Review all commits

Fix bug - reverse self.turned_defector condition.
Refine docstring.
Tweak formatting.
Update parameter name in reset method.

Rewrite tests to loop over set of histories.

Author: margaret

axelrod/strategies/prober.py

@@ -104,11 +104,15 @@ def strategy(self, opponent):
 
 class Prober4(Player):
     """
-    Plays fixed initial sequence of 20 moves.
-    Counts just (retaliated) and unjust defections of the opponent.
-    If the absolute difference between just and unjust defections
-    is greater than 2, defects forever.
-    Otherwise cooperates for the next 5 moves, and plays TFT afterwards.
+    Plays C, C, D, C, D, D, D, C, C, D, C, D, C, C, D, C, D, D, C, D initially.
+    Counts retaliating and provocative defections of the opponent.
+    If the absolute difference between the counts is smaller or equal to 2,
+    defects forever.
+    Otherwise plays C for the next 5 turns and TFT for the rest of the game.
+
+    Names:
+
+    - prober4: [PRISON1998]_
     """
 
     name = 'Prober 4'
@@ -125,18 +129,19 @@ class Prober4(Player):
     @init_args
     def __init__(self):
         Player.__init__(self)
-        self.init_sequence = [C, C, D, C, D, D, D, C, C, D,
-                              C, D, C, C, D, C, D, D, C, D]
+        self.init_sequence = [
+            C, C, D, C, D, D, D, C, C, D, C, D, C, C, D, C, D, D, C, D
+        ]
         self.just_Ds = 0
         self.unjust_Ds = 0
-        self.cooperation_pool = 5 * [C]
+        self.cooperation_pool = [C] * 5
         self.turned_defector = False
 
     def strategy(self, opponent):
         if len(opponent.history) == 0:
-            return C
+            return self.init_sequence[0]
         if len(self.history) == 0:
-            return C
+            return self.init_sequence[0]
         else:
             turn = len(self.history)
             if turn < len(self.init_sequence):
@@ -148,7 +153,7 @@ def strategy(self, opponent):
                 return self.init_sequence[turn]
             if turn == len(self.init_sequence):
                 diff_in_Ds = abs(self.just_Ds - self.unjust_Ds)
-                self.turned_defector = (diff_in_Ds > 2)
+                self.turned_defector = (diff_in_Ds <= 2)
             if self.turned_defector:
                 return D
             if not self.turned_defector:
@@ -161,8 +166,8 @@ def reset(self):
         Player.reset(self)
         self.just_Ds = 0
         self.unjust_Ds = 0
-        self.cooperation_pool = [C, C, C, C, C]
-        self.became_defector = False
+        self.cooperation_pool = [C] * 5
+        self.turned_defector = False
 
 
 class HardProber(Player):

axelrod/tests/unit/test_prober.py

@@ -112,56 +112,64 @@ class TestProber4(TestPlayer):
         'manipulates_source': False,
         'manipulates_state': False
     }
-    initial_sequence = [C, C, D, C, D, D, D, C, C, D,
-                        C, D, C, C, D, C, D, D, C, D]
+    initial_sequence = [
+        C, C, D, C, D, D, D, C, C, D, C, D, C, C, D, C, D, D, C, D
+    ]
     cooperation_pool = [C] * 5
 
     def test_initial_strategy(self):
         """Starts by playing CCDCDDDCCDCDCCDCDDCD."""
         self.responses_test([], [], self.initial_sequence)
 
     def test_strategy(self):
-        # Defects forever if the opponent played D for C
-        # at least 3 times more than D for D
-        history1 = self.initial_sequence
-        history2 = self.initial_sequence
-        responses = [D] * 10
-        self.responses_test(history1, history2, responses)
+        # After playing the initial sequence defects forever
+        # if the absolute difference in the number of retaliating
+        # and provocative defections of the opponent is smaller or equal to 2
+
+        provocative_histories = [
+            [C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C],
+            [C, D, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C],
+            [C, D, C, D, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C],
+            [C, C, D, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C],
+            [C, C, D, C, D, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C],
+            [D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D],
+        ]
 
-        # or if the opponent played D for D
-        # at least 3 times more than D for C
         history1 = self.initial_sequence
-        history2 = list(map(lambda x: D if x is C else C,
-                            self.initial_sequence))
         responses = [D] * 10
-        self.responses_test(history1, history2, responses)
+        for history2 in provocative_histories:
+            self.responses_test(history1, history2, responses)
 
         # Otherwise cooperates for 5 rounds
+        unprovocative_histories = [
+            [C, C, D, C, D, D, D, C, C, D, C, D, C, C, D, C, D, D, C, D],
+            [D, D, C, D, C, C, C, D, D, C, D, C, D, D, C, D, C, C, D, C],
+            [C, C, D, C, D, D, C, C, C, C, C, C, C, C, C, C, C, C, C, C],
+            [C, C, D, C, D, D, C, C, D, C, C, C, C, C, C, D, D, D, C, C],
+            [C, C, C, C, D, D, C, C, D, C, C, D, D, C, D, C, D, C, C, C],
+        ]
+
         history1 = self.initial_sequence
-        history2 = [C] * len(history1)
         responses = self.cooperation_pool
-        self.responses_test(history1, history2, responses)
+        for history2 in unprovocative_histories:
+            self.responses_test(history1, history2, responses)
 
         # and plays like TFT afterwards
-        history1 = self.initial_sequence + self.cooperation_pool
-        history2 = [C] * (len(history1) - 1) + [D]
-        self.responses_test(history1, history2, [D])
-
-        history1 = self.initial_sequence + self.cooperation_pool + [D]
-        history2 = [C] * len(history1)
-        self.responses_test(history1, history2, [C])
+            history1 += self.cooperation_pool
+            history2 += self.cooperation_pool
+            self.responses_test(history1, history2, [C])
 
-        history1 = self.initial_sequence + self.cooperation_pool
-        history2 = [C] * len(history1)
-        self.responses_test(history1, history2, [C])
+            history1 += [C]
+            history2 += [D]
+            self.responses_test(history1, history2, [D])
 
-        history1 = self.initial_sequence + self.cooperation_pool + [C]
-        history2 = [C] * (len(history1) - 1) + [D]
-        self.responses_test(history1, history2, [D])
+            history1 += [D]
+            history2 += [C]
+            self.responses_test(history1, history2, [C])
 
-        history1 = self.initial_sequence + self.cooperation_pool + [C]
-        history2 = [C] * (len(history1) - 1) + [D]
-        self.responses_test(history1, history2, [D])
+            history1 += [C]
+            history2 += [D]
+            self.responses_test(history1, history2, [D])
 
 
 class TestHardProber(TestPlayer):