def test_strategy(self):
for action in [C, D]:
m = MockPlayer(actions=[action])
p2 = axelrod.Player()
self.assertEqual(action, m.strategy(p2))
actions = [C, C, D, D, C, C]
m = MockPlayer(actions=actions)
p2 = axelrod.Player()
for action in actions:
self.assertEqual(action, m.strategy(p2))
def test_cloning(self):
p1 = axelrod.Cooperator()
p2 = axelrod.Defector()
moves = 10
for i in range(moves):
p1.play(p2)
m1 = MockPlayer(p1, C)
m2 = MockPlayer(p2, D)
self.assertEqual(m1.move, C)
self.assertEqual(m1.history, p1.history)
self.assertEqual(m1.cooperations, p1.cooperations)
self.assertEqual(m1.defections, p1.defections)
self.assertEqual(m2.move, D)
self.assertEqual(m2.history, p2.history)
self.assertEqual(m2.cooperations, p2.cooperations)
self.assertEqual(m2.defections, p2.defections)
def test_strategy(self):
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
opponent = MockPlayer(actions=opponent_actions)
if soft:
first_player_action = [C]
else:
first_player_action = [D]
if memory_depth % 2 == 1 or soft:
cooperations = int(memory_depth * 1.5)
else:
cooperations = int(memory_depth * 1.5) - 1
defections = len(opponent_actions) - cooperations - 1
player_actions = (first_player_action + [C] * cooperations +
[D] * defections)
actions = list(zip(player_actions, opponent_actions))
self.versus_test(opponent, expected_actions=actions)
def test_init(self):
actions = [C, C, D]
history = [C, C, C]
state_dist = {(C, C): 2, (D, C): 1}
m = MockPlayer(actions, history, state_dist)
self.assertEqual(m.history, [C, C, C])
self.assertEqual(m.state_distribution, state_dist)
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_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_false(self):
memory_depth = 4
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_infinite_soft_is_false(self):
init_kwargs = {}
if self.default_soft:
init_kwargs['soft'] = False
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_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 responses_test(self, responses, player_history=None,
opponent_history=None, seed=None, length=200,
attrs=None,
init_args=None, init_kwargs=None):
"""Test responses to arbitrary histories. A match is played where the
histories are enforced and the sequence of plays in responses is
checked to be the outcome. Internal variables can be checked with the
attrs attribute and arguments to the first player can be passed in
init_args.
Parameters
----------
responses: History or sequence of axelrod.Actions
The expected outcomes
player_history, opponent_history: sequences of prior history to enforce
seed: int
A random seed if needed for reproducibility
length: int
Some players require the length of the match
attrs: dict
dictionary of internal attributes to check at the end of all plays
in player
init_args: tuple or list
A list of arguments to instantiate player with
init_kwargs: dictionary
A list of keyword arguments to instantiate player with
"""
if init_args is None:
init_args = ()
if init_kwargs is None:
init_kwargs = dict()
player1 = self.player(*init_args, **init_kwargs)
player1.set_match_attributes(length=length)
player2 = MockPlayer()
player2.set_match_attributes(length=length)
test_responses(self, player1, player2, responses, player_history,
opponent_history, seed=seed, attrs=attrs)
# Test that we get the same sequence after a reset
player1.reset()
player2.reset()
test_responses(self, player1, player2, responses, player_history,
opponent_history, seed=seed, attrs=attrs)
# Test that we get the same sequence after a clone
player1 = player1.clone()
player2 = player2.clone()
test_responses(self, player1, player2, responses, player_history,
opponent_history, seed=seed, attrs=attrs)
def test_strategy(self):
for action in [C, D]:
m = MockPlayer(actions=[action])
p2 = Player()
self.assertEqual(action, m.strategy(p2))
actions = [C, C, D, D, C, C]
m = MockPlayer(actions=actions)
p2 = Player()
for action in actions:
self.assertEqual(action, m.strategy(p2))
def test_history(self):
t = TestOpponent()
m1 = MockPlayer([C], history=[C] * 10)
self.assertEqual(m1.actions[0], 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.history, [D] * 10)
self.assertEqual(m2.cooperations, 0)
self.assertEqual(m2.defections, 10)
self.assertEqual(m2.strategy(t), D)
def test_strategy(self):
for move in [C, D]:
m = MockPlayer(axelrod.Player(), move)
p2 = axelrod.Player()
self.assertEqual(move, m.strategy(p2))
def test_strategy(self):
for move in [C, D]:
m = MockPlayer(axelrod.Player(), move)
p2 = axelrod.Player()
self.assertEqual(move, m.strategy(p2))