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.assertEqual(tournament._processes, None)
self.assertTrue(tournament._with_morality)
self.assertIsInstance(tournament._logger, logging.Logger)
self.assertEqual(tournament.deterministic_cache, {})
self.assertEqual(tournament.noise, 0.2)
self.assertEqual(tournament._parallel_repetitions, 10)
anonymous_tournament = axelrod.Tournament(players=self.players)
self.assertEqual(anonymous_tournament.name, 'axelrod')
# Test init when passing a cache:
cache = axelrod.DeterministicCache()
tournament = axelrod.ProbEndTournament(
name=self.test_name,
players=self.players,
game=self.game,
prob_end=self.test_prob_end,
processes=4,
noise=0.2,
deterministic_cache=cache)
self.assertEqual(tournament.deterministic_cache, cache)
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])
def test_complete_tournament(self, strategies, prob_end, seed, reps):
"""
A test to check that a spatial tournament on the complete graph
gives the same results as the round robin.
"""
players = [s() for s in strategies]
# create a prob end round robin tournament
tournament = axelrod.ProbEndTournament(players,
prob_end=prob_end,
repetitions=reps)
axelrod.seed(seed)
results = tournament.play(progress_bar=False)
# create a complete spatial tournament
# edges
edges = [(i, j) for i in range(len(players))
for j in range(i, len(players))]
spatial_tournament = axelrod.ProbEndSpatialTournament(
players, prob_end=prob_end, repetitions=reps, edges=edges)
axelrod.seed(seed)
spatial_results = spatial_tournament.play(progress_bar=False)
self.assertEqual(results.match_lengths, spatial_results.match_lengths)
self.assertEqual(results.ranked_names, spatial_results.ranked_names)
self.assertEqual(results.wins, spatial_results.wins)
self.assertEqual(results.scores, spatial_results.scores)
self.assertEqual(results.cooperation, spatial_results.cooperation)
def test_players_do_not_know_match_length(self):
"""Create two players who should cooperate on last two turns if they
don't know when those last two turns are.
"""
p1 = FinalTransformer(['D', 'D'])(axelrod.Cooperator)()
p2 = FinalTransformer(['D', 'D'])(axelrod.Cooperator)()
players = [p1, p2]
tournament = axelrod.ProbEndTournament(players,
prob_end=.1,
repetitions=1)
results = tournament.play(progress_bar=False)
# Check that both plays always cooperated
for rating in results.cooperating_rating:
self.assertEqual(rating, 1)
def main(players=players):
# Deleting the file if it exists
try:
os.remove(filename)
except OSError:
pass
axl.seed(seed) # Setting a seed
tournament = axl.ProbEndTournament(players, prob_end=prob_end,
repetitions=repetitions)
results = tournament.play(filename=filename, processes=processes)
utils.obtain_assets(results, "strategies", "probend", lengthplot=True)
results.write_summary('assets/probend_summary.csv')
def test_property_serial_play(self, s, prob_end, repetitions, rm):
"""Test serial play using hypothesis"""
# Test that we get an instance of ResultSet
players = [strat() for strat in s]
tournament = axelrod.ProbEndTournament(
name=self.test_name,
players=players,
game=self.game,
prob_end=prob_end,
repetitions=repetitions)
results = tournament.play()
self.assertIsInstance(results, axelrod.ResultSet)
self.assertEqual(results.nplayers, len(players))
self.assertEqual(results.players, players)
self.assertEqual(len(results.interactions), repetitions)
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')
def prob_end_tournaments(draw, strategies=axelrod.strategies,
min_size=1, max_size=10,
min_prob_end=0, max_prob_end=1,
min_noise=0, max_noise=1,
min_repetitions=1, max_repetitions=20):
"""
A hypothesis decorator to return a tournament and a random seed (to ensure
reproducibility for strategies that make use of the random module when
initiating).
Parameters
----------
min_size : integer
The minimum number of strategies to include
max_size : integer
The maximum number of strategies to include
min_prob_end : float
The minimum probability of a match ending
max_prob_end : float
The maximum probability of a match ending
min_noise : float
The minimum noise value
min_noise : float
The maximum noise value
min_repetitions : integer
The minimum number of repetitions
max_repetitions : integer
The maximum number of repetitions
"""
seed = draw(random_module())
strategies = draw(strategy_lists(strategies=strategies,
min_size=min_size,
max_size=max_size))
players = [s() for s in strategies]
prob_end = draw(floats(min_value=min_prob_end, max_value=max_prob_end))
repetitions = draw(integers(min_value=min_repetitions,
max_value=max_repetitions))
noise = draw(floats(min_value=min_noise, max_value=max_noise))
tournament = axelrod.ProbEndTournament(players, prob_end=prob_end,
repetitions=repetitions, noise=noise)
return tournament, seed
