def setUpClass(cls):
cls.filename = "test_outputs/test_results.csv"
cls.players = [axl.Alternator(), axl.TitForTat(), axl.Defector()]
cls.repetitions = 3
cls.turns = 5
cls.test_result_set = axl.ResultSet(cls.filename,
cls.players,
cls.repetitions,
progress_bar=False)
cls.test_result_set = axl.ResultSet(cls.filename,
cls.players,
cls.repetitions,
progress_bar=False)
cls.expected_boxplot_dataset = [
[(17 / 5 + 9 / 5) / 2 for _ in range(3)],
[(13 / 5 + 4 / 5) / 2 for _ in range(3)],
[3 / 2 for _ in range(3)],
]
cls.expected_boxplot_xticks_locations = [1, 2, 3, 4]
cls.expected_boxplot_xticks_labels = [
"Defector", "Tit For Tat", "Alternator"
]
cls.expected_lengthplot_dataset = [
[cls.turns for _ in range(3)],
[cls.turns for _ in range(3)],
[cls.turns for _ in range(3)],
]
cls.expected_payoff_dataset = [
[
0,
mean([9 / 5 for _ in range(3)]),
mean([17 / 5 for _ in range(3)])
],
[
mean([4 / 5 for _ in range(3)]), 0,
mean([13 / 5 for _ in range(3)])
],
[
mean([2 / 5 for _ in range(3)]),
mean([13 / 5 for _ in range(3)]), 0
],
]
cls.expected_winplot_dataset = (
[[2, 2, 2], [0, 0, 0], [0, 0, 0]],
["Defector", "Tit For Tat", "Alternator"],
)
cls.expected_sdvplot_dataset = (
[
[3, 3, 3, 1, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, -1, -1, -1],
[0, 0, 0, 0, 0, 0, -3, -3, -3],
],
["Defector", "Tit For Tat", "Alternator"],
)
def test_with_progress_bar(self):
rs = axelrod.ResultSet(self.players, self.interactions)
self.assertTrue(rs.progress_bar)
self.assertEqual(rs.progress_bar.total, 19)
rs = axelrod.ResultSet(self.players, self.interactions,
progress_bar=True)
self.assertTrue(rs.progress_bar)
self.assertEqual(rs.progress_bar.total, 19)
def test_normalised_scores(self):
rs = axelrod.ResultSet(
self.filename, self.players, self.repetitions, progress_bar=False
)
self.assertIsInstance(rs.normalised_scores, list)
self.assertEqual(len(rs.normalised_scores), rs.num_players)
self.assertEqual(rs.normalised_scores, self.expected_normalised_scores)
def test_match_lengths(self):
"""
Overwriting match lengths test. This method, among other things, checks
that if two players interacted the length of that interaction equals the
number of turns.
Implementing this for the round robin tournament meant checking the
interactions between each strategy and the rest strategies of the
tournament.
In a spatial tournament we need to check that: The length of interaction
of players-nodes that are end vertices of an edge is equal to the
number of turns. Otherwise it is 0.
"""
rs = axelrod.ResultSet(self.players, self.interactions,
progress_bar=False)
self.assertIsInstance(rs.match_lengths, list)
self.assertEqual(len(rs.match_lengths), rs.nrepetitions)
self.assertEqual(rs.match_lengths, self.expected_match_lengths)
for rep in rs.match_lengths:
self.assertIsInstance(rep, list)
self.assertEqual(len(rep), len(self.players))
for i, opp in enumerate(rep):
self.assertIsInstance(opp, list)
self.assertEqual(len(opp), len(self.players))
for j, length in enumerate(opp):
edge = (i, j)
# Specific test for example match setup
if edge in self.edges or edge[::-1] in self.edges :
self.assertEqual(length, self.turns)
else:
self.assertEqual(length, 0)
def test_payoff_stddevs(self):
rs = axelrod.ResultSet(
self.filename, self.players, self.repetitions, progress_bar=False
)
self.assertIsInstance(rs.payoff_stddevs, list)
self.assertEqual(len(rs.payoff_stddevs), rs.num_players)
self.assertEqual(rs.payoff_stddevs, self.expected_payoff_stddevs)
def test_state_distribution(self):
rs = axelrod.ResultSet(
self.filename, self.players, self.repetitions, progress_bar=False
)
self.assertIsInstance(rs.state_distribution, list)
self.assertEqual(len(rs.state_distribution), rs.num_players)
self.assertEqual(rs.state_distribution, self.expected_state_distribution)
def test_eigenmoses_rating(self):
rs = axelrod.ResultSet(self.players, self.interactions,
progress_bar=False)
self.assertIsInstance(rs.eigenmoses_rating, list)
self.assertEqual(len(rs.eigenmoses_rating), rs.nplayers)
for j, rate in enumerate(rs.eigenmoses_rating):
self.assertAlmostEqual(rate, self.expected_eigenmoses_rating[j])
def test_good_partner_matrix(self):
rs = axelrod.ResultSet(self.players, self.interactions,
progress_bar=False)
self.assertIsInstance(rs.good_partner_matrix, list)
self.assertEqual(len(rs.good_partner_matrix), rs.nplayers)
self.assertEqual(rs.good_partner_matrix,
self.expected_good_partner_matrix)
def test_cooperating_rating(self):
rs = axelrod.ResultSet(self.players, self.interactions,
progress_bar=False)
self.assertIsInstance(rs.cooperating_rating, list)
self.assertEqual(len(rs.cooperating_rating), rs.nplayers)
self.assertEqual(rs.cooperating_rating,
self.expected_cooperating_rating)
def test_vengeful_cooperation(self):
rs = axelrod.ResultSet(self.players, self.interactions,
progress_bar=False)
self.assertIsInstance(rs.vengeful_cooperation, list)
self.assertEqual(len(rs.vengeful_cooperation), rs.nplayers)
self.assertEqual(rs.vengeful_cooperation,
self.expected_vengeful_cooperation)
def test_scores_with_different_game(self):
game = axelrod.Game(p=-1, r=-1, s=-1, t=-1)
rs = axelrod.ResultSet(self.players, self.interactions,
progress_bar=False, game=game)
for player in rs.scores:
for score in player:
self.assertFalse(score > 0)
def test_good_partner_rating(self):
rs = axelrod.ResultSet(
self.filename, self.players, self.repetitions, progress_bar=False
)
self.assertIsInstance(rs.good_partner_rating, list)
self.assertEqual(len(rs.good_partner_rating), rs.num_players)
self.assertEqual(rs.good_partner_rating, self.expected_good_partner_rating)
def test_generate_payoff_matrix(self):
rs = axelrod.ResultSet(self.players, 5, 2)
rs.results = self.test_results
payoffs, stddevs = rs.generate_payoff_matrix()
stddevs = [[round(x, 1) for x in row] for row in stddevs]
self.assertEquals(payoffs, self.expected_payoffs)
self.assertEquals(stddevs, self.expected_stddevs)
def test_with_progress_bar(self):
rs = axelrod.ResultSet(
self.filename, self.players, self.repetitions, progress_bar=True
)
self.assertTrue(rs.progress_bar)
self.assertEqual(rs.progress_bar.total, 25)
self.assertEqual(rs.progress_bar.n, rs.progress_bar.total)
def test_payoffs(self):
rs = axelrod.ResultSet(self.players,
self.interactions,
progress_bar=False)
self.assertIsInstance(rs.payoffs, list)
self.assertEqual(len(rs.payoffs), rs.nplayers)
self.assertEqual(rs.payoffs, self.expected_payoffs)
def test_payoff_diffs_means(self):
rs = axelrod.ResultSet(self.players, self.interactions)
self.assertIsInstance(rs.payoff_diffs_means, list)
self.assertEqual(len(rs.payoff_diffs_means), rs.nplayers)
for i, row in enumerate(rs.payoff_diffs_means):
for j, col in enumerate(row):
self.assertAlmostEqual(col,
self.expected_payoff_diffs_means[i][j])
def test_finalise(self):
rs = axelrod.ResultSet(self.players, 5, 2)
rs.finalise(self.test_payoffs_list)
self.assertEquals(rs.scores, self.expected_scores)
self.assertEquals(rs.ranking, self.expected_ranking)
self.assertEquals(rs.ranked_names, self.expected_ranked_names)
self.assertTrue(rs.finalised)
self.assertRaises(AttributeError, rs.finalise, self.test_payoffs_list)
def setUpClass(cls):
cls.players = (
axelrod.Alternator(), axelrod.TitForTat(), axelrod.Defector())
cls.turns = 5
cls.matches = {
(0, 1): [axelrod.Match(
(cls.players[0], cls.players[1]), turns=cls.turns)
for _ in range(3)],
(0, 2): [axelrod.Match(
(cls.players[0], cls.players[2]), turns=cls.turns)
for _ in range(3)],
(1, 2): [axelrod.Match(
(cls.players[1], cls.players[2]), turns=cls.turns)
for _ in range(3)]
}
# This would not actually be a round robin tournament
# (no cloned matches)
cls.interactions = {}
for index_pair, matches in cls.matches.items():
for match in matches:
match.play()
try:
cls.interactions[index_pair].append(match.result)
except KeyError:
cls.interactions[index_pair] = [match.result]
cls.test_result_set = axelrod.ResultSet(cls.players, cls.interactions,
progress_bar=False)
cls.expected_boxplot_dataset = [
[(17 / 5 + 9 / 5) / 2 for _ in range(3)],
[(13 / 5 + 4 / 5) / 2 for _ in range(3)],
[3 / 2 for _ in range(3)]
]
cls.expected_boxplot_xticks_locations = [1, 2, 3, 4]
cls.expected_boxplot_xticks_labels = [
'Defector', 'Tit For Tat', 'Alternator']
cls.expected_lengthplot_dataset = [
[cls.turns for _ in range(3)],
[cls.turns for _ in range(3)],
[cls.turns for _ in range(3)],
]
cls.expected_payoff_dataset = [
[0, mean(
[9 / 5 for _ in range(3)]),
mean([17 / 5 for _ in range(3)])],
[mean(
[4 / 5 for _ in range(3)]), 0,
mean([13 / 5 for _ in range(3)])],
[mean(
[2 / 5 for _ in range(3)]),
mean([13 / 5 for _ in range(3)]), 0]
]
cls.expected_winplot_dataset = (
[[2, 2, 2], [0, 0, 0], [0, 0, 0]],
['Defector', 'Tit For Tat', 'Alternator'])
def test_init(self):
rs = axelrod.ResultSet(self.players, 5, 2)
expected_results = [[[0,0] for j in range(3)] for i in range(3)]
self.assertEquals(rs.nplayers, 3)
self.assertEquals(rs.players, self.players)
self.assertEquals(rs.turns, 5)
self.assertEquals(rs.repetitions, 2)
self.assertTrue(rs.results, expected_results)
self.assertFalse(rs.finalised)
def test_equality(self):
rs_sets = [axelrod.ResultSet(self.players, self.interactions,
progress_bar=False) for _ in range(2)]
self.assertEqual(rs_sets[0], rs_sets[1])
players = [s() for s in axelrod.demo_strategies]
tournament = axelrod.Tournament(players, repetitions=2, turns=5)
results = tournament.play()
self.assertNotEqual(results, rs_sets[0])
def test_vengeful_cooperation(self):
rs = axelrod.ResultSet(
self.filename, self.players, self.repetitions, progress_bar=False
)
self.assertIsInstance(rs.vengeful_cooperation, list)
self.assertEqual(len(rs.vengeful_cooperation), rs.num_players)
for i, row in enumerate(rs.vengeful_cooperation):
for j, col in enumerate(row):
self.assertAlmostEqual(col, self.expected_vengeful_cooperation[i][j])
def test_initial_cooperation_rate(self):
rs = axelrod.ResultSet(
self.filename, self.players, self.repetitions, progress_bar=False
)
self.assertIsInstance(rs.initial_cooperation_rate, list)
self.assertEqual(len(rs.initial_cooperation_rate), rs.num_players)
self.assertEqual(
rs.initial_cooperation_rate, self.expected_initial_cooperation_rate
)
def test_build_all(self):
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=False)
rs = axelrod.ResultSet(self.players, self.interactions,
progress_bar=False)
brs._build_empty_metrics()
self.assertNotEqual(brs, rs)
brs._build_score_related_metrics(progress_bar=False)
self.assertEqual(brs, rs)
def test_payoff_diffs_means(self):
rs = axelrod.ResultSet(
self.filename, self.players, self.repetitions, progress_bar=False
)
self.assertIsInstance(rs.payoff_diffs_means, list)
self.assertEqual(len(rs.payoff_diffs_means), rs.num_players)
for i, row in enumerate(rs.payoff_diffs_means):
for j, col in enumerate(row):
self.assertAlmostEqual(col, self.expected_payoff_diffs_means[i][j])
def test_score_diffs(self):
rs = axelrod.ResultSet(self.players, self.interactions)
self.assertIsInstance(rs.score_diffs, list)
self.assertEqual(len(rs.score_diffs), rs.nplayers)
for i, row in enumerate(rs.score_diffs):
for j, col in enumerate(row):
for k, score in enumerate(col):
self.assertAlmostEqual(score,
self.expected_score_diffs[i][j][k])
def recover_results(p, r):
file_path = p
run_number = r
with open(file_path + 'players-run' + str(run_number), 'rb') as handle:
played = pickle.load(handle)
myfile = file_path + 'run' + str(run_number)
secondresults = axl.ResultSet(myfile, players=played, repetitions=10)
#print(secondresults.ranked_names)
return secondresults
def test_init_from_resulsetfromfile(self):
tmp_file = tempfile.NamedTemporaryFile(mode="w", delete=False)
players = [axl.Cooperator(), axl.TitForTat(), axl.Defector()]
tournament = axl.Tournament(players=players, turns=2, repetitions=2)
tournament.play(filename=tmp_file.name, progress_bar=False)
tmp_file.close()
rs = axl.ResultSet(tmp_file.name, players, 2, progress_bar=False)
plot = axl.Plot(rs)
self.assertEqual(plot.result_set, rs)
def test_normalised_scores(self):
"""
Need to test string representation because of nan
"""
rs = axelrod.ResultSet(self.players, self.interactions,
progress_bar=False)
self.assertIsInstance(rs.normalised_scores, list)
self.assertEqual(len(rs.normalised_scores), rs.nplayers)
self.assertEqual([[str(s) for s in player] for player in rs.normalised_scores]
, self.expected_normalised_scores)
def test_score_diffs(self):
rs = axelrod.ResultSet(
self.filename, self.players, self.repetitions, progress_bar=False
)
self.assertIsInstance(rs.score_diffs, list)
self.assertEqual(len(rs.score_diffs), rs.num_players)
for i, row in enumerate(rs.score_diffs):
for j, col in enumerate(row):
for k, score in enumerate(col):
self.assertAlmostEqual(score, self.expected_score_diffs[i][j][k])
def test_init_multiprocessing(self):
rs = axelrod.ResultSet(
self.filename,
self.players,
self.repetitions,
progress_bar=False,
processes=2,
)
self.assertEqual(rs.players, self.players)
self.assertEqual(rs.num_players, len(self.players))
rs = axelrod.ResultSet(
self.filename,
self.players,
self.repetitions,
progress_bar=False,
processes=0,
)
self.assertEqual(rs.players, self.players)
self.assertEqual(rs.num_players, len(self.players))
