GeneralSoftGrudger changed to cover edge cases. edge case tests included

Author: eric-s-s

axelrod/strategies/grudger.py

@@ -63,11 +63,11 @@ def __init__(self) -> None:
     def strategy(self, opponent: Player) -> Action:
         """Begins by playing C, then plays D for mem_length rounds if the
         opponent ever plays D."""
-        if self.grudge_memory >= self.mem_length:
+        if self.grudge_memory == self.mem_length:
             self.grudge_memory = 0
             self.grudged = False
 
-        if not self.grudged and D in opponent.history[-1:]:
+        if D in opponent.history[-1:]:
             self.grudged = True
 
         if self.grudged:
@@ -284,7 +284,7 @@ def __init__(self, n: int=1, d: int=4, c: int=2) -> None:
         self.n = n
         self.d = d
         self.c = c
-        self.grudge = [D] * (d - 1) + [C] * c
+        self.grudge = [D] * d + [C] * c
         self.grudged = False
         self.grudge_memory = 0
 
@@ -294,16 +294,18 @@ def strategy(self, opponent: Player) -> Action:
         The punishment is in the form of 'd' defections followed by a penance of
         'c' consecutive cooperations.
         """
+        if self.grudge_memory == len(self.grudge):
+            self.grudged = False
+            self.grudge_memory = 0
+
+        if [D] * self.n == opponent.history[-self.n:] or self.n == 0:
+            self.grudged = True
+
         if self.grudged:
             strategy = self.grudge[self.grudge_memory]
             self.grudge_memory += 1
-            if self.grudge_memory == len(self.grudge):
-                self.grudged = False
-                self.grudge_memory = 0
             return strategy
-        elif [D] * self.n == opponent.history[-self.n:]:
-            self.grudged = True
-            return D
+
         return C
 
     def reset(self):

axelrod/tests/strategies/test_grudger.py

@@ -288,6 +288,7 @@ def test_set_n(self):
                          init_kwargs=init_kwargs)
 
     def test_set_d_and_c(self):
+        # Sets the number of D's then C's in the grudge response.
         init_kwargs = {'d': 3, 'c': 3}
         grudge_response_d = [(D, D)] * 3 + [(C, D)] * 3
         grudge_response_c = [(D, C)] * 3 + [(C, C)] * 3
@@ -305,6 +306,53 @@ def test_set_d_and_c(self):
         self.versus_test(opponent, expected_actions=actions,
                          init_kwargs=init_kwargs)
 
+    def test_edge_case_n_is_zero(self):
+        # Always uses grudge response.
+        init_kwargs = {'n': 0}
+        grudge_response_d = [(D, D)] * 4 + [(C, D)] * 2
+        grudge_response_c = [(D, C)] * 4 + [(C, C)] * 2
+
+        opponent = axl.Defector()
+        actions = grudge_response_d * 5
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+        opponent = axl.Cooperator()
+        actions = grudge_response_c * 5
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+    def test_edge_case_d_is_zero(self):
+        # Grudge response is only C, so acts like Cooperator.
+        init_kwargs = {'d': 0}
+
+        opponent = axl.Defector()
+        actions = [(C, D)] * 5
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+        opponent = axl.Alternator()
+        actions = [(C, C), (C, D)] * 5
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+    def test_edge_case_c_is_zero(self):
+        # Grudge response is a set number of D's (defaults to 4)
+        init_kwargs = {'c': 0}
+
+        opponent = axl.Defector()
+        actions = [(C, D)] + [(D, D)] * 10
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+        opponent_actions = [C] * 10 + [D]
+        opponent = axl.MockPlayer(actions=opponent_actions)
+        actions_start = [(C, C)] * 10 + [(C, D)]
+        subsequent = [(D, C)] * 4 + [(C, C)] * 6 + [(C, D)]
+        actions = actions_start + subsequent * 5
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
     def test_repr(self):
         default_player = self.player()
         self.assertEqual(repr(default_player),