Add sufficient rounds to test strategies.

Author: drvinceknight

axelrod/strategies/resurrection.py

@@ -6,18 +6,20 @@
 
 class Resurrection(Player):
     """
-    A player starts by cooperating and defects if the number of rounds 
-    played by the player is greater than five and the last five rounds are defections.
+    A player starts by cooperating and defects if the number of rounds
+    played by the player is greater than five and the last five rounds
+    are defections.
+
     Otherwise, the strategy plays like Tit-for-tat.
-    
+
     Names:
-    - Resurrection: Name from CoopSim https://github.com/jecki/CoopSim     
+    - Resurrection: Name from CoopSim https://github.com/jecki/CoopSim
     """
 
     # These are various properties for the strategy
     name = 'Resurrection'
     classifier = {
-        'memory_depth': 1,  
+        'memory_depth': 5,
         'stochastic': False,
         'makes_use_of': set(),
         'long_run_time': False,
@@ -33,20 +35,22 @@ def strategy(self, opponent: Player) -> Action:
             return D
         else:
             return opponent.history[-1]
-        
+
 class DoubleResurrection(Player):
     """
-    A player starts by cooperating and defects if the number of rounds 
-    played by the player is greater than five and the last five rounds are cooperations.
+    A player starts by cooperating and defects if the number of rounds
+    played by the player is greater than five and the last five rounds
+    are cooperations.
+
     If the last five rounds were defections, the player cooperates.
-    
+
     Names:
-    - DoubleResurrection: Name from CoopSim https://github.com/jecki/CoopSim     
+    - DoubleResurrection: Name from CoopSim https://github.com/jecki/CoopSim
     """
 
     name = 'DoubleResurrection'
     classifier = {
-        'memory_depth': 1,  
+        'memory_depth': 5,
         'stochastic': False,
         'makes_use_of': set(),
         'long_run_time': False,

axelrod/tests/strategies/test_resurrection.py

@@ -9,7 +9,7 @@ class Resurrection(TestPlayer):
     name = "Resurrection"
     player = axelrod.Resurrection
     expected_classifier = {
-        'memory_depth': 1,
+        'memory_depth': 5,
         'stochastic': False,
         'makes_use_of': set(),
         'long_run_time': False,
@@ -21,25 +21,24 @@ class Resurrection(TestPlayer):
     def test_strategy(self):
         # Starts by Cooperating
         self.first_play_test(C)
-        
-        # Check if the turns played are greater than 5 
-        self.responses_test([D], [D, C, C, D, D, D, D, D] , [C] * 8)
-        
-        #Check if turns played are less than 5.
-        self.responses_test([C], [D, C, D, C], [C] * 4)
-        
+
+        # Check if the turns played are greater than 5
+        actions = [(C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C)]
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions)
+
+        actions = [(C, D), (D, D), (D, D), (D, D), (D, D), (D, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions)
+
         # Check for TFT behavior after 5 rounds
-        self.responses_test([C], [C] * 5, [C, C, C, C, C, D])
-        
-        # Check for four defections and a cooperation by opponent
-        self.responses_test([D], [C] * 5, [D, D, D, D, D, C])
-        
+        actions = [(C, C), (C, D), (D, C), (C, D), (D, C), (C, D), (D, C)]
+        self.versus_test(axelrod.Alternator(), expected_actions=actions)
+
 class TestDoubleResurrection(TestPlayer):
 
     name = "DoubleResurrection"
     player = axelrod.DoubleResurrection
     expected_classifier = {
-        'memory_depth': 1,
+        'memory_depth': 5,
         'stochastic': False,
         'makes_use_of': set(),
         'long_run_time': False,
@@ -51,12 +50,12 @@ class TestDoubleResurrection(TestPlayer):
     def test_strategy(self):
         # Starts by Cooperating
         self.first_play_test(C)
-        
-        actions = [(C, C), (C, D), (D, C), (C, D), (D, C)]
+
+        actions = [(C, C), (C, D), (D, C), (C, D), (D, C), (C, D)]
         self.versus_test(axelrod.Alternator(), expected_actions=actions)
 
-        actions = [(C, C), (C, C), (C, C), (C, C), (C, C)]
+        actions = [(C, C), (C, C), (C, C), (C, C), (C, C), (D, C)]
         self.versus_test(axelrod.Cooperator(), expected_actions=actions)
 
-        actions = [(C, D), (D, D), (D, D), (D, D), (D, D)]
+        actions = [(C, D), (D, D), (D, D), (D, D), (D, D), (D, D), (C, D)]
         self.versus_test(axelrod.Defector(), expected_actions=actions)

docs/tutorials/advanced/classification_of_strategies.rst

@@ -57,7 +57,7 @@ make a decision::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    28
+    27
 
 Multiple filters can be specified within the filterset dictionary. To specify a
 range of memory_depth values, we can use the 'min_memory_depth' and
@@ -69,7 +69,7 @@ range of memory_depth values, we can use the 'min_memory_depth' and
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    50
+    49
 
 We can also identify strategies that make use of particular properties of the
 tournament. For example, here is the number of strategies that  make use of the