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