re-did gobymajority test

Author: eric-s-s

axelrod/tests/strategies/test_gobymajority.py

@@ -11,8 +11,7 @@ class TestHardGoByMajority(TestPlayer):
 
     name = "Hard Go By Majority"
     player = axelrod.HardGoByMajority
-    eq_play = D
-    soft = False
+    default_soft = False
 
     expected_classifier = {
         'stochastic': False,
@@ -24,60 +23,77 @@ class TestHardGoByMajority(TestPlayer):
         'manipulates_state': False
     }
 
-    def test_strategy(self):
-        self.first_play_test(self.eq_play)
+    def test_first_play(self):
+        self.first_play_test(D)
 
-        expected, opponent_actions = self.get_infinite_memory_depth_actions()
-        self.versus_test(MockPlayer(actions=opponent_actions),
-                         expected_actions=expected)
+    def test_memory_depth_infinite_soft_is_false(self):
+        init_kwargs = {}
+        if self.default_soft:
+            init_kwargs['soft'] = False
 
-    def get_infinite_memory_depth_actions(self):
-        opponent_actions = [C, D, D]
-        first_three = [(self.eq_play, C), (C, D), (self.eq_play, D)]
-        second_three = [(D, C), (self.eq_play, D), (D, D)]
-        subsequent = [(D, C), (D, D), (D, D)]
-        expected = first_three + second_three + subsequent * 10
-        return expected, opponent_actions
+        opponent_actions = [C] * 50 + [D] * 100 + [C] * 52
+        actions = ([(D, C)] + [(C, C)] * 49 + [(C, D)] * 50 + [(D, D)] * 50 +
+                   [(D, C)] * 51 + [(C, C)])
+        opponent = MockPlayer(actions=opponent_actions)
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
 
-    def test_memory_depth(self):
+    def test_memory_depth_even_soft_is_false(self):
         memory_depth = 4
-        opponent_actions = [C, C, C, D, D, D]
-        first_six = [(self.eq_play, C), (C, C), (C, C),
-                     (C, D), (C, D), (self.eq_play, D)]
-        subsequent = [(D, C), (D, C), (self.eq_play, C),
-                      (C, D), (C, D), (self.eq_play, D)]
-
-        expected = first_six + subsequent * 10
-        self.versus_test(MockPlayer(actions=opponent_actions),
-                         expected_actions=expected,
-                         init_kwargs={'memory_depth': memory_depth})
-
-    def test_soft_value(self):
+        init_kwargs = {'memory_depth': memory_depth}
+        if self.default_soft:
+            init_kwargs['soft'] = False
+
+        opponent = MockPlayer(actions=[C] * memory_depth + [D] * memory_depth)
+        actions = ([(D, C)] + [(C, C)] * 3 + [(C, D)] * 2 + [(D, D)] * 2 +
+                   [(D, C)] * 3 + [(C, C)])
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+    def test_memory_depth_odd(self):
+        memory_depth = 5
+        init_kwargs = {'memory_depth': memory_depth}
+        if self.default_soft:
+            first_action = [(C, C)]
+        else:
+            first_action = [(D, C)]
+        opponent = MockPlayer(actions=[C] * memory_depth + [D] * memory_depth)
+        actions = (first_action + [(C, C)] * 4 + [(C, D)] * 3 + [(D, D)] * 2 +
+                   [(D, C)] * 3 + [(C, C)] * 2)
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+    def test_default_values(self):
         player = self.player()
-        self.assertFalse(player.soft)
+        self.assertEqual(player.soft, self.default_soft)
+        self.assertEqual(player.memory, 0)
 
 
 class TestGoByMajority(TestHardGoByMajority):
 
     name = "Soft Go By Majority"
     player = axelrod.GoByMajority
-    eq_play = C
-    soft = True
-
-    def test_set_soft_to_false(self):
-        self.eq_play = D
-        expected, opponent_actions = self.get_infinite_memory_depth_actions()
-        self.versus_test(MockPlayer(actions=opponent_actions),
-                         expected_actions=expected, init_kwargs={'soft': False})
-        self.eq_play = C
-
-    def test_soft_value(self):
-        default = self.player()
-        self.assertTrue(default.soft)
-        player = self.player(soft=True)
-        self.assertTrue(player.soft)
-        player = self.player(soft=False)
-        self.assertFalse(player.soft)
+    default_soft = True
+
+    def test_first_play(self):
+        self.first_play_test(C)
+
+    def test_memory_depth_infinite_soft_is_true(self):
+        opponent_actions = [C] * 50 + [D] * 100 + [C] * 52
+        actions = ([(C, C)] * 50 + [(C, D)] * 51 + [(D, D)] * 49 +
+                   [(D, C)] * 50 + [(C, C)] * 2)
+        opponent = MockPlayer(actions=opponent_actions)
+        self.versus_test(opponent, expected_actions=actions)
+
+    def test_memory_depth_even_soft_is_true(self):
+        memory_depth = 4
+        init_kwargs = {'memory_depth': memory_depth}
+
+        opponent = MockPlayer([C] * memory_depth + [D] * memory_depth)
+        actions = ([(C, C)] * 4 + [(C, D)] * 3 + [(D, D)] +
+                   [(D, C)] * 2 + [(C, C)] * 2)
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
 
     def test_name(self):
         player = self.player(soft=True)
@@ -124,38 +140,31 @@ class TestGoByRecentMajority(TestPlayer):
         }
 
         def test_strategy(self):
-            """
-            with memory_depth=3 always switches after
-            opponent_history=[C, C, C, D, D] (int(3*1.5) + 1 = 5)
-            with memory_depth=4 soft switches after
-            op_history=[C, C, C, C, D, D, D] (int(4*1.5) + 1 = 7)
-            and hard switches after
-            op_history=[C, C, C, C, D, D] (int(4 * 1.5) = 6)
-            """
 
             if soft:
                 self.first_play_test(C)
             else:
                 self.first_play_test(D)
 
+            # for example memory_depth=2 plays against [C, C, D, D]
+            # soft actions = [(C, C), (C, C), (C, D), (C, D)]
+            # hard actions = [(D, C), (C, C), (C, D), (D, D)]
             opponent_actions = [C] * memory_depth + [D] * memory_depth
-
-            if memory_depth % 2 == 1 or soft:
-                cooperation_len = int(memory_depth * 1.5) + 1
-            else:
-                cooperation_len = int(memory_depth * 1.5)
-            defect_len = 2 * memory_depth - cooperation_len
-
+            opponent = MockPlayer(actions=opponent_actions)
             if soft:
-                first_move = [C]
+                first_player_action = [C]
+            else:
+                first_player_action = [D]
+            if memory_depth % 2 == 1 or soft:
+                cooperations = int(memory_depth * 1.5)
             else:
-                first_move = [D]
+                cooperations = int(memory_depth * 1.5) - 1
+            defections = len(opponent_actions) - cooperations - 1
+            player_actions = (first_player_action + [C] * cooperations +
+                              [D] * defections)
 
-            player_actions = (first_move + [C] * (cooperation_len - 1) +
-                              [D] * defect_len)
-            expected = list(zip(player_actions, opponent_actions))
-            self.versus_test(MockPlayer(actions=opponent_actions),
-                             expected_actions=expected)
+            actions = list(zip(player_actions, opponent_actions))
+            self.versus_test(opponent, expected_actions=actions)
 
     return TestGoByRecentMajority