Fix many more tests

marcharper · marcharper · commit b2dc6cd262f4 · 2020-04-20T23:19:36.000-07:00
diff --git a/axelrod/evolvable_player.py b/axelrod/evolvable_player.py
@@ -22,6 +22,7 @@ class EvolvablePlayer(Player):
 
     def __init__(self, seed=None):
         super().__init__()
+        # if set_seed:
         self.set_seed(seed=seed)
 
     def overwrite_init_kwargs(self, **kwargs):
diff --git a/axelrod/strategies/cycler.py b/axelrod/strategies/cycler.py
@@ -111,11 +111,9 @@ def __init__(
         mutation_potency: int = 1,
         seed: int = None
     ) -> None:
-        self.set_seed(seed=seed)
+        EvolvablePlayer.__init__(self, seed=seed)
         cycle, cycle_length = self._normalize_parameters(cycle, cycle_length)
-        # The following __init__ sets self.cycle = cycle
         Cycler.__init__(self, cycle=cycle)
-        EvolvablePlayer.__init__(self)
         # Overwrite init_kwargs in the case that we generated a new cycle from cycle_length
         self.overwrite_init_kwargs(
             cycle=cycle,
@@ -162,7 +160,7 @@ def crossover(self, other) -> EvolvablePlayer:
         cycle_list = crossover_lists(self.cycle, other.cycle, self._random)
         cycle = "".join(cycle_list)
         cycle, _ = self._normalize_parameters(cycle)
-        return self.create_new(cycle=cycle)
+        return self.create_new(cycle=cycle, seed=self._random.random_seed_int())
 
 
 class CyclerDC(Cycler):
diff --git a/axelrod/strategies/darwin.py b/axelrod/strategies/darwin.py
@@ -3,7 +3,6 @@
 indicated by their classifier). We do not recommend putting a lot of time in to
 optimising it.
 """
-from collections import defaultdict
 from typing import Optional
 
 from axelrod.action import Action
diff --git a/axelrod/tests/strategies/test_better_and_better.py b/axelrod/tests/strategies/test_better_and_better.py
@@ -23,72 +23,29 @@ class TestBetterAndBetter(TestPlayer):
 
     def test_strategy(self):
         """Tests that the strategy gives expected behaviour."""
+        expected_actions = [(D, D)] * 90 + [(C, D)]
         self.versus_test(
             axl.Defector(),
-            expected_actions=[
-                (D, D),
-                (D, D),
-                (D, D),
-                (D, D),
-                (C, D),
-                (D, D),
-                (D, D),
-                (D, D),
-                (D, D),
-            ],
+            expected_actions=expected_actions,
             seed=6,
         )
+        expected_actions = [(D, C)] * 10
         self.versus_test(
             axl.Cooperator(),
-            expected_actions=[
-                (D, C),
-                (D, C),
-                (D, C),
-                (D, C),
-                (D, C),
-                (D, C),
-                (D, C),
-                (D, C),
-                (D, C),
-            ],
+            expected_actions=expected_actions,
             seed=8,
         )
+        expected_actions = [(D, D)] * 41 + [(C, D)]
         self.versus_test(
             axl.Defector(),
-            expected_actions=[
-                (C, D),
-                (D, D),
-                (D, D),
-                (D, D),
-                (D, D),
-                (D, D),
-                (D, D),
-                (D, D),
-                (D, D),
-            ],
-            seed=1514,
+            expected_actions=expected_actions,
+            seed=13,
         )
-        actions = []
-        for index in range(200):
-            if index in [
-                64,
-                79,
-                91,
-                99,
-                100,
-                107,
-                111,
-                119,
-                124,
-                127,
-                137,
-                141,
-                144,
-                154,
-                192,
-                196,
-            ]:
-                actions.append((C, D))
-            else:
-                actions.append((D, D))
-        self.versus_test(axl.Defector(), expected_actions=actions, seed=8)
+        expected_indices = [18, 39, 49, 67, 77, 116, 139, 142, 149]
+        m = axl.Match((self.player(), axl.Defector()), turns=150, seed=111)
+        result = m.play()
+        indices = []
+        for index, actions in enumerate(result):
+            if actions == (C, D):
+                indices.append(index)
+        self.assertEqual(expected_indices, indices)
diff --git a/axelrod/tests/strategies/test_cycler.py b/axelrod/tests/strategies/test_cycler.py
@@ -180,20 +180,20 @@ def test_normalized_parameters(self):
     def test_crossover_even_length(self):
         cycle1 = "C" * 6
         cycle2 = "D" * 6
-        cross_cycle = "CCCDDD"
+        cross_cycle = "CCCCCD"
 
-        player1 = self.player_class(cycle=cycle1, seed=3)
-        player2 = self.player_class(cycle=cycle2)
+        player1 = self.player_class(cycle=cycle1, seed=4)
+        player2 = self.player_class(cycle=cycle2, seed=5)
         crossed = player1.crossover(player2)
         self.assertEqual(cross_cycle, crossed.cycle)
 
     def test_crossover_odd_length(self):
         cycle1 = "C" * 7
         cycle2 = "D" * 7
-        cross_cycle = "CCCDDDD"
+        cross_cycle = "CCDDDDD"
 
-        player1 = self.player_class(cycle=cycle1, seed=5)
-        player2 = self.player_class(cycle=cycle2)
+        player1 = self.player_class(cycle=cycle1, seed=6)
+        player2 = self.player_class(cycle=cycle2, seed=7)
         crossed = player1.crossover(player2)
         self.assertEqual(cross_cycle, crossed.cycle)
 
diff --git a/axelrod/tests/strategies/test_geller.py b/axelrod/tests/strategies/test_geller.py
@@ -67,7 +67,7 @@ def test_returns_foil_inspection_strategy_of_opponent(self):
         self.versus_test(axl.Darwin(), expected_actions=[(C, C), (C, C), (C, C)], seed=3)
 
         self.versus_test(
-            axelrod.MindReader(), expected_actions=[(D, D), (D, D), (D, D)], seed=1
+            axl.MindReader(), expected_actions=[(D, D), (D, D), (D, D)], seed=1
         )
 
 
diff --git a/axelrod/tests/strategies/test_headsup.py b/axelrod/tests/strategies/test_headsup.py
@@ -56,7 +56,7 @@ def test_rounds(self):
         self.versus_test(
             axl.ZDGTFT2(),
             axl.Bully(),
-            [C, D, D, C, C, C],
+            [C, D, D, C, C, D],
             [D, D, C, C, D, D],
             seed=2,
         )
@@ -69,9 +69,9 @@ def test_rounds(self):
         self.versus_test(
             axl.ZDExtort2(),
             axl.TitForTat(),
-            [C, D, D, D, D, D],
-            [C, C, D, D, D, D],
-            seed=2,
+            [C, D, C, D, D, D],
+            [C, C, D, C, D, D],
+            seed=100,
         )
 
 
diff --git a/axelrod/tests/strategies/test_hmm.py b/axelrod/tests/strategies/test_hmm.py
@@ -187,7 +187,7 @@ class TestEvolvedHMM5(TestPlayer):
 
     def test_strategy(self):
         actions = [(C, C), (C, D), (D, C), (D, D), (D, C)]
-        self.versus_test(opponent=axl.Alternator(), expected_actions=actions)
+        self.versus_test(opponent=axl.Alternator(), expected_actions=actions, seed=2)
 
 
 class TestEvolvedHMM5vsCooperator(TestMatch):
diff --git a/axelrod/tests/strategies/test_inverse.py b/axelrod/tests/strategies/test_inverse.py
@@ -23,24 +23,15 @@ class TestInverse(TestPlayer):
 
     def test_strategy(self):
         # Test that as long as the opponent has not defected the player will
-        # cooperate.
-        self.versus_test(axl.Cooperator(), expected_actions=[(C, C)])
-
-        # Tests that if opponent has played all D then player chooses D.
-        self.versus_test(axl.Defector(), expected_actions=[(C, D)] + [(D, D)] * 9)
-
-        expected_actions = [
-            (C, D),
-            (D, C),
-            (D, C),
-            (D, D),
-            (D, C),
-            (C, C),
-            (C, C),
-            (C, C),
-            (C, D),
-            (D, D),
-        ]
+        # cooperate, regardless of the random seed.
+        self.versus_test(axl.Cooperator(), expected_actions=[(C, C)], seed=None)
+
+        # Tests that if opponent has played all D then player chooses D,
+        # regardless of the random seed.
+        self.versus_test(axl.Defector(), expected_actions=[(C, D)] + [(D, D)] * 9, seed=None)
+
+        expected_actions = [(C, D), (D, C), (D, C), (C, D), (D, C), (C, C),
+                            (D, C), (C, C), (C, D), (D, D)]
         self.versus_test(
             axl.MockPlayer(actions=[a[1] for a in expected_actions]),
             expected_actions=expected_actions,
diff --git a/axelrod/tests/strategies/test_memorytwo.py b/axelrod/tests/strategies/test_memorytwo.py
@@ -153,7 +153,7 @@ class TestMemoryStochastic(TestPlayer):
     }
 
     def test_strategy(self):
-        rng = axelrod.RandomGenerator(seed=7888)
+        rng = axl.RandomGenerator(seed=7888)
         vector = [rng.random() for _ in range(16)]
 
         actions = [(C, C), (C, C), (D, D), (C, C), (D, C), (D, D), (D, C)]
diff --git a/axelrod/tests/strategies/test_player.py b/axelrod/tests/strategies/test_player.py
@@ -2,6 +2,8 @@
 import itertools
 import pickle
 import types
+import warnings
+
 import numpy as np
 
 from hypothesis import given, settings
@@ -452,45 +454,34 @@ def test_reset_clone(self):
         clone = player.clone()
         self.assertEqual(player, clone)
 
-    def test_reproducibility_of_play(self):
-        player = self.player()
-        player_clone = player.clone()
-        coplayer = axl.Random(0.5)
-        coplayer_clone = coplayer.clone()
-        m1 = axl.Match((player, coplayer), turns=10, seed=10)
-        m2 = axl.Match((player_clone, coplayer_clone), turns=10, seed=10)
-        m1.play()
-        m2.play()
-        self.assertEqual(m1.result, m2.result)
-
-    @given(seed=integers(min_value=1, max_value=20000000))
-    @settings(max_examples=1)
-    def test_clone(self, seed):
+    @given(seed=integers(min_value=1, max_value=20000000),
+           turns=integers(min_value=5, max_value=10),
+           noise=integers(min_value=0, max_value=10))
+    @settings(max_examples=1, deadline=None)
+    def test_clone_reproducible_play(self, seed, turns, noise):
         # Test that the cloned player produces identical play
-        player1 = self.player()
-        if player1.name in ["Darwin", "Human"]:
+        player = self.player()
+        if player.name in ["Darwin", "Human"]:
             # Known exceptions
             return
-        player2 = player1.clone()
-        self.assertEqual(len(player2.history), 0)
-        self.assertEqual(player2.cooperations, 0)
-        self.assertEqual(player2.defections, 0)
-        self.assertEqual(player2.state_distribution, {})
-        self.assertEqual(player2.classifier, player1.classifier)
-        self.assertEqual(player2.match_attributes, player1.match_attributes)
 
-        turns = 5
         for op in [
             axl.Cooperator(),
             axl.Defector(),
             axl.TitForTat(),
             axl.Random(p=0.5),
         ]:
-            for p in [player1, player2]:
-                m = axl.Match((p, op), turns=turns, reset=True, seed=seed)
-                m.play()
-            self.assertEqual(len(player1.history), turns)
-            self.assertEqual(player1.history, player2.history)
+            player = self.player()
+            player_clone = player.clone()
+            op = op.clone()
+            op_clone = op.clone()
+            m1 = axl.Match((player, op), turns=turns, seed=seed, noise=noise/100.)
+            m2 = axl.Match((player_clone, op_clone), turns=turns, seed=seed, noise=noise/100.)
+            m1.play()
+            m2.play()
+            self.assertEqual(m1.result, m2.result)
+            self.assertEqual(player, player_clone)
+            self.assertEqual(op, op_clone)
 
     @given(
         strategies=strategy_lists(
@@ -582,6 +573,10 @@ def versus_test(
             match_attributes=match_attributes,
             seed=seed
         )
+        if match._stochastic and (seed is None):
+            warnings.warn(
+                "Test Match in TestPlayer.versus_test is stochastic "
+                "but no random seed was given.")
         self.assertEqual(match.play(), expected_actions)
 
         if attrs:
@@ -645,8 +640,12 @@ def versus_test(
             raise ValueError("Mismatched History lengths.")
         turns = len(expected_actions1)
         match = axl.Match((player1, player2), turns=turns, noise=noise, seed=seed)
-        match.play()
-        self.assertEqual(match.result, list(zip(expected_actions1, expected_actions2)))
+        if match._stochastic and (seed is None):
+            warnings.warn(
+                "Test Match in TestMatch.versus_test is stochastic "
+                "but no random seed was given.")
+        result = match.play()
+        self.assertEqual(result, list(zip(expected_actions1, expected_actions2)))
 
     def test_versus_with_incorrect_history_lengths(self):
         """Test the error raised by versus_test if expected actions do not
diff --git a/axelrod/tests/strategies/test_rand.py b/axelrod/tests/strategies/test_rand.py
@@ -28,7 +28,7 @@ def test_strategy(self):
         self.versus_test(opponent, expected_actions=actions, seed=1)
 
         opponent = axl.MockPlayer()
-        actions = [(D, C), (D, C), (C, C)]
+        actions = [(D, C), (C, C), (D, C)]
         self.versus_test(opponent, expected_actions=actions, seed=2)
 
         opponent = axl.MockPlayer()
diff --git a/axelrod/tests/strategies/test_titfortat.py b/axelrod/tests/strategies/test_titfortat.py

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ def test_returns_foil_inspection_strategy_of_opponent(self):`
`67`	`67`	`self.versus_test(axl.Darwin(), expected_actions=[(C, C), (C, C), (C, C)], seed=3)`
`68`	`68`
`69`	`69`	`self.versus_test(`
`70`		`- axelrod.MindReader(), expected_actions=[(D, D), (D, D), (D, D)], seed=1`
	`70`	`+ axl.MindReader(), expected_actions=[(D, D), (D, D), (D, D)], seed=1`
`71`	`71`	`)`
`72`	`72`
`73`	`73`
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,7 @@ class TestMemoryStochastic(TestPlayer):`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`def test_strategy(self):`
`156`		`- rng = axelrod.RandomGenerator(seed=7888)`
	`156`	`+ rng = axl.RandomGenerator(seed=7888)`
`157`	`157`	`vector = [rng.random() for _ in range(16)]`
`158`	`158`
`159`	`159`	`actions = [(C, C), (C, C), (D, D), (C, C), (D, C), (D, D), (D, C)]`