Add a versus_test method to TestPlayer

axelrod/mock_player.py

@@ -2,6 +2,7 @@
 from axelrod.actions import Actions, Action
 from axelrod.player import Player, update_history, update_state_distribution
 from collections import defaultdict
+from itertools import cycle
 
 from typing import List, Tuple
 
@@ -28,16 +29,16 @@ def __init__(self, actions: List[Action] =None, history: List[Action] =None, sta
         if state_dist:
             self.state_distribution = dict(state_dist)
         if actions:
-            self.actions = list(actions)
+            self.actions = cycle(actions)
         else:
             self.actions = []
 
     def strategy(self, opponent: Player) -> Action:
         # Return the next saved action, if present.
         try:
-            action = self.actions.pop(0)
+            action = self.actions.__next__()
             return action
-        except IndexError:
+        except AttributeError:
             return C
 
 

axelrod/strategies/apavlov.py

@@ -29,7 +29,7 @@ class APavlov2006(Player):
 
     def __init__(self) -> None:
         super().__init__()
-        self.opponent_class = ""
+        self.opponent_class = None
 
     def strategy(self, opponent: Player) -> Action:
         # TFT for six rounds
@@ -96,7 +96,7 @@ class APavlov2011(Player):
 
     def __init__(self) -> None:
         super().__init__()
-        self.opponent_class = ""
+        self.opponent_class = None
 
     def strategy(self, opponent: Player) -> Action:
         # TFT for six rounds

axelrod/strategies/appeaser.py

@@ -24,11 +24,11 @@ class Appeaser(Player):
 
     def strategy(self, opponent: Player) -> Action:
         if not len(opponent.history):
-            self.move = C
+            return C
         else:
             if opponent.history[-1] == D:
-                if self.move == C:
-                    self.move = D
+                if self.history[-1] == C:
+                    return D
                 else:
-                    self.move = C
-        return self.move
+                    return C
+        return self.history[-1]

axelrod/strategies/axelrod_first.py

@@ -98,12 +98,10 @@ def strategy(self, opponent: Player) -> Action:
 
         if self.revised:
             if round_number == 1:
-                self.move = C
-                return self.move
+                return C
         elif not self.revised:
             if round_number <= 2:
-                self.move = D
-                return self.move
+                return D
 
         # Update various counts
         if round_number > 2:
@@ -121,12 +119,12 @@ def strategy(self, opponent: Player) -> Action:
         c = 6.0 * self.good - 8.0 * self.bad - 2
         alt = 4.0 * self.good - 5.0 * self.bad - 1
         if (c >= 0 and c >= alt):
-            self.move = C
+            move = C
         elif (c >= 0 and c < alt) or (alt >= 0):
-            self.move = flip_action(self.move)
+            move = flip_action(self.history[-1])
         else:
-            self.move = D
-        return self.move
+            move = D
+        return move
 
     def reset(self):
         super().reset()

axelrod/strategies/finite_state_machines.py

@@ -32,6 +32,13 @@ def move(self, opponent_action):
         self.state = next_state
         return next_action
 
+    def __eq__(self, other):
+        """Equality of two FSMs"""
+        check = True
+        for attr in ["state", "state_transitions"]:
+            check = check and getattr(self, attr) == getattr(other, attr)
+        return check
+
 
 class FSMPlayer(Player):
     """Abstract base class for finite state machine players."""
@@ -57,6 +64,7 @@ def __init__(self, transitions=None, initial_state=None,
             initial_action = C
         super().__init__()
         self.initial_state = initial_state
+        self.state = initial_state
         self.initial_action = initial_action
         self.fsm = SimpleFSM(transitions, initial_state)
 
@@ -73,6 +81,7 @@ def strategy(self, opponent):
     def reset(self):
         super().reset()
         self.fsm.state = self.initial_state
+        self.state = self.initial_state
 
 
 class Fortress3(FSMPlayer):

axelrod/strategies/hmm.py

@@ -61,6 +61,15 @@ def is_well_formed(self):
             return False
         return True
 
+    def __eq__(self, other):
+        """Equality of two HMMs"""
+        check = True
+        for attr in ["transitions_C", "transitions_D",
+                     "emission_probabilities", "state"]:
+            check = check and getattr(self, attr) == getattr(other, attr)
+        return check
+
+
     def move(self, opponent_action):
         """Changes state and computes the response action.
 
@@ -114,6 +123,7 @@ def __init__(self, transitions_C=None, transitions_D=None,
         self.hmm = SimpleHMM(transitions_C, transitions_D,
                              emission_probabilities, initial_state)
         assert self.hmm.is_well_formed()
+        self.state = self.hmm.state
         self.classifier['stochastic'] = self.is_stochastic()
 
     def is_stochastic(self):
@@ -141,6 +151,7 @@ def strategy(self, opponent):
     def reset(self):
         super().reset()
         self.hmm.state = self.initial_state
+        self.state = self.hmm.state
 
 
 class EvolvedHMM5(HMMPlayer):

axelrod/strategies/punisher.py

@@ -62,7 +62,7 @@ def reset(self):
         """
         super().reset()
         self.grudged = False
-        self.grudge_memory = 0
+        self.grudge_memory = 1
         self.mem_length = 1
 
 
@@ -122,15 +122,15 @@ def reset(self):
         """Resets internal variables and history"""
         super().reset()
         self.grudged = False
-        self.grudge_memory = 0
+        self.grudge_memory = 1
         self.mem_length = 1
 
 class LevelPunisher(Player):
     """
-    A player starts by cooperating however, after 10 rounds 
-    will defect if at any point the number of defections 
+    A player starts by cooperating however, after 10 rounds
+    will defect if at any point the number of defections
     by an opponent is greater than 20%.
-    
+
     Names:
 
     - Level Punisher: Name from CoopSim https://github.com/jecki/CoopSim

axelrod/strategies/qlearner.py

@@ -49,6 +49,7 @@ def __init__(self) -> None:
         self.classifier['stochastic'] = True
 
         self.prev_action = random_choice()
+        self.original_prev_action = self.prev_action
         self.history = [] # type: List[Action]
         self.score = 0
         self.Qs = OrderedDict({'':  OrderedDict(zip([C, D], [0, 0]))})
@@ -117,7 +118,7 @@ def reset(self):
         self.Qs = {'': {C: 0, D: 0}}
         self.Vs = {'': 0}
         self.prev_state = ''
-        self.prev_action = random_choice()
+        self.prev_action = self.original_prev_action
 
 
 class ArrogantQLearner(RiskyQLearner):

axelrod/strategies/stalker.py

@@ -34,7 +34,7 @@ class Stalker(Player):
     classifier = {
         'memory_depth': float('inf'),
         'stochastic': True,
-        'makes_use_of': set(),
+        'makes_use_of': set(["game", "length"]),
         'long_run_time': False,
         'inspects_source': False,
         'manipulates_source': False,
@@ -46,7 +46,7 @@ def __init__(self) -> None:
         R, P, S, T  = self.match_attributes["game"].RPST()
         self.very_good_score = R
         self.very_bad_score = P
-        self.wish_score = ( R + P ) / 2
+        self.wish_score = (R + P) / 2
         self.current_score = 0
 
     def score_last_round(self, opponent: Player):

axelrod/strategies/titfortat.py

@@ -304,7 +304,7 @@ def strategy(self, opponent: Player) -> Action:
 
         # Are we deadlocked? (in a CD -> DC loop)
         if (self.deadlock_counter >= self.deadlock_threshold):
-            self.move = C
+            move = C
             if self.deadlock_counter == self.deadlock_threshold:
                 self.deadlock_counter = self.deadlock_threshold + 1
             else:
@@ -323,16 +323,16 @@ def strategy(self, opponent: Player) -> Action:
             # Compare counts to thresholds
             # If randomness_counter exceeds Y, Defect for the remainder
             if self.randomness_counter >= 8:
-                self.move = D
+                move = D
             else:
                 # TFT
-                self.move = D if opponent.history[-1:] == [D] else C
+                move = D if opponent.history[-1:] == [D] else C
                 # Check for deadlock
                 if opponent.history[-2] != opponent.history[-1]:
                     self.deadlock_counter += 1
                 else:
                     self.deadlock_counter = 0
-        return self.move
+        return move
 
     def reset(self):
         super().reset()

axelrod/tests/unit/test_calculator.py

@@ -44,3 +44,7 @@ def test_strategy(self):
                    D, C]
         self.responses_test([C], [C] * 22, history)
 
+    def attribute_equality_test(self, player, clone):
+        """Overwrite the default test to check Joss instance"""
+        self.assertIsInstance(player.joss_instance, axelrod.Joss)
+        self.assertIsInstance(clone.joss_instance, axelrod.Joss)

axelrod/tests/unit/test_grumpy.py

@@ -45,7 +45,7 @@ def test_strategy(self):
                             init_kwargs={"grumpy_threshold": 3,
                                          "nice_threshold": 0})
 
-    def test_reset(self):
+    def test_reset_state_with_non_default_init(self):
         P1 = axelrod.Grumpy(starting_state='Grumpy')
         P1.state = 'Nice'
         P1.reset()

axelrod/tests/unit/test_human.py

@@ -91,3 +91,7 @@ def test_strategy(self):
         expected_action = C
         actual_action = human.strategy(Player(), lambda: C)
         self.assertEqual(actual_action, expected_action)
+
+    def test_reset_history_and_attributes(self):
+        """Overwrite the reset method for this strategy."""
+        pass

axelrod/tests/unit/test_memorytwo.py

@@ -41,3 +41,16 @@ def test_strategy(self):
         # ALLD forever if all D twice
         self.responses_test([D] * 10, [C, D, D, D, D, D], [D, D, D, D, D, D])
         self.responses_test([D] * 9, [C] + [D] * 5 + [C] * 4, [D] * 6 + [C] * 4)
+
+    def attribute_equality_test(self, player, clone):
+        """Overwrite specific test to be able to test self.players"""
+        for p in [player, clone]:
+            self.assertEqual(p.play_as, "TFT")
+            self.assertEqual(p.shift_counter, 3)
+            self.assertEqual(p.alld_counter, 0)
+
+        for key, value in [("TFT", axelrod.TitForTat),
+                           ("TFTT", axelrod.TitFor2Tats),
+                           ("ALLD", axelrod.Defector)]:
+            self.assertEqual(p.players[key].history, [])
+            self.assertIsInstance(p.players[key], value)

axelrod/tests/unit/test_meta.py

@@ -46,16 +46,15 @@ def classifier_test(self, expected_class_classifier=None):
                              msg="%s - Behaviour: %s != Expected Behaviour: %s" %
                                  (key, player.classifier[key], classifier[key]))
 
-    def test_reset(self):
-        p1 = self.player()
-        p2 = axelrod.Cooperator()
-        p1.play(p2)
-        p1.play(p2)
-        p1.play(p2)
-        p1.reset()
-        for player in p1.team:
-            self.assertEqual(len(player.history), 0)
+    def attribute_equality_test(self, player, clone):
+        """Overwriting this specific method to check team."""
+        for p1, p2 in zip(player.team, clone.team):
+            self.assertEqual(len(p1.history), 0)
+            self.assertEqual(len(p2.history), 0)
 
+        team_player_names = [p.__repr__() for p in player.team]
+        team_clone_names = [p.__repr__() for p in clone.team]
+        self.assertEqual(team_player_names, team_clone_names)
 
 class TestMetaMajority(TestMetaPlayer):
 
@@ -222,8 +221,6 @@ def test_strategy(self):
         self.responses_test([D], [C] * 4, [D] * 4)
         self.responses_test([D], [C] * 6, [C, D] * 3)
         self.responses_test([D], [C] * 8, [C, C, C, D, C, C, C, D])
-        self.responses_test([D], [C] * 100,
-                            [random.choice([C, D]) for i in range(100)])
         # Test post 100 rounds responses
         self.responses_test([C], [C] * 101, [C] * 101)
         self.responses_test([D], [C] * 101, [C] * 100 + [D])
@@ -257,8 +254,6 @@ def test_strategy(self):
         self.responses_test([D], [C] * 4, [D] * 4)
         self.responses_test([D], [C] * 6, [C, D] * 3)
         self.responses_test([D], [C] * 8, [C, C, C, D, C, C, C, D])
-        self.responses_test([D], [C] * 100,
-                            [random.choice([C, D]) for i in range(100)])
         # Test post 100 rounds responses
         self.responses_test([D], [C] * 101, [C] * 101)
         self.responses_test([D], [C] * 101, [C] * 100 + [D])

axelrod/tests/unit/test_mock_player.py

@@ -23,13 +23,14 @@ def test_strategy(self):
     def test_history(self):
         t = TestOpponent()
         m1 = MockPlayer([C], history=[C]*10)
-        self.assertEqual(m1.actions[0], C)
+        self.assertEqual(m1.actions.__next__(), C)
         self.assertEqual(m1.history, [C] * 10)
         self.assertEqual(m1.cooperations, 10)
         self.assertEqual(m1.defections, 0)
         self.assertEqual(m1.strategy(t), C)
+
         m2 = MockPlayer([D], history=[D]*10)
-        self.assertEqual(m2.actions[0], D)
+        self.assertEqual(m2.actions.__next__(), D)
         self.assertEqual(m2.history, [D] * 10)
         self.assertEqual(m2.cooperations, 0)
         self.assertEqual(m2.defections, 10)