Add more tests to Prober4

Tweak Prober4 property names

Author: margaret

axelrod/strategies/prober.py

@@ -104,7 +104,7 @@ def strategy(self, opponent):
 
 class Prober4(Player):
     """
-    Plays initial sequence of 20 fixed moves.
+    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.
@@ -129,8 +129,8 @@ def __init__(self):
                               C, D, C, C, D, C, D, D, C, D]
         self.just_Ds = 0
         self.unjust_Ds = 0
-        self.politeness_pool = [C, C, C, C, C]
-        self.is_naughty = False
+        self.cooperation_pool = 5 * [C]
+        self.turned_defector = False
 
     def strategy(self, opponent):
         if len(opponent.history) == 0:
@@ -148,21 +148,21 @@ 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.is_naughty = (diff_in_Ds > 2)
-            if self.is_naughty:
+                self.turned_defector = (diff_in_Ds > 2)
+            if self.turned_defector:
                 return D
-            if not self.is_naughty:
-                if self.politeness_pool:
-                    return self.politeness_pool.pop()
+            if not self.turned_defector:
+                if self.cooperation_pool:
+                    return self.cooperation_pool.pop()
                 else:
-                    return D if opponent.history[-1:] == [D] else C
+                    return D if opponent.history[-1] == D else C
 
     def reset(self):
         Player.reset(self)
         self.just_Ds = 0
         self.unjust_Ds = 0
-        self.politeness_pool = [C, C, C, C, C]
-        self.is_angry = False
+        self.cooperation_pool = [C, C, C, C, C]
+        self.became_defector = False
 
 
 class HardProber(Player):

axelrod/tests/unit/test_prober.py

@@ -104,8 +104,8 @@ class TestProber4(TestPlayer):
     name = "Prober 4"
     player = axelrod.Prober4
     expected_classifier = {
-        'memory_depth': 1,
         'stochastic': False,
+        'memory_depth': 1,
         'makes_use_of': set(),
         'long_run_time': False,
         'inspects_source': False,
@@ -114,24 +114,54 @@ class TestProber4(TestPlayer):
     }
     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 opponent played D for C
-        # at least 3 more times than D for D
-        self.responses_test(self.initial_sequence,
-                            self.initial_sequence, [D] * 10)
-
-        # Defects forever if opponent played D for D
-        # at least 3 more times than C for D
-        opponents_history = list(map(lambda x: D if x is C else C,
-                                     self.initial_sequence))
-
-        self.responses_test(self.initial_sequence,
-                            opponents_history, [D] * 10)
+        # 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)
+
+        # 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)
+
+        # Otherwise cooperates for 5 rounds
+        history1 = self.initial_sequence
+        history2 = [C] * len(history1)
+        responses = self.cooperation_pool
+        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.initial_sequence + self.cooperation_pool
+        history2 = [C] * len(history1)
+        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 = self.initial_sequence + self.cooperation_pool + [C]
+        history2 = [C] * (len(history1) - 1) + [D]
+        self.responses_test(history1, history2, [D])
 
 
 class TestHardProber(TestPlayer):