class TestProbEndTournament(unittest.TestCase):
def test_call(self):
tournament = tournaments().example()
self.assertIsInstance(tournament, axelrod.Tournament)
@given(tournament=prob_end_tournaments(min_prob_end=0,
max_prob_end=1,
min_noise=0,
max_noise=1,
min_repetitions=2,
max_repetitions=50,
max_size=3))
@settings(max_examples=5, max_iterations=20)
def test_decorator(self, tournament):
self.assertIsInstance(tournament, axelrod.Tournament)
self.assertLessEqual(tournament.prob_end, 1)
self.assertGreaterEqual(tournament.prob_end, 0)
self.assertLessEqual(tournament.noise, 1)
self.assertGreaterEqual(tournament.noise, 0)
self.assertLessEqual(tournament.repetitions, 50)
self.assertGreaterEqual(tournament.repetitions, 2)
@given(tournament=prob_end_tournaments(strategies=axelrod.basic_strategies,
max_size=3))
@settings(max_examples=5, max_iterations=20)
def test_decorator_with_given_strategies(self, tournament):
self.assertIsInstance(tournament, axelrod.Tournament)
basic_player_names = [str(s()) for s in axelrod.basic_strategies]
for p in tournament.players:
self.assertIn(str(p), basic_player_names)
class TestProbEndTournament(unittest.TestCase):
def test_call(self):
tournament, seed = prob_end_tournaments().example()
self.assertTrue(str(seed).startswith('random.seed'))
self.assertIsInstance(tournament, axelrod.Tournament)
@given(tournament_and_seed=prob_end_tournaments(min_prob_end=0,
max_prob_end=1,
min_noise=0,
max_noise=1,
min_repetitions=2,
max_repetitions=50,
max_size=3))
@settings(max_examples=10, timeout=0)
def test_decorator(self, tournament_and_seed):
tournament, seed = tournament_and_seed
self.assertTrue(str(seed).startswith('random.seed'))
self.assertIsInstance(tournament, axelrod.ProbEndTournament)
self.assertLessEqual(tournament.prob_end, 1)
self.assertGreaterEqual(tournament.prob_end, 0)
self.assertLessEqual(tournament.noise, 1)
self.assertGreaterEqual(tournament.noise, 0)
self.assertLessEqual(tournament.repetitions, 50)
self.assertGreaterEqual(tournament.repetitions, 2)
@given(tournament_and_seed=prob_end_tournaments(
strategies=axelrod.basic_strategies, max_size=3))
@settings(max_examples=10, timeout=0)
def test_decorator_with_given_strategies(self, tournament_and_seed):
tournament, seed = tournament_and_seed
self.assertTrue(str(seed).startswith('random.seed'))
self.assertIsInstance(tournament, axelrod.ProbEndTournament)
basic_player_names = [str(s()) for s in axelrod.basic_strategies]
for p in tournament.players:
self.assertIn(str(p), basic_player_names)
@given(tournament_and_seed=prob_end_tournaments(
strategies=stochastic_strategies, max_size=3))
@settings(max_examples=10, timeout=0)
def test_decorator_with_stochastic_strategies(self, tournament_and_seed):
tournament, seed = tournament_and_seed
self.assertTrue(str(seed).startswith('random.seed'))
self.assertIsInstance(tournament, axelrod.ProbEndTournament)
stochastic_player_names = [str(s()) for s in stochastic_strategies]
for p in tournament.players:
self.assertIn(str(p), stochastic_player_names)
class TestProbEndTournament(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.game = axelrod.Game()
cls.players = [s() for s in test_strategies]
cls.test_name = 'test'
cls.test_repetitions = test_repetitions
cls.test_prob_end = test_prob_end
def test_init(self):
tournament = axelrod.ProbEndTournament(name=self.test_name,
players=self.players,
game=self.game,
prob_end=self.test_prob_end,
noise=0.2)
self.assertEqual(tournament.match_generator.prob_end,
tournament.prob_end)
self.assertEqual(len(tournament.players), len(test_strategies))
self.assertEqual(tournament.game.score(('C', 'C')), (3, 3))
self.assertEqual(tournament.turns, float("inf"))
self.assertEqual(tournament.repetitions, 10)
self.assertEqual(tournament.name, 'test')
self.assertTrue(tournament._with_morality)
self.assertIsInstance(tournament._logger, logging.Logger)
self.assertEqual(tournament.noise, 0.2)
anonymous_tournament = axelrod.Tournament(players=self.players)
self.assertEqual(anonymous_tournament.name, 'axelrod')
@given(tournament=prob_end_tournaments(min_size=2,
max_size=5,
min_prob_end=.1,
max_prob_end=.9,
min_repetitions=2,
max_repetitions=4))
@settings(max_examples=50, timeout=0)
@example(tournament=axelrod.ProbEndTournament(
players=[s() for s in test_strategies],
prob_end=.2,
repetitions=test_repetitions))
# These two examples are to make sure #465 is fixed.
# As explained there: https://github.com/Axelrod-Python/Axelrod/issues/465,
# these two examples were identified by hypothesis.
@example(tournament=axelrod.ProbEndTournament(
players=[axelrod.BackStabber(),
axelrod.MindReader()],
prob_end=.2,
repetitions=1))
@example(tournament=axelrod.ProbEndTournament(
players=[axelrod.ThueMorse(),
axelrod.MindReader()],
prob_end=.2,
repetitions=1))
def test_property_serial_play(self, tournament):
"""Test serial play using hypothesis"""
# Test that we get an instance of ResultSet
results = tournament.play(progress_bar=False)
self.assertIsInstance(results, axelrod.ResultSet)
self.assertEqual(results.nplayers, len(tournament.players))
self.assertEqual(results.players, [str(p) for p in tournament.players])
class TestResultSetFromFile(unittest.TestCase):
filename = "test_outputs/test_results_from_file.csv"
players = [axelrod.Cooperator(),
axelrod.TitForTat(),
axelrod.Defector()]
tournament = axelrod.Tournament(players=players, turns=2, repetitions=3)
tournament.play(filename=filename)
interactions = iu.read_interactions_from_file(filename)
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_init_with_progress_bar(self):
"""Just able to test that no error occurs"""
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=True)
self.assertEqual(brs.nplayers, len(self.players))
self.assertEqual(brs.nrepetitions, 3)
self.assertEqual(brs.num_interactions, 18)
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_init_with_players_nrepetitions(self):
"""Just able to test that no error occurs"""
brs = axelrod.ResultSetFromFile(self.filename, progress_bar=True,
num_interactions=18, nrepetitions=3,
players=[str(p) for p in self.players])
self.assertEqual(brs.nplayers, len(self.players))
self.assertEqual(brs.nrepetitions, 3)
self.assertEqual(brs.num_interactions, 18)
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)
@given(tournament=tournaments(max_size=5,
max_turns=5,
max_noise=0,
max_repetitions=3))
@settings(max_examples=50, timeout=0)
def test_equality_with_round_robin(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)
@given(tournament=prob_end_tournaments(max_size=5,
min_prob_end=.7,
max_repetitions=3))
@settings(max_examples=50, timeout=0)
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_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)
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_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_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_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_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_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_call(self):
tournament, seed = prob_end_tournaments().example()
self.assertTrue(str(seed).startswith('random.seed'))
self.assertIsInstance(tournament, axelrod.Tournament)
def test_call(self):
tournament, seed = prob_end_tournaments().example()
self.assertTrue(str(seed).startswith('random.seed'))
self.assertIsInstance(tournament, axelrod.Tournament)
