Add new tests and update some existing tests

Author: marcharper

src/axelrod_fortran/player.py

@@ -45,7 +45,7 @@ def __init__(self, original_name):
         self.index, self.shared_library_filename = \
             shared_library_manager.get_filename_for_player(original_name)
         self.shared_library = load_library(self.shared_library_filename)
-        self.original_name = original_name
+        self.__original_name = original_name
         self.original_function = self.original_name
         is_stochastic = characteristics[self.original_name]['stochastic']
         if is_stochastic is not None:

src/axelrod_fortran/shared_library_manager.py

@@ -59,7 +59,7 @@ def create_library_copy(self):
         # Copy the library file to a new (temp) location.
         temp_directory = tempfile.gettempdir()
         copy_number = len(self.filenames)
-        filename =  "{}-{}-{}".format(
+        filename = "{}-{}-{}".format(
             self.prefix,
             str(copy_number),
             self.shared_library_name)

src/axelrod_fortran/strategies.py

@@ -348,7 +348,7 @@
         'original_rank': None},
 }
 
-all_strategies = characteristics.keys()
+all_strategies = list(characteristics.keys())
 
 # Players from Axelrod's second tournament.
 second_tournament_strategies = [

tests/test_player.py

@@ -5,7 +5,7 @@
 
 from axelrod_fortran import Player, characteristics, all_strategies
 from axelrod import (Alternator, Cooperator, Defector, Match, MoranProcess,
-                     Game, basic_strategies, seed)
+                     Game, RandomGenerator, Tournament, basic_strategies)
 from axelrod.action import Action
 
 
@@ -22,7 +22,7 @@ def test_init():
             POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int),
             POINTER(c_float))
         assert player.original_function.restype == c_int
-        with pytest.raises(ValueError):
+        with pytest.raises(AttributeError):
             player = Player('test')
 
 
@@ -122,16 +122,22 @@ def test_implemented_strategies():
     """
     for strategy, dictionary in characteristics.items():
         axelrod_class = dictionary["axelrod-python_class"]
-        player = Player(strategy)
-        if (axelrod_class is not None and
-            player.classifier["stochastic"] is False):
-            axl_player = axelrod_class()
+        stochastic = Player(strategy).classifier["stochastic"]
+        if axelrod_class is not None and not stochastic:
             for opponent_strategy in basic_strategies:
+                player = Player(strategy)
                 opponent = opponent_strategy()
                 match = Match((player, opponent))
                 interactions = match.play()
+
+                axl_player = axelrod_class()
+                opponent = opponent_strategy()
                 axl_match = Match((axl_player, opponent))
-                assert interactions == axl_match.play(), (player, opponent)
+                axl_interactions = axl_match.play()
+                print(player, axl_player, opponent)
+                print(interactions)
+                print(axl_interactions)
+                assert interactions == axl_interactions
 
 
 def test_champion_v_alternator():
@@ -140,15 +146,12 @@ def test_champion_v_alternator():
     """
     player = Player("k61r")
     opponent = Alternator()
-
     match = Match((player, opponent))
 
-    seed(0)
-    interactions = match.play()
+    seed = 0
+    interactions = match.play(seed=seed)
     assert interactions[25:30] == [(C, D), (C, C), (C, D), (D, C), (C, D)]
-
-    seed(0)
-    assert interactions == match.play()
+    assert interactions == match.play(seed=seed)
 
 
 def test_warning_for_self_interaction(recwarn):
@@ -157,9 +160,7 @@ def test_warning_for_self_interaction(recwarn):
     """
     player = Player("k42r")
     opponent = player
-
     match = Match((player, opponent))
-
     interactions = match.play()
     assert len(recwarn) == 1
 
@@ -168,13 +169,10 @@ def test_no_warning_for_normal_interaction(recwarn):
     """
     Test that a warning is not given for a normal interaction
     """
-    player = Player("k42r")
-    opponent = Alternator()
     for players in [(Player("k42r"), Alternator()),
                     (Player("k42r"), Player("k41r"))]:
 
         match = Match(players)
-
         interactions = match.play()
         assert len(recwarn) == 0
 
@@ -185,3 +183,44 @@ def test_multiple_copies(recwarn):
     mp = MoranProcess(players)
     mp.play()
     mp.populations_plot()
+
+
+def test_match_reproducibility():
+    for _ in range(10):
+        rng = RandomGenerator()
+        seed = rng.random_seed_int()
+        strategies = rng.choice(all_strategies, size=2)
+        print(strategies)
+        players1 = [Player(strategy) for strategy in strategies]
+        # players1 = (p() for p in strategies)
+        match1 = Match(players1, turns=200, noise=0.1, seed=seed)
+        results1 = match1.play()
+        players2 = [Player(strategy) for strategy in strategies]
+        # players2 = (p() for p in strategies)
+        match2 = Match(players2, turns=200, noise=0.1, seed=seed)
+        results2 = match2.play()
+        assert (results1 == results2)
+
+
+def test_tournament_reproducibility():
+    rng = RandomGenerator()
+    seed = rng.random_seed_int()
+    strategies = rng.choice(all_strategies, size=2)
+    players1 = [Player(strategy) for strategy in strategies]
+    tournament1 = Tournament(players1, seed=seed, repetitions=2)
+    results1 = tournament1.play(processes=2)
+
+    players2 = [Player(strategy) for strategy in strategies]
+    tournament2 = Tournament(players2, seed=seed, repetitions=2)
+    results2 = tournament2.play(processes=2)
+
+    assert (results1.ranked_names == results2.ranked_names)
+
+
+if __name__ == "__main__":
+    test_init()
+    test_matches()
+    test_noisy_matches()
+    test_implemented_strategies()
+    test_match_reproducibility()
+    test_tournament_reproducibility()