Adjust tests to cover left out lines

Author: marcharper

axelrod/evolvable_player.py

@@ -29,7 +29,7 @@ def create_new(self, **kwargs):
         init_kwargs.update(kwargs)
         return self.__class__(**init_kwargs)
 
-    # Serialization and Deserialization to strings. You may overwrite to obtain more human readable serializations
+    # Serialization and deserialization. You may overwrite to obtain more human readable serializations
     # but you must overwrite both.
 
     def serialize_parameters(self):

axelrod/strategies/ann.py

@@ -227,7 +227,7 @@ class EvolvableANN(ANN, EvolvablePlayer):
     def __init__(
         self, num_features: int, num_hidden: int,
         weights: List[float] = None,
-        mutation_probability: float = 0.1,
+        mutation_probability: float = None,
         mutation_distance: int = 5,
     ) -> None:
         num_features, num_hidden, weights, mutation_probability = self._normalize_parameters(
@@ -274,7 +274,8 @@ def mutate(self):
         return self.create_new(weights=weights)
 
     def crossover(self, other):
-        # Assuming that the number of states is the same
+        if not isinstance(other, self.__class__):
+            raise TypeError("Crossover must be between the same player classes.")
         weights = crossover_lists(self.weights, other.weights)
         return self.create_new(weights=weights)
 

axelrod/strategies/cycler.py

@@ -152,13 +152,13 @@ def mutate(self):
         cycle, _ = self._normalize_parameters(cycle)
         return self.create_new(cycle=cycle)
 
-    def crossover(self, other_cycler):
+    def crossover(self, other):
         """
         Creates and returns a new Player instance with a single crossover point.
         """
-        if not isinstance(other_cycler, self.__class__):
-            raise TypeError
-        cycle_list = crossover_lists(self.cycle, other_cycler.cycle)
+        if not isinstance(other, self.__class__):
+            raise TypeError("Crossover must be between the same player classes.")
+        cycle_list = crossover_lists(self.cycle, other.cycle)
         cycle = "".join(cycle_list)
         cycle, _ = self._normalize_parameters(cycle)
         return self.create_new(cycle=cycle)

axelrod/strategies/finite_state_machines.py

@@ -249,7 +249,8 @@ def crossover_rows(rows1, rows2):
         return new_rows
 
     def crossover(self, other):
-        # Assuming that the number of states is the same
+        if not isinstance(other, self.__class__):
+            raise TypeError("Crossover must be between the same player classes.")
         transitions = self.crossover_rows(self.fsm.transitions(), other.fsm.transitions())
         transitions = self.normalize_transitions(transitions)
         return self.create_new(transitions=transitions)

axelrod/strategies/hmm.py

@@ -45,7 +45,7 @@ def normalize_vector(vec):
     s = sum(vec)
     if s == 0.0:
         n = len(vec)
-        return [1 / n for v in vec]
+        return [1. / n for v in vec]
     vec = [v / s for v in vec]
     return vec
 
@@ -307,7 +307,8 @@ def mutate(self):
         )
 
     def crossover(self, other):
-        # Assuming that the number of states is the same
+        if not isinstance(other, self.__class__):
+            raise TypeError("Crossover must be between the same player classes.")
         transitions_C = crossover_lists_of_lists(self.hmm.transitions_C, other.hmm.transitions_C)
         transitions_D = crossover_lists_of_lists(self.hmm.transitions_D, other.hmm.transitions_D)
         emission_probabilities = crossover_lists(

axelrod/strategies/lookerup.py

@@ -501,6 +501,8 @@ def mutate(self):
         )
 
     def crossover(self, other):
+        if not isinstance(other, self.__class__):
+            raise TypeError("Crossover must be between the same player classes.")
         lookup_dict = crossover_dictionaries(self.lookup_dict, other.lookup_dict)
         return self.create_new(lookup_dict=lookup_dict)
 

axelrod/tests/strategies/test_evolvable_player.py

@@ -29,19 +29,11 @@ def crossover(self, other):
         value = self.value + other.value
         return EvolvableTestOpponent(value)
 
-    def serialize_parameters(self):
-        return str(self.value)
-
-    @classmethod
-    def deserialize_parameters(cls, value):
-        return EvolvableTestOpponent(int(value))
-
 
 class TestEvolvablePlayer(TestPlayer):
 
     player_class = EvolvableTestOpponent
     init_parameters = dict()
-    randomized = False
 
     def player(self):
         return self.player_class(**self.init_parameters)
@@ -56,8 +48,8 @@ def test_initialisation(self):
 
     def test_randomization(self):
         """Test that randomization on initialization produces different strategies."""
-        if not self.randomized:
-            return True
+        if self.init_parameters:
+            return
         seed(0)
         player1 = self.player()
         seed(0)
@@ -70,24 +62,24 @@ def test_randomization(self):
                 return
         self.assertFalse(True)
 
-    def test_mutate(self):
+    def test_mutate_variations(self):
         """Test that mutate produces different strategies."""
         seed(0)
         player = self.player()
-        for seed_ in range(2, 20):
+        variants_produced = False
+        for seed_ in range(2, 200):
             seed(seed_)
             mutant = player.clone().mutate()
             if player != mutant:
-                return
-        self.assertFalse(True)
+                variants_produced = True
+        self.assertFalse(variants_produced)
 
     def test_mutate_and_clone(self):
         """Test that mutated players clone properly."""
         seed(0)
         player = self.player()
         mutant = player.clone().mutate()
         clone = mutant.clone()
-        # compare_dicts(mutant.__dict__, clone.__dict__)
         self.assertEqual(clone, mutant)
 
     def test_crossover(self):
@@ -106,13 +98,17 @@ def test_crossover(self):
                 return
         self.assertFalse(True)
 
+    def test_crossover_mismatch(self):
+        player = self.player()
+        other = EvolvableTestOpponent()
+        self.assertRaises(TypeError, self.player_class.crossover, other=other)
+
     def test_serialization(self):
         """Serializing and deserializing should return the original player."""
         seed(0)
         player = self.player()
         serialized = player.serialize_parameters()
         deserialized_player = player.__class__.deserialize_parameters(serialized)
-        # compare_dicts(player.__dict__, deserialized_player.__dict__)
         self.assertEqual(player, deserialized_player)
         self.assertEqual(deserialized_player, deserialized_player.clone())