Fix docstrings, remove comments, and update a few tests based on round 1 of review

Author: marcharper

axelrod/tests/integration/test_filtering.py

@@ -92,9 +92,7 @@ def test_memory_depth_filtering(
         filtered = set(axl.filtered_strategies(filterset, strategies=strategies))
         self.assertEqual(comprehension, filtered)
 
-    @given(seed_=integers(min_value=0, max_value=4294967295),
-           strategies=strategy_lists(min_size=20, max_size=20),
-           )
+    @given(strategies=strategy_lists(min_size=20, max_size=20))
     @settings(max_examples=5, deadline=None)
     def test_makes_use_of_filtering(self, strategies):
         """

axelrod/tests/strategies/test_calculator.py

@@ -23,7 +23,7 @@ class TestCalculator(TestPlayer):
     }
 
     def test_twenty_rounds_joss_for_cyclers(self):
-        """Uses axelrod.strategies.axelrod_first.Joss strategy for first 20 rounds"""
+        """Uses axelrod.strategies.axelrod_first.FirstByJoss strategy for first 20 rounds"""
         seed = 4
         match = axl.Match((axl.FirstByJoss(), axl.Alternator()), turns=20, seed=seed)
         match.play()
@@ -32,7 +32,7 @@ def test_twenty_rounds_joss_for_cyclers(self):
         )
 
     def test_twenty_rounds_joss_then_defects_for_cyclers(self):
-        """Uses axelrod.strategies.axelrod_first.Joss strategy for first 20 rounds"""
+        """Uses axelrod.strategies.axelrod_first.FirstByJoss strategy for first 20 rounds"""
         seed = 4
         match = axl.Match((axl.FirstByJoss(), axl.Alternator()), turns=20, seed=seed)
         match.play()
@@ -42,7 +42,7 @@ def test_twenty_rounds_joss_then_defects_for_cyclers(self):
         )
 
     def test_twenty_rounds_joss_for_noncyclers(self):
-        """Uses axelrod.strategies.axelrod_first.Joss strategy for first 20 rounds"""
+        """Uses axelrod.strategies.axelrod_first.FirstByJoss strategy for first 20 rounds"""
         seed = 4
         match = axl.Match((axl.FirstByJoss(), axl.AntiCycler()), turns=20, seed=seed)
         match.play()
@@ -51,7 +51,7 @@ def test_twenty_rounds_joss_for_noncyclers(self):
         )
 
     def test_twenty_rounds_joss_then_tft_for_noncyclers(self):
-        """Uses axelrod.strategies.axelrod_first.Joss strategy for first 20 rounds"""
+        """Uses axelrod.strategies.axelrod_first.FirstByJoss strategy for first 20 rounds"""
         seed = 4
         match = axl.Match((axl.FirstByJoss(), axl.AntiCycler()), turns=20, seed=seed)
         match.play()

axelrod/tests/strategies/test_human.py

@@ -130,6 +130,3 @@ def test_repr(self):
 
     def equality_of_players_test(self, p1, p2, seed, opponent):
         return True
-
-    def test_reproducibility_of_play(self):
-        return True

axelrod/tests/strategies/test_memorytwo.py

@@ -255,7 +255,7 @@ def test_strategy(self):
 
 
 class TestMemoryTwoCooperator(TestCooperator):
-    """Cooperator is equivalent to MemoryOnePlayer((1, 1, 1, 1), C)"""
+    """Cooperator is equivalent to MemoryTwoPlayer((1, 1, ..., 1), C)"""
     name = "Generic Memory Two Player: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], (C, C)"
     player = lambda x: axl.MemoryTwoPlayer(sixteen_vector=[1] * 16, initial=(C, C))
     expected_classifier = {
@@ -270,7 +270,7 @@ class TestMemoryTwoCooperator(TestCooperator):
 
 
 class TestMemoryTwoDefector(TestDefector):
-    """Defector is equivalent to MemoryOnePlayer((0, 0, 0, 0), D)"""
+    """Defector is equivalent to MemoryTwoPlayer((0, 0, ..., 0), D)"""
     name = "Generic Memory Two Player: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], (D, D)"
     player = lambda x: axl.MemoryTwoPlayer(sixteen_vector=[0] * 16, initial=(D, D))
     expected_classifier = {
@@ -291,10 +291,9 @@ def four_vector_to_sixteen_vector(four_vector):
 
 
 class TestMemoryTwoAlternator(TestAlternator):
-    """Alternator is equivalent to MemoryOnePlayer((0, 0, 1, 1), C)"""
+    """Alternator is equivalent to MemoryTwoPlayer(0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1), C)."""
     name = "Generic Memory Two Player: [0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1], (C, D)"
     player = lambda x: axl.MemoryTwoPlayer(sixteen_vector=four_vector_to_sixteen_vector((0, 0, 1, 1)), initial=(C, D))
-    # player = lambda x: axl.MemoryTwoPlayer(sixteen_vector=four_vector_to_sixteen_vector((1, 1, 0, 0)), initial=(C, D))
     expected_classifier = {
         "memory_depth": 1,
         "stochastic": False,

axelrod/tests/strategies/test_meta.py

@@ -180,9 +180,8 @@ def test_stochasticity(self):
         player = axl.MetaWinnerEnsemble(team=team)
         self.assertTrue(Classifiers["stochastic"](player))
 
-        # If the players are all identical, a multiplayer
-        # team might is in fact deterministic, even though random values
-        # are being drawn.
+        # If the players are all identical, a multiplayer team might in fact
+        # be deterministic, even though random values are being drawn.
         team = [axl.Cooperator, axl.Cooperator]
         player = axl.MetaWinnerEnsemble(team=team)
         self.assertFalse(Classifiers["stochastic"](player))

axelrod/tests/strategies/test_player.py

@@ -656,8 +656,8 @@ def versus_test(
                 self.assertEqual(getattr(player1, attr), value)
 
     def search_seeds(self, *args, **kwargs):  # pragma: no cover
-        """Search for a seed that will pass the test. To use to find a new seed
-        for a versus_test, change self.versus_test to self.search_seeds
+        """Search for a seed that will pass the test. Use to find a new seed
+        for a versus_test by changing self.versus_test to self.search_seeds
         within a TestPlayer or TestMatch class.
         """
         for seed in range(1, 100000):

axelrod/tests/strategies/test_titfortat.py

@@ -669,7 +669,7 @@ def test_output_from_literature(self):
         ]
 
         turns = 1000
-        tournament = axl.Tournament(players, turns=turns, repetitions=1, seed=1)
+        tournament = axl.Tournament(players, turns=turns, repetitions=1, seed=75)
         results = tournament.play(progress_bar=False)
         scores = [
             round(average_score_per_turn * 1000, 1)
@@ -678,7 +678,7 @@ def test_output_from_literature(self):
         expected_scores = [
             3000.0,
             915.0,
-            2756.0,
+            2763.0,
             3000.0,
             3000.0,
             2219.0,
@@ -1031,7 +1031,7 @@ class Test1TitsFor1TatsIsTFT(TestTitForTat):
 
 
 class Test1TitsFor2TatsIsTF2T(TestTitFor2Tats):
-    """Tests that for N = 1 = M, all the TFT tests are passed."""
+    """Tests that for N = 1,  M = 2, all the TF2T tests are passed."""
     name = "N Tit(s) For M Tat(s): 1, 2"
     player = lambda x: axl.NTitsForMTats(1, 2)
     expected_classifier = {
@@ -1045,8 +1045,8 @@ class Test1TitsFor2TatsIsTF2T(TestTitFor2Tats):
     }
 
 
-class Test2TitsFor1TatsIsT2FT(TestTwoTitsForTat):
-    """Tests that for N = 1 = M, all the TFT tests are passed."""
+class Test2TitsFor1TatsIs2TFT(TestTwoTitsForTat):
+    """Tests that for N = 2,  M = 1, all the 2TFT tests are passed."""
     name = "N Tit(s) For M Tat(s): 2, 1"
     player = lambda x: axl.NTitsForMTats(2, 1)
     expected_classifier = {