def test_progres_bar(self):
rs = axelrod.ResultSetFromFile(self.tmp_file.name, progress_bar=True)
self.assertEqual(rs.read_progress_bar.total, 6)
# Test that can give length
rs = axelrod.ResultSetFromFile(self.tmp_file.name,
progress_bar=True,
num_interactions=6)
self.assertEqual(rs.read_progress_bar.total, 6)
def test_init_with_num_interactions(self):
"""Just able to test that no error occurs"""
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=True,
num_interactions=18)
self.assertEqual(brs.nplayers, len(self.players))
self.assertEqual(brs.nrepetitions, 3)
self.assertEqual(brs.num_interactions, 18)
def test_progress_bar_play(self):
"""Test that progress bar is created by default and with True argument"""
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
turns=200,
repetitions=self.test_repetitions)
results = tournament.play()
self.assertIsInstance(results, axelrod.ResultSet)
self.assertEqual(tournament.progress_bar.total, 15)
self.assertEqual(tournament.progress_bar.total,
tournament.progress_bar.n)
results = tournament.play(progress_bar=True)
self.assertIsInstance(results, axelrod.ResultSet)
self.assertEqual(tournament.progress_bar.total, 15)
self.assertEqual(tournament.progress_bar.total,
tournament.progress_bar.n)
# Test without build results
results = tournament.play(progress_bar=True,
build_results=False,
filename=self.filename)
self.assertIsNone(results)
results = axelrod.ResultSetFromFile(self.filename)
self.assertIsInstance(results, axelrod.ResultSet)
self.assertEqual(tournament.progress_bar.total, 15)
self.assertEqual(tournament.progress_bar.total,
tournament.progress_bar.n)
def test_no_progress_bar_play(self):
"""Test that progress bar is not created for progress_bar=False"""
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
turns=axelrod.DEFAULT_TURNS,
repetitions=self.test_repetitions)
# Test with build results
RecordedTQDM.reset_record()
results = tournament.play(progress_bar=False)
self.assertIsInstance(results, axelrod.ResultSet)
# Check that no progress bar was created.
self.assertEqual(RecordedTQDM.record, [])
# Test without build results
RecordedTQDM.reset_record()
results = tournament.play(progress_bar=False,
build_results=False,
filename=self.filename)
self.assertIsNone(results)
self.assertEqual(RecordedTQDM.record, [])
results = axelrod.ResultSetFromFile(self.filename, progress_bar=False)
self.assertIsInstance(results, axelrod.ResultSet)
def test_build_players(self):
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=False)
brs.players_d = {}
brs._update_players((0, 0), ('Cooperator', 'Cooperator'))
brs._update_players((0, 1), ('Cooperator', 'Defector'))
players = brs._build_players()
self.assertEqual(players, ['Cooperator', 'Defector'])
self.assertFalse(hasattr(brs, 'players_d'))
def test_build_read_match_chunks(self):
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=False)
matches = brs.read_match_chunks()
chunk = next(matches)
self.assertEqual(chunk[0], ['0'] * 2 + ['Cooperator'] * 2 + ['CC'] * 2)
self.assertEqual(chunk[1], ['0'] * 2 + ['Cooperator'] * 2 + ['CC'] * 2)
self.assertEqual(chunk[2], ['0'] * 2 + ['Cooperator'] * 2 + ['CC'] * 2)
self.assertEqual(len(list(matches)), 5)
def test_build_repetitions(self):
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=False)
brs.repetitions_d = {}
brs._update_repetitions((0, 0))
brs._update_repetitions((0, 0))
nrepetitions = brs._build_nrepetitions()
self.assertEqual(nrepetitions, 2)
self.assertFalse(hasattr(brs, 'repetitions_d'))
def test_update_repetitions(self):
brs = axelrod.ResultSetFromFile(filename=self.filename, progress_bar=False)
brs.repetitions_d = {}
brs._update_repetitions((0, 0))
self.assertEqual(brs.repetitions_d, {(0, 0): 1})
brs._update_repetitions((0, 0))
self.assertEqual(brs.repetitions_d, {(0, 0): 2})
brs._update_repetitions((0, 1))
self.assertEqual(brs.repetitions_d, {(0, 0): 2, (0, 1): 1})
def test_update_players(self):
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=False)
brs.players_d = {}
brs._update_players((0, 0), ('Cooperator', 'Cooperator'))
self.assertEqual(brs.players_d, {0: 'Cooperator'})
brs._update_players((0, 0), ('Cooperator', 'Cooperator'))
self.assertEqual(brs.players_d, {0: 'Cooperator'})
brs._update_players((0, 1), ('Cooperator', 'Defector'))
self.assertEqual(brs.players_d, {0: 'Cooperator', 1: 'Defector'})
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_equality_with_prob_end(self, tournament):
filename = "test_outputs/test_results.csv"
tournament.play(filename=filename, progress_bar=False,
build_results=False)
brs = axelrod.ResultSetFromFile(filename, progress_bar=False)
interactions = iu.read_interactions_from_file(filename)
rs = axelrod.ResultSet(tournament.players, interactions,
progress_bar=False)
# Not testing full equality because of floating point errors.
self.assertEqual(rs.ranked_names, brs.ranked_names)
self.assertEqual(rs.scores, brs.scores)
self.assertEqual(rs.match_lengths, brs.match_lengths)
self.assertEqual(rs.cooperation, brs.cooperation)
def test_init_from_resulsetfromfile(self):
tmp_file = tempfile.NamedTemporaryFile(mode='w', delete=False)
tournament = axelrod.Tournament(
players=[axelrod.Cooperator(),
axelrod.TitForTat(),
axelrod.Defector()],
turns=2,
repetitions=2)
tournament.play(filename=tmp_file.name, progress_bar=False)
tmp_file.close()
rs = axelrod.ResultSetFromFile(tmp_file.name, progress_bar=False)
plot = axelrod.Plot(rs)
self.assertEqual(plot.result_set, rs)
def test_no_build_result_set(self):
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
turns=axelrod.DEFAULT_TURNS,
repetitions=self.test_repetitions)
results = tournament.play(build_results=False,
filename=self.filename,
progress_bar=False)
self.assertIsNone(results)
# Checking that results were written properly
results = axelrod.ResultSetFromFile(self.filename, progress_bar=False)
self.assertIsInstance(results, axelrod.ResultSet)
def test_no_build_result_set(self):
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
turns=200,
repetitions=self.test_repetitions)
tmp_file = tempfile.NamedTemporaryFile(mode='w', delete=False)
results = tournament.play(build_results=False,
filename=tmp_file.name,
progress_bar=False)
self.assertIsNone(results)
# Checking that results were written properly
results = axelrod.ResultSetFromFile(tmp_file.name)
self.assertIsInstance(results, axelrod.ResultSet)
def test_init(self):
rs = axelrod.ResultSetFromFile(self.tmp_file.name, progress_bar=False)
players = ['Cooperator', 'Tit For Tat', 'Defector']
self.assertEqual(rs.players, players)
self.assertEqual(rs.nplayers, len(players))
self.assertEqual(rs.nrepetitions, 1)
expected_interactions = {
(0, 1): [[('C', 'C'), ('C', 'C')]],
(1, 2): [[('C', 'D'), ('D', 'D')]],
(0, 0): [[('C', 'C'), ('C', 'C')]],
(2, 2): [[('D', 'D'), ('D', 'D')]],
(0, 2): [[('C', 'D'), ('C', 'D')]],
(1, 1): [[('C', 'C'), ('C', 'C')]]
}
self.assertEqual(rs.interactions, expected_interactions)
def test_buid_empty_metrics(self):
plist = range(3)
nrepetitions = 3
replist = range(nrepetitions)
expected_match_lengths = [[[0 for opponent in plist] for player in plist]
for _ in replist]
expected_wins = [[0 for _ in replist] for player in plist]
expected_scores = [[0 for _ in replist] for player in plist]
expected_normalised_scores = [[[] for _ in replist] for player in plist]
expected_payoffs = [[[] for opponent in plist] for player in plist]
expected_score_diffs = [[[0] * nrepetitions for opponent in plist]
for player in plist]
expected_cooperation = [[0 for opponent in plist] for player in plist]
expected_normalised_cooperation = [[[] for opponent in plist]
for player in plist]
expected_good_partner_matrix = [[0 for opponent in plist]
for player in plist]
expected_good_partner_rating = [0 for player in plist]
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=False)
brs.match_lengths = []
brs.wins = []
brs.scores = []
brs.normalised_scores = []
brs.payoffs = []
brs.score_diffs = []
brs.cooperation = []
brs.normalised_cooperation = []
brs.good_partner_matrix = []
brs.total_interactions = []
brs.good_partner_rating = []
brs._build_empty_metrics()
self.assertEqual(brs.match_lengths, expected_match_lengths)
self.assertEqual(brs.wins, expected_wins)
self.assertEqual(brs.scores, expected_scores)
self.assertEqual(brs.normalised_scores, expected_normalised_scores)
self.assertEqual(brs.payoffs, expected_payoffs)
self.assertEqual(brs.score_diffs, expected_score_diffs)
self.assertEqual(brs.cooperation, expected_cooperation)
self.assertEqual(brs.normalised_cooperation,
expected_normalised_cooperation)
self.assertEqual(brs.good_partner_matrix, expected_good_partner_matrix)
self.assertEqual(brs.good_partner_rating, expected_good_partner_rating)
def test_no_progress_bar_play(self):
"""Test that progress bar is not created for progress_bar=False"""
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
turns=200,
repetitions=self.test_repetitions)
# Test with build results
results = tournament.play(progress_bar=False)
self.assertIsInstance(results, axelrod.ResultSet)
# Check that no progress bar was created
call_progress_bar = lambda: tournament.progress_bar.total
self.assertRaises(AttributeError, call_progress_bar)
# Test without build results
results = tournament.play(progress_bar=False,
build_results=False,
filename=self.filename)
self.assertIsNone(results)
results = axelrod.ResultSetFromFile(self.filename, progress_bar=False)
self.assertIsInstance(results, axelrod.ResultSet)
self.assertRaises(AttributeError, call_progress_bar)
def test_progress_bar_play(self):
"""Test that progress bar is created by default and with True argument"""
tournament = axelrod.Tournament(name=self.test_name,
players=self.players,
game=self.game,
turns=axelrod.DEFAULT_TURNS,
repetitions=self.test_repetitions)
RecordedTQDM.reset_record()
results = tournament.play()
self.assertIsInstance(results, axelrod.ResultSet)
# Check that progress bar was created, updated and closed.
self.assertEqual(len(RecordedTQDM.record), 3)
play_pbar = RecordedTQDM.record[0]
self.assert_play_pbar_correct_total_and_finished(play_pbar, total=15)
# Check all progress bars are closed.
self.assertTrue(all(pbar.disable for pbar in RecordedTQDM.record))
RecordedTQDM.reset_record()
results = tournament.play(progress_bar=True)
self.assertIsInstance(results, axelrod.ResultSet)
self.assertEqual(len(RecordedTQDM.record), 3)
play_pbar = RecordedTQDM.record[0]
self.assert_play_pbar_correct_total_and_finished(play_pbar, total=15)
# Test without build results
RecordedTQDM.reset_record()
results = tournament.play(progress_bar=True,
build_results=False,
filename=self.filename)
self.assertIsNone(results)
self.assertEqual(len(RecordedTQDM.record), 1)
play_pbar = RecordedTQDM.record[0]
self.assert_play_pbar_correct_total_and_finished(play_pbar, total=15)
results = axelrod.ResultSetFromFile(self.filename)
self.assertIsInstance(results, axelrod.ResultSet)
def test_string_to_interactions(self):
rs = axelrod.ResultSetFromFile(self.tmp_file.name)
string = 'CDCDDD'
interactions = [('C', 'D'), ('C', 'D'), ('D', 'D')]
self.assertEqual(rs._string_to_interactions(string), interactions)
def test_init(self):
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=False)
self.assertEqual(brs.players, [str(p) for p in self.players])
self.assertEqual(brs.nplayers, len(self.players))
self.assertEqual(brs.nrepetitions, 3)
def test_init_with_different_game(self):
game = axelrod.Game(p=-1, r=-1, s=-1, t=-1)
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=False,
game=game)
self.assertEqual(brs.game.RPST(), (-1, -1, -1, -1))
def test_equality(self):
"""A test that checks overall equality by comparing to the base result
set class"""
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=False)
rs = axelrod.ResultSet(self.players, self.interactions, progress_bar=False)
self.assertEqual(rs, brs)
def test_interactions_equality(self):
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=False,
keep_interactions=True)
rs = axelrod.ResultSet(self.players, self.interactions, progress_bar=False)
self.assertEqual(rs.interactions, brs.interactions)
def test_read_players_and_repetitions(self):
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=False)
players, nrepetitions = brs._read_players_and_repetition_numbers()
expected_players = ['Cooperator', 'Tit For Tat', 'Defector']
self.assertEqual(brs.players, expected_players)
self.assertEqual(nrepetitions, 3)
