random test created and passed, basic deterministic tests created and passed

Author: bing-j

axelrod/strategies/epsilon_greedy.py

@@ -86,7 +86,7 @@ def strategy(self, opponent: Player) -> Action:
             self.update_rewards(opponent)
 
         # explore
-        if self._random.uniform(0.0, 1.0) <= self.epsilon:
+        if self.epsilon > 0 and self._random.uniform(0.0, 1.0) <= self.epsilon:
             return self._random.random_choice()
         # exploit
         else:

axelrod/tests/strategies/test_epsilon_greedy.py

@@ -2,7 +2,7 @@
 
 import axelrod as axl
 
-from .test_player import TestPlayer
+from .test_player import TestPlayer, TestMatch
 
 C, D = axl.Action.C, axl.Action.D
 
@@ -21,8 +21,62 @@ class TestEpsilonGreedy(TestPlayer):
         "manipulates_state": False,
     }
 
+    def test_deterministic(self):
+        # cases where epsilon = 0
+        actions = [(C, C), (C, C), (C, C)]
+        self.versus_test(axl.Cooperator(),
+                         expected_actions=actions,
+                         init_kwargs={"epsilon": 0, "init_c_reward": 0, "init_d_reward": -1},
+                         attrs={"_rewards": {C: 3, D: -1}})
+
+        actions = [(D, D), (D, D), (D, D)]
+        self.versus_test(axl.Defector(),
+                         expected_actions=actions,
+                         init_kwargs={"epsilon": 0, "init_c_reward": -1, "init_d_reward": 0},
+                         attrs={"_rewards": {C: -1, D: 1}})
+
+        # actions = [(D, C), (D, D)]
+        # self.versus_test(axl.TitForTat(),
+        #                  expected_actions=actions,
+        #                  init_kwargs={"epsilon": 0, "init_c_reward": 3.2, "init_d_reward": 4},
+        #                  attrs={"_rewards": {C: 3.2, D: 9}})
+
     def test_random(self):
-        """Test that strategy is randomly picked (not affected by history)."""
+        # case where epsilon = 1
         opponent = axl.MockPlayer()
-        actions = [(C, C), (C, D), (C, D), (C, C), (C, D)]
-        self.versus_test(opponent, expected_actions=actions, seed=0, init_kwargs={"epsilon": 1})
+        actions = [(C, C), (D, C), (D, C), (C, C)]
+        self.versus_test(opponent, expected_actions=actions, init_kwargs={"epsilon": 1}, seed=5)
+
+
+    # def versus_test(
+    #     self,
+    #     opponent,
+    #     expected_actions,
+    #     turns=None,
+    #     noise=None,
+    #     seed=None,
+    #     match_attributes=None,
+    #     attrs=None,
+    #     init_kwargs=None,
+    # ):
+    #
+    #     if init_kwargs is None:
+    #         init_kwargs = dict()
+    #
+    #     player = self.player(**init_kwargs)
+    #
+    #     test_match = TestMatch()
+    #     seed = test_match.search_seeds(
+    #         player,
+    #         opponent,
+    #         [x for (x, y) in expected_actions],
+    #         [y for (x, y) in expected_actions],
+    #         turns=turns,
+    #         noise=noise,
+    #         seed=seed,
+    #         attrs=attrs,
+    #         match_attributes=match_attributes,
+    #     )
+    #     self.assertIsNotNone(seed)
+    #     print(seed)
+    #