Update many tests with new random seeds and values, up to axelrod_first.py

Author: marcharper

axelrod/player.py

@@ -3,6 +3,7 @@
 import itertools
 import types
 from typing import Any, Dict
+import warnings
 
 import numpy as np
 
@@ -121,7 +122,9 @@ def set_match_attributes(self, length=-1, game=None, noise=0):
     def set_seed(self, seed=None):
         """Set a random seed for the player's random number generator."""
         if seed is None:
-            # Warning: using global seed
+            warnings.warn(
+                "Initializing player with seed from Axelrod module random number generator."
+                " Results may not be seed reproducible.")
             self._seed = _module_random.random_seed_int()
         else:
             self._seed = seed

axelrod/strategies/axelrod_first.py

@@ -745,15 +745,8 @@ class FirstByTullock(Player):
     }
 
     def __init__(self) -> None:
-        """
-        Parameters
-        ----------
-        rounds_to_cooperate: int
-           The number of rounds to cooperate initially
-        """
         super().__init__()
         self._rounds_to_cooperate = 11
-        self.memory_depth = self._rounds_to_cooperate
 
     def strategy(self, opponent: Player) -> Action:
         if len(self.history) < self._rounds_to_cooperate:

axelrod/tests/integration/test_filtering.py

@@ -21,6 +21,7 @@ def setUp(self) -> None:
     def tearDown(self) -> None:
         warnings.simplefilter("default", category=UserWarning)
 
+    @settings(deadline=None)
     @given(strategies=strategy_lists(min_size=20, max_size=20))
     def test_boolean_filtering(self, strategies):
 

axelrod/tests/integration/test_matches.py

@@ -47,7 +47,7 @@ def test_outcome_repeats_stochastic(self, strategies, turns, seed):
         results = []
         for _ in range(3):
             players = [s() for s in strategies]
-            results.append(axelrod.Match(players, turns=turns, seed=seed).play())
+            results.append(axl.Match(players, turns=turns, seed=seed).play())
 
         self.assertEqual(results[0], results[1])
         self.assertEqual(results[1], results[2])

axelrod/tests/integration/test_tournament.py

@@ -164,7 +164,7 @@ def test_matches_have_different_length(self):
         p2 = axl.Cooperator()
         p3 = axl.Cooperator()
         players = [p1, p2, p3]
-        tournament = axelrod.Tournament(players, prob_end=0.5, repetitions=2, seed=3)
+        tournament = axl.Tournament(players, prob_end=0.5, repetitions=2, seed=3)
         results = tournament.play(progress_bar=False)
         # Check that match length are different across the repetitions
         self.assertNotEqual(results.match_lengths[0], results.match_lengths[1])

axelrod/tests/strategies/test_adaptor.py

@@ -29,13 +29,13 @@ def test_strategy(self):
         # Error corrected.
         actions = [(C, C), (C, D), (D, C), (C, C)]
         self.versus_test(
-            opponent=axl.AdaptorBrief(), expected_actions=actions, seed=22
+            opponent=axl.AdaptorBrief(), expected_actions=actions, seed=245
         )
 
         # Error corrected, example 2
         actions = [(D, C), (C, D), (D, C), (C, D), (C, C)]
         self.versus_test(
-            opponent=axl.AdaptorBrief(), expected_actions=actions, seed=925
+            opponent=axl.AdaptorBrief(), expected_actions=actions, seed=7935
         )
 
         # Versus Cooperator
@@ -74,7 +74,7 @@ def test_strategy(self):
         # Error corrected.
         actions = [(C, C), (C, D), (D, D), (C, C), (C, C)]
         self.versus_test(
-            opponent=axl.AdaptorLong(), expected_actions=actions, seed=22
+            opponent=axl.AdaptorLong(), expected_actions=actions, seed=305
         )
 
         # Versus Cooperator

axelrod/tests/strategies/test_averagecopier.py

@@ -45,19 +45,19 @@ def test_strategy(self):
             (C, D),
             (C, C),
             (D, D),
-            (D, C),
+            (C, C),
             (C, D),
         ]
         self.versus_test(axl.Alternator(), expected_actions=actions, seed=1)
 
         actions = [
             (D, C),
             (C, D),
-            (D, C),
+            (C, C),
             (C, D),
             (C, C),
             (D, D),
-            (D, C),
+            (C, C),
             (D, D),
             (C, C),
             (D, D),
@@ -73,9 +73,9 @@ def test_strategy(self):
             (D, D),
             (C, D),
             (D, C),
-            (D, C),
-            (D, D),
+            (C, C),
             (D, D),
+            (C, D),
         ]
         self.versus_test(opponent, expected_actions=actions, seed=1)
 
@@ -85,12 +85,12 @@ def test_strategy(self):
             (C, C),
             (C, C),
             (C, D),
-            (D, D),
+            (C, D),
             (C, D),
             (C, C),
             (D, C),
-            (D, C),
-            (D, D),
+            (C, C),
+            (C, D),
         ]
         self.versus_test(opponent, expected_actions=actions, seed=2)
 
@@ -126,22 +126,22 @@ def test_strategy(self):
             (D, D),
             (D, C),
             (C, D),
-            (C, C),
+            (D, C),
             (C, D),
             (D, C),
-            (D, D),
+            (C, D),
         ]
         self.versus_test(axl.Alternator(), expected_actions=actions, seed=1)
 
         actions = [
             (C, C),
             (C, D),
             (D, C),
-            (D, D),
-            (C, C),
             (C, D),
             (D, C),
-            (D, D),
+            (C, D),
+            (D, C),
+            (C, D),
             (D, C),
             (C, D),
         ]
@@ -155,7 +155,7 @@ def test_strategy(self):
             (C, D),
             (D, D),
             (D, D),
-            (C, C),
+            (D, C),
             (D, C),
             (C, D),
             (D, D),
@@ -168,11 +168,11 @@ def test_strategy(self):
             (C, C),
             (C, C),
             (C, D),
-            (D, D),
-            (D, D),
-            (C, C),
+            (C, D),
+            (C, D),
+            (D, C),
             (C, C),
             (D, C),
-            (D, D),
+            (C, D),
         ]
         self.versus_test(opponent, expected_actions=actions, seed=2)

axelrod/tests/strategies/test_axelrod_first.py

@@ -127,10 +127,10 @@ def test_decay(self):
             self.assertEqual(player._cooperation_probability(), player._end_coop_prob)
 
     def test_strategy(self):
-        actions = [(C, C)] * 41 + [(D, C)]
+        actions = [(C, C)] * 13 + [(D, C)]
         self.versus_test(axl.Cooperator(), expected_actions=actions, seed=1)
 
-        actions = [(C, C)] * 16 + [(D, C)]
+        actions = [(C, C)] * 11 + [(D, C)]
         self.versus_test(axl.Cooperator(), expected_actions=actions, seed=2)
 
         actions = [(C, D)] + [(D, D)] * 20
@@ -163,19 +163,19 @@ def test_strategy(self):
         actions += [(D, C)]  # 51 turns
         actions += [(C, D), (D, C)] * 2 + [(C, D)]  # 56 turns
         self.versus_test(
-            axl.Alternator(), expected_actions=actions, attrs=expected_attrs
+            axl.Alternator(), expected_actions=actions, attrs=expected_attrs, seed=0
         )
 
         # Against defector
         actions = [(C, D)] + [(D, D)] * 55  # 56 turns
         self.versus_test(
-            axl.Defector(), expected_actions=actions, attrs=expected_attrs
+            axl.Defector(), expected_actions=actions, attrs=expected_attrs, seed=0
         )
 
         # Against cooperator
         actions = [(C, C)] * 50 + [(D, C)] + [(C, C)] * 5
         self.versus_test(
-            axl.Cooperator(), expected_actions=actions, attrs=expected_attrs
+            axl.Cooperator(), expected_actions=actions, attrs=expected_attrs, seed=0
         )
 
         # Test recognition of random player
@@ -185,12 +185,12 @@ def test_strategy(self):
         }
         actions = [(C, C)] * 50 + [(D, C)] + [(C, C)] * 5  # 56 turns
         self.versus_test(
-            axl.Cooperator(), expected_actions=actions, attrs=expected_attrs
+            axl.Cooperator(), expected_actions=actions, attrs=expected_attrs, seed=1
         )
-        expected_attrs = {"opponent_is_random": False, "next_random_defection_turn": 68}
+        expected_attrs = {"opponent_is_random": False, "next_random_defection_turn": 63}
         actions += [(C, C)]  # 57 turns
         self.versus_test(
-            axl.Cooperator(), expected_actions=actions, attrs=expected_attrs
+            axl.Cooperator(), expected_actions=actions, attrs=expected_attrs, seed=8
         )
 
         expected_attrs = {
@@ -202,11 +202,11 @@ def test_strategy(self):
         actions += [(C, D), (D, C)] * 3  # 57 turns
         actions += [(D, D)]
         self.versus_test(
-            axl.Alternator(), expected_actions=actions, attrs=expected_attrs
+            axl.Alternator(), expected_actions=actions, attrs=expected_attrs, seed=3
         )
         actions += [(D, C), (D, D)] * 5
         self.versus_test(
-            axl.Alternator(), expected_actions=actions, attrs=expected_attrs
+            axl.Alternator(), expected_actions=actions, attrs=expected_attrs, seed=4
         )
 
         # Test versus TfT
@@ -222,16 +222,16 @@ def test_strategy(self):
         )
 
         # Test random defections
-        expected_attrs = {"opponent_is_random": False, "next_random_defection_turn": 78}
-        actions = [(C, C)] * 50 + [(D, C)] + [(C, C)] * 16 + [(D, C)] + [(C, C)]
+        expected_attrs = {"opponent_is_random": False, "next_random_defection_turn": 76}
+        actions = [(C, C)] * 50 + [(D, C)] + [(C, C)] * 15 + [(D, C)] + [(C, C)]
         self.versus_test(
             axl.Cooperator(), expected_actions=actions, seed=0, attrs=expected_attrs
         )
 
-        expected_attrs = {"opponent_is_random": False, "next_random_defection_turn": 77}
-        actions = [(C, C)] * 50 + [(D, C)] + [(C, C)] * 12 + [(D, C)] + [(C, C)]
+        expected_attrs = {"opponent_is_random": False, "next_random_defection_turn": 79}
+        actions = [(C, C)] * 50 + [(D, C)] + [(C, C)] * 14 + [(D, C)] + [(C, C)]
         self.versus_test(
-            axl.Cooperator(), expected_actions=actions, seed=1, attrs=expected_attrs
+            axl.Cooperator(), expected_actions=actions, seed=5, attrs=expected_attrs
         )
 
 
@@ -251,17 +251,17 @@ class TestFirstByGrofman(TestPlayer):
 
     def test_strategy(self):
         actions = [(C, C)] * 7
-        self.versus_test(axl.Cooperator(), expected_actions=actions)
+        self.versus_test(axl.Cooperator(), expected_actions=actions, seed=0)
 
         actions = [(C, C), (C, D), (D, C)]
-        self.versus_test(axl.Alternator(), expected_actions=actions)
+        self.versus_test(axl.Alternator(), expected_actions=actions, seed=0)
 
         opponent = axl.MockPlayer(actions=[D] * 8)
-        actions = [(C, D), (C, D), (D, D), (C, D), (D, D), (C, D), (C, D), (D, D)]
+        actions = [(C, D), (C, D), (D, D), (C, D), (D, D), (C, D), (D, D), (C, D)]
         self.versus_test(opponent, expected_actions=actions, seed=1)
 
         opponent = axl.MockPlayer(actions=[D] * 8)
-        actions = [(C, D), (D, D), (C, D), (D, D), (C, D), (C, D), (C, D), (D, D)]
+        actions = [(C, D), (D, D), (C, D), (D, D), (C, D), (D, D), (C, D), (C, D)]
         self.versus_test(opponent, expected_actions=actions, seed=2)
 
 
@@ -284,10 +284,10 @@ def test_four_vector(self):
         test_four_vector(self, expected_dictionary)
 
     def test_strategy(self):
-        actions = [(C, C), (C, C), (C, C), (C, C)]
+        actions = [(C, C), (C, C), (C, C), (D, C)]
         self.versus_test(axl.Cooperator(), expected_actions=actions, seed=1)
 
-        actions = [(C, C), (D, C), (D, C), (C, C)]
+        actions = [(C, C), (C, C), (C, C), (C, C)]
         self.versus_test(axl.Cooperator(), expected_actions=actions, seed=2)
 
         actions = [(C, D), (D, D), (D, D), (D, D)]
@@ -424,22 +424,10 @@ def test_strategy(self):
         self.versus_test(opponent, expected_actions=actions)
 
         # Test beyond 10 rounds
-        opponent = axl.MockPlayer(actions=[D] * 5 + [C] * 6)
-        actions = [(C, D)] * 5 + [(C, C)] * 6 + [(D, D)] * 4
+        opponent = axl.MockPlayer(actions=[D] * 5 + [C] * 5 + [C, D] * 5)
+        actions = [(C, D)] * 5 + [(C, C)] * 6 + [(D, D)] + [(D, C), (C, D), (C, C)]
         self.versus_test(opponent, expected_actions=actions, seed=20)
 
-        opponent = axl.MockPlayer(actions=[D] * 5 + [C] * 6)
-        actions = [(C, D)] * 5 + [(C, C)] * 6 + [(C, D), (D, D), (D, D), (C, D)]
-        self.versus_test(opponent, expected_actions=actions, seed=1)
-
-        opponent = axl.MockPlayer(actions=[C] * 9 + [D] * 2)
-        actions = [(C, C)] * 9 + [(C, D)] * 2 + [(C, C), (D, C), (D, C), (C, C)]
-        self.versus_test(opponent, expected_actions=actions, seed=1)
-
-        opponent = axl.MockPlayer(actions=[C] * 9 + [D] * 2)
-        actions = [(C, C)] * 9 + [(C, D)] * 2 + [(D, C), (D, C), (C, C), (C, C)]
-        self.versus_test(opponent, expected_actions=actions, seed=2)
-
 
 class TestFirstByAnonymous(TestPlayer):
 
@@ -456,10 +444,10 @@ class TestFirstByAnonymous(TestPlayer):
     }
 
     def test_strategy(self):
-        actions = [(D, C), (C, C), (C, C), (D, C), (C, C), (C, C)]
+        actions = [(D, C), (C, C), (C, C), (C, C), (D, C), (C, C)]
         self.versus_test(axl.Cooperator(), expected_actions=actions, seed=1)
 
-        actions = [(C, C), (C, C), (D, C), (C, C), (C, C), (D, C)]
+        actions = [(D, C), (D, C), (D, C), (C, C), (D, C), (D, C)]
         self.versus_test(axl.Cooperator(), expected_actions=actions, seed=10)
 
 

axelrod/tests/strategies/test_player.py

@@ -10,11 +10,8 @@
 import axelrod as axl
 from axelrod.tests.property import strategy_lists
 
-
 C, D = axl.Action.C, axl.Action.D
-
 random = axl.RandomGenerator()
-
 short_run_time_short_mem = [
     s
     for s in axl.short_run_time_strategies
@@ -487,7 +484,7 @@ def test_clone(self, seed):
             axl.Cooperator(),
             axl.Defector(),
             axl.TitForTat(),
-            axl.Random(p=r),
+            axl.Random(p=0.5),
         ]:
             for p in [player1, player2]:
                 m = axl.Match((p, op), turns=turns, reset=True, seed=seed)
@@ -687,7 +684,6 @@ def test_memory(player, opponent, memory_length, seed=0, turns=10):
     opponent.reset()
     player._history = axl.LimitedHistory(memory_length)
     opponent._history = axl.LimitedHistory(memory_length)
-    axl.seed(seed)
     match = axl.Match((player, opponent), turns=turns, reset=False, seed=seed)
     limited_plays = [p[0] for p in match.play()]