def test_cache_update_required(self):
p1, p2 = axelrod.Player(), axelrod.Player()
rr = axelrod.RoundRobin(players=[p1, p2],
game=self.game,
turns=20,
noise=0.2)
self.assertFalse(rr._cache_update_required(p1, p2))
rr = axelrod.RoundRobin(players=[p1, p2], game=self.game, turns=20)
self.assertTrue(rr._cache_update_required(p1, p2))
p1 = axelrod.Random()
rr = axelrod.RoundRobin(players=[p1, p2], game=self.game, turns=20)
self.assertFalse(rr._cache_update_required(p1, p2))
def test_stochastic_interaction(self):
p1, p2 = axelrod.Player(), axelrod.Player()
rr = axelrod.RoundRobin(players=[p1, p2],
game=self.game,
turns=20,
noise=0.2)
self.assertTrue(rr._stochastic_interaction(p1, p2))
rr = axelrod.RoundRobin(players=[p1, p2], game=self.game, turns=20)
self.assertFalse(rr._stochastic_interaction(p1, p2))
p1 = axelrod.Random()
rr = axelrod.RoundRobin(players=[p1, p2], game=self.game, turns=20)
self.assertTrue(rr._stochastic_interaction(p1, p2))
def test_calculate_cooperation(self):
p1, p2 = axelrod.Player(), axelrod.Player()
p1.history = [C, C, D, D]
rr = axelrod.RoundRobin(players=[p1, p2], game=self.game, turns=20)
result = rr._calculate_cooperation(p1)
expected = 2
self.assertEqual(result, expected)
def test_deterministic_cache(self):
p1, p2, p3 = axelrod.Cooperator(), axelrod.Defector(), axelrod.Random()
rr = axelrod.RoundRobin(players=[p1, p2, p3], game=self.game, turns=20)
self.assertEquals(rr.deterministic_cache, {})
rr.play()
self.assertEqual(
rr.deterministic_cache[(axelrod.Defector,
axelrod.Defector)]['scores'], (20, 20))
self.assertEqual(
rr.deterministic_cache[(axelrod.Defector,
axelrod.Defector)]['cooperation_rates'],
(0, 0))
self.assertEqual(
rr.deterministic_cache[(axelrod.Cooperator,
axelrod.Cooperator)]['scores'], (60, 60))
self.assertEqual(
rr.deterministic_cache[(axelrod.Cooperator,
axelrod.Cooperator)]['cooperation_rates'],
(20, 20))
self.assertEqual(
rr.deterministic_cache[(axelrod.Cooperator,
axelrod.Defector)]['scores'], (0, 100))
self.assertEqual(
rr.deterministic_cache[(axelrod.Cooperator,
axelrod.Defector)]['cooperation_rates'],
(20, 0))
self.assertFalse((axelrod.Random,
axelrod.Random) in rr.deterministic_cache)
def test_play(self):
p1, p2, p3 = axelrod.Cooperator(), axelrod.Defector(), axelrod.Random()
rr = axelrod.RoundRobin(players=[p1, p2, p3], game=self.game, turns=20)
results = rr.play()
expected_payoff = [[60.0, 0, 33], [100, 20.0, 56], [78, 11, 46.5]]
expected_cooperation = [[20, 20, 20], [0, 0, 0], [11, 9, 13]]
self.assertEqual(results['payoff'], expected_payoff)
self.assertEqual(results['cooperation'], expected_cooperation)
def test_calculate_scores(self):
p1, p2 = axelrod.Player(), axelrod.Player()
p1.history = [C, C, D, D]
p2.history = [C, D, C, D]
rr = axelrod.RoundRobin(players=[p1, p2], game=self.game, turns=20)
result = rr._calculate_scores(p1, p2)
expected = (9, 9)
self.assertEqual(result, expected)
def test_noisy_cache(self):
p1, p2, p3 = axelrod.Cooperator(), axelrod.Defector(), axelrod.Random()
rr = axelrod.RoundRobin(players=[p1, p2, p3],
game=self.game,
turns=20,
noise=0.2)
rr.play()
self.assertEqual(rr.deterministic_cache, {})
def test_calculate_score_for_all_defect(self):
"""Test that scores are calculated correctly."""
P1 = axelrod.Player()
P1.history = ['D', 'D', 'D']
P2 = axelrod.Player()
P2.history = ['D', 'D', 'D']
round_robin = axelrod.RoundRobin(players=[P1, P2], game=self.game, turns=200)
self.assertEqual(round_robin.calculate_scores(P1, P2), (3, 3))
def test_calculate_score_for_all_cooperate(self):
"""Test that scores are calculated correctly."""
P1 = axelrod.Player()
P1.history = [C, C, C]
P2 = axelrod.Player()
P2.history = [C, C, C]
round_robin = axelrod.RoundRobin(players=[P1, P2],
game=self.game,
turns=200)
self.assertEqual(round_robin._calculate_scores(P1, P2), (9, 9))
def test_calculate_score_for_mix(self):
"""Test that scores are calculated correctly."""
P1 = axelrod.Defector()
P1.history = [C, C, D]
P2 = axelrod.Defector()
P2.history = [C, D, D]
round_robin = axelrod.RoundRobin(players=[P1, P2],
game=self.game,
turns=200)
self.assertEqual(round_robin._calculate_scores(P1, P2), (4, 9))
def test_score_single_interaction(self):
players = [
axelrod.Alternator(),
axelrod.Defector(),
axelrod.TitForTat()
]
rr = axelrod.RoundRobin(players=players, game=self.game, turns=20)
scores, cooperation_rates = rr._score_single_interaction(0, 2)
expected_scores = (53, 48)
expected_cooperation_rates = (10, 11)
self.assertEqual(expected_scores, scores)
self.assertEqual(expected_cooperation_rates, cooperation_rates)
def test_noisy_play(self):
random.seed(1)
p1, p2, p3 = axelrod.Cooperator(), axelrod.Defector(), axelrod.Random()
rr = axelrod.RoundRobin(players=[p1, p2, p3],
game=self.game,
turns=20,
noise=0.2)
results = rr.play()
expected_payoff = [[57, 10, 45], [80, 40, 57], [65, 22, 37]]
expected_cooperation = [[15, 16, 17], [2, 3, 4], [13, 11, 9]]
self.assertEqual(results['payoff'], expected_payoff)
self.assertEqual(results['cooperation'], expected_cooperation)
def test_init(self):
p1, p2 = axelrod.Player(), axelrod.Player()
rr = axelrod.RoundRobin(players=[p1, p2],
game=self.game,
turns=20,
noise=0.2)
self.assertEqual(rr.players, [p1, p2])
self.assertEqual(rr.nplayers, 2)
self.assertEqual(rr.game.score((C, C)), (3, 3))
self.assertEqual(rr.turns, 20)
self.assertEqual(rr.deterministic_cache, {})
self.assertEqual(rr.cache_mutable, True)
self.assertEqual(rr._noise, 0.2)
def get_test_outcome(cls, outcome, turns=10):
# Extract the name of players from the outcome tupples,
# and initiate the players by getting the classes from axelrod.
names = [out[0] for out in outcome]
players = [getattr(axelrod, n)() for n in names]
# Do the actual game and build the expected outcome tuples.
round_robin = axelrod.RoundRobin(players=players, game=cls.game, turns=turns)
payoffs = round_robin.play()
scores = cls.payoffs2scores(payoffs)
outcome = zip(names, scores)
# The outcome is expected to be sort by score.
return sorted(outcome, key = lambda k: k[1])
def test_play_single_interaction(self):
players = [
axelrod.Alternator(),
axelrod.Defector(),
axelrod.TitForTat()
]
rr = axelrod.RoundRobin(players=players, game=self.game, turns=20)
player1 = players[0]
player2 = players[2]
classes = (player1.__class__, player2.__class__)
scores, cooperation_rates = (rr._play_single_interaction(
player1, player2, classes))
expected_scores = (53, 48)
expected_cooperation_rates = (10, 11)
self.assertEqual(expected_scores, scores)
self.assertEqual(expected_cooperation_rates, cooperation_rates)
def test_update_matrices(self):
players = [
axelrod.Alternator(),
axelrod.Defector(),
axelrod.TitForTat()
]
rr = axelrod.RoundRobin(players=players, game=self.game, turns=20)
scores = (53, 48)
cooperation_rates = (0.5, 0.55)
payoffs = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
cooperation = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
rr._update_matrices(0, 2, scores, payoffs, cooperation_rates,
cooperation)
expected_payoffs = [[0, 0, 53], [0, 0, 0], [48, 0, 0]]
expected_cooperation = [[0, 0, 0.5], [0, 0, 0], [0.55, 0, 0]]
self.assertEqual(expected_payoffs, payoffs)
self.assertEqual(expected_cooperation, cooperation)
def test_pair_of_players(self):
players = [
axelrod.Cooperator(),
axelrod.Defector(),
axelrod.TitForTat()
]
rr = axelrod.RoundRobin(players=players, game=self.game, turns=20)
player1, player2, key = rr._pair_of_players(0, 2)
self.assertEqual(player1.name, 'Cooperator')
self.assertEqual(player2.name, 'Tit For Tat')
self.assertEqual(key[0], axelrod.Cooperator)
self.assertEqual(key[1], axelrod.TitForTat)
player1, player2, key = rr._pair_of_players(0, 0)
self.assertEqual(player1.name, player2.name)
self.assertEqual(key[0], key[1])
self.assertNotEqual(player1, player2)
# Check that the two player instances are wholly independent
player1.name = 'player 1'
player2.name = 'player 2'
self.assertNotEqual(player1.name, player2.name)
def test_init(self):
p1, p2 = axelrod.Player(), axelrod.Player()
rr = axelrod.RoundRobin(players=[p1, p2], game=self.game, turns=20)
self.assertEquals(rr.players, [p1, p2])
self.assertEquals(rr.nplayers, 2)
self.assertEquals(rr.game.score(('C', 'C')), (3, 3))
def test_empty_matrix(self):
p1, p2 = axelrod.Player(), axelrod.Player()
rr = axelrod.RoundRobin(players=[p1, p2], game=self.game, turns=20)
result = rr._empty_matrix(2, 2)
expected = [[0, 0], [0, 0]]
self.assertEqual(result, expected)
