Extend testing of MuPlusLambda class

Add tests for single function of MuPlusLambda class
Co-authored-by: Jakob Jordan <1562742+jakobj@users.noreply.github.com>

test/test_ea_mu_plus_lambda.py

@@ -28,7 +28,7 @@ def objective_with_label(individual, label):
     assert pop.champion.fitness == pytest.approx(-1.0)
 
 
-def test_fitness_contains_and_maintains_nan(population_params, genome_params):
+def test_fitness_contains_and_maintains_nan(population_params, genome_params, ea_params):
     def objective(individual):
         if np.random.rand() < 0.95:
             individual.fitness = np.nan
@@ -38,21 +38,23 @@ def objective(individual):
 
     pop = cgp.Population(**population_params, genome_params=genome_params)
 
-    ea = cgp.ea.MuPlusLambda(10, 10, 1)
+    ea = cgp.ea.MuPlusLambda(**ea_params)
     ea.initialize_fitness_parents(pop, objective)
     ea.step(pop, objective)
 
     assert np.nan in [ind.fitness for ind in pop]
 
 
-def test_offspring_individuals_are_assigned_correct_indices(population_params, genome_params):
+def test_offspring_individuals_are_assigned_correct_indices(
+    population_params, genome_params, ea_params
+):
     def objective(ind):
         ind.fitness = 0.0
         return ind
 
     pop = cgp.Population(**population_params, genome_params=genome_params)
 
-    ea = cgp.ea.MuPlusLambda(10, 10, 1)
+    ea = cgp.ea.MuPlusLambda(**ea_params)
     ea.initialize_fitness_parents(pop, objective)
 
     offsprings = ea._create_new_offspring_generation(pop)
@@ -62,16 +64,17 @@ def objective(ind):
 
 
 def test_offspring_individuals_are_assigned_correct_parent_indices(
-    population_params, genome_params
+    population_params, genome_params, ea_params
 ):
     def objective(ind):
         ind.fitness = 0.0
         return ind
 
     population_params["n_parents"] = 1
+
     pop = cgp.Population(**population_params, genome_params=genome_params)
 
-    ea = cgp.ea.MuPlusLambda(10, 10, 1)
+    ea = cgp.ea.MuPlusLambda(**ea_params)
     ea.initialize_fitness_parents(pop, objective)
 
     offsprings = ea._create_new_offspring_generation(pop)
@@ -113,7 +116,7 @@ def objective(ind):
     pop = cgp.Population(**population_params, genome_params=genome_params)
 
     local_search = functools.partial(
-        cgp.local_search.gradient_based, objective=inner_objective, **local_search_params,
+        cgp.local_search.gradient_based, objective=inner_objective, **local_search_params
     )
 
     ea = cgp.ea.MuPlusLambda(5, 5, 1, local_search=local_search, k_local_search=k_local_search)
@@ -125,3 +128,100 @@ def objective(ind):
 
     for idx in range(k_local_search, population_params["n_parents"]):
         assert pop[idx].genome._parameter_names_to_values["<p1>"] == pytest.approx(1.0)
+
+
+def test_raise_n_offsprings_less_than_n_breeding():
+    n_offsprings = 10
+    n_breeding = 5
+    with pytest.raises(ValueError):
+        cgp.ea.MuPlusLambda(n_offsprings, n_breeding, 1)
+
+
+def test_raise_fitness_has_wrong_type(population_params, genome_params, ea_params):
+    def objective(individual):
+        individual.fitness = int(5.0)  # should raise error since fitness should be float
+        return individual
+
+    pop = cgp.Population(**population_params, genome_params=genome_params)
+    ea = cgp.ea.MuPlusLambda(**ea_params)
+    ea.initialize_fitness_parents(pop, objective)
+
+    with pytest.raises(ValueError):
+        ea.step(pop, objective)
+
+
+def test_initialize_fitness_parents(population_params, genome_params, ea_params):
+    def objective(individual):
+        individual.fitness = -1.0
+        return individual
+
+    pop = cgp.Population(**population_params, genome_params=genome_params)
+
+    ea = cgp.ea.MuPlusLambda(**ea_params)
+    ea.initialize_fitness_parents(pop, objective)
+    assert all([ind.fitness is not None for ind in pop.parents])
+
+
+def test_step(population_params, genome_params, ea_params):
+    def objective(individual):
+        individual.fitness = float(individual.idx)
+        return individual
+
+    pop = cgp.Population(**population_params, genome_params=genome_params)
+
+    ea = cgp.ea.MuPlusLambda(**ea_params)
+    ea.initialize_fitness_parents(pop, objective)
+    old_parent_ids = sorted([ind.idx for ind in pop.parents])
+    ea.step(pop, objective)
+    new_parent_ids = sorted([ind.idx for ind in pop.parents])
+    # After one step, the new parent population should have IDs that
+    # are offset from the old parent ids by n_offsprings
+    # This is by construction in this test because the fitness is equal to the id
+    assert all(
+        [
+            new_id == old_id + ea_params["n_offsprings"]
+            for new_id, old_id in zip(new_parent_ids, old_parent_ids)
+        ]
+    )
+
+
+def test_sort(population_params, genome_params, ea_params):
+    def objective(individual):
+        individual.fitness = float(individual.idx)
+        return individual
+
+    pop = cgp.Population(**population_params, genome_params=genome_params)
+    ea = cgp.ea.MuPlusLambda(**ea_params)
+    ea.initialize_fitness_parents(pop, objective)
+    sorted_parents = ea._sort(pop.parents)
+    # Assert that the sorting inverted the list of parents (because the fitness is equal to the id)
+    assert sorted_parents == pop.parents[::-1]
+
+
+def test_create_new_offspring_and_parent_generation(population_params, genome_params, ea_params):
+    def objective(individual):
+        individual.fitness = float(individual.idx)
+        return individual
+
+    pop = cgp.Population(**population_params, genome_params=genome_params)
+    ea = cgp.ea.MuPlusLambda(**ea_params)
+
+    ea.initialize_fitness_parents(pop, objective)
+
+    offsprings = ea._create_new_offspring_generation(pop)
+    assert len(offsprings) == ea_params["n_offsprings"]
+    assert all([ind.idx >= pop.n_parents for ind in offsprings])
+    # Assert that all offspring dna are different from all parents dna
+    offspring_dna = [ind.genome.dna for ind in offsprings]
+    parent_dna = [ind.genome.dna for ind in pop.parents]
+    assert all([odna != pdna for odna in offspring_dna for pdna in parent_dna])
+
+
+def test_create_new_parent_population(population_params, genome_params, ea_params):
+    pop = cgp.Population(**population_params, genome_params=genome_params)
+    ea = cgp.ea.MuPlusLambda(**ea_params)
+
+    # Create new parent population from the parents and assert that
+    # we picked the first three individuals
+    new_parents = ea._create_new_parent_population(3, pop.parents)
+    assert new_parents == pop.parents[:3]