import unittest
import numpy as np
import importlib

# --- Defining Constants ---
X_MIN, X_MAX = 0, 6
TARGET_X = 3.0
TARGET_FITNESS = 10.0

def _dynamic_test(test_case, condition, success_message, failure_message):
    """Helper function to dynamically pass/fail tests."""
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestGeneticAlgorithm(unittest.TestCase):
    
    @classmethod
    def setUpClass(cls):
        """Importing the user's code and running the GA."""
        global user_code
        try:
            user_code = importlib.import_module("user_code")
            # Running the GA to get the results for testing
            cls.best_x, cls.best_fitness = user_code.genetic_algorithm()
        except ImportError:
            cls.fail("Could not import user_code.py. Make sure the file exists.")
        except Exception as e:
            cls.fail(f"Error running genetic_algorithm(): {e}")

    def test_return_types(self):
        """Checking if the GA returns values with the correct types."""
        # Checking best_x type
        condition_x = isinstance(self.best_x, (float, np.float64))
        _dynamic_test(
            self,
            condition_x,
            "The returned `best_x` is a float.",
            f"The returned `best_x` should be a float, but got {type(self.best_x)}."
        )
        
        # Checking best_fitness type
        condition_f = isinstance(self.best_fitness, (float, np.float64))
        _dynamic_test(
            self,
            condition_f,
            "The returned `best_fitness` is a float.",
            f"The returned `best_fitness` should be a float, but got {type(self.best_fitness)}."
        )

    def test_solution_in_range(self):
        """Checking if the solution `best_x` is within the valid [0, 6] range."""
        condition = X_MIN <= self.best_x <= X_MAX
        _dynamic_test(
            self,
            condition,
            f"The solution `best_x` ({self.best_x:.4f}) is within the [{X_MIN}, {X_MAX}] range.",
            f"The solution `best_x` ({self.best_x:.4f}) is outside the valid [{X_MIN}, {X_MAX}] range."
        )

    def test_solution_optimality(self):
        """Checking if the solution is very close to the known optimum (x=3, f=10)."""
        # Due to random seeds, the result is deterministic and should be very close.
        
        # Checking x value
        # We allow a small tolerance
        condition_x = np.isclose(self.best_x, TARGET_X, atol=0.01)
        _dynamic_test(
            self,
            condition_x,
            f"The solution `best_x` ({self.best_x:.4f}) is very close to the target {TARGET_X}.",
            f"The solution `best_x` ({self.best_x:.4f}) is not close enough to the target {TARGET_X}."
        )
        
        # Checking fitness value
        # The fitness should be *very* close to 10.0
        condition_f = np.isclose(self.best_fitness, TARGET_FITNESS, atol=1e-4)
        _dynamic_test(
            self,
            condition_f,
            f"The solution `best_fitness` ({self.best_fitness:.4f}) is very close to the target {TARGET_FITNESS}.",
            f"The solution `best_fitness` ({self.best_fitness:.4f}) is not close enough to the target {TARGET_FITNESS}."
        )
        
    def test_fitness_function_correctness(self):
        """Checking if the fitness_function calculates the correct value at the peak."""
        # This test checks the helper function directly
        peak_fitness = user_code.fitness_function(3.0)
        condition = np.isclose(peak_fitness, 10.0)
        _dynamic_test(
            self,
            condition,
            "The `fitness_function(3.0)` correctly returns 10.0.",
            f"The `fitness_function(3.0)` returned {peak_fitness}, but should be 10.0."
        )

if __name__ == "__main__":
    unittest.main(argv=['first-arg-is-ignored'], exit=False)

test_main.py

Explore the foundations and practical applications of bio-inspired algorithms in Python. This course covers evolutionary computation, swarm intelligence, and other nature-inspired optimization techniques, using only standard Python and permitted scientific libraries.

Understand the motivation, history, and core principles behind bio-inspired computation, including evolution, adaptation, and swarm intelligence.

Dive into the structure, operators, and parameter tuning of genetic algorithms.

Investigate algorithms inspired by collective behavior in nature, including ants, particles, and other swarms.

Explore the principles and algorithms inspired by the biological immune system, including negative selection and clonal selection.

Challenge: Build a Genetic Algorithm

Ratkaisu

Awesome!

Challenge: Build a Genetic Algorithm

Ratkaisu