def test_stochastic_outcomes(self): for seed, expected in zip(range(2), [[0, 1, 0, 1, 0], [0, 0, 0, 1, 1]]): axl.seed(seed) player = axl.TitForTat() opponent = axl.Defector() expected_fixation_probabilities = expected fixation_probabilities = utils.objective_moran_win(player, opponent, turns=3, repetitions=5, noise=0) self.assertEqual(fixation_probabilities, expected_fixation_probabilities)
def setUpClass(cls): cls.test_key = (axl.TitForTat(), axl.Defector()) cls.test_value = [(C, D), (D, D), (D, D)] save_path = pathlib.Path("test_outputs/test_cache_save.txt") cls.test_save_file = axl_filename(save_path) load_path = pathlib.Path("test_outputs/test_cache_load.txt") cls.test_load_file = axl_filename(load_path) test_data_to_pickle = { ("Tit For Tat", "Defector"): [(C, D), (D, D), (D, D)] } cls.test_pickle = pickle.dumps(test_data_to_pickle) with open(cls.test_load_file, "wb") as f: f.write(cls.test_pickle)
def test_strategy(self): axelrod.seed(0) vector = [random.random() for _ in range(16)] actions = [(C, C), (C, C), (D, D), (D, C), (C, C), (C, D), (C, C)] self.versus_test(opponent=axelrod.CyclerCCD(), expected_actions=actions, seed=0, init_kwargs={'sixteen_vector': vector}) actions = [(C, C), (C, C), (C, D), (D, C), (C, C), (C, D), (C, C)] self.versus_test(opponent=axelrod.CyclerCCD(), expected_actions=actions, seed=1, init_kwargs={'sixteen_vector': vector}) actions = [(C, C), (C, C), (D, C), (D, D), (C, D), (C, C), (D, C)] self.versus_test(opponent=axelrod.TitForTat(), expected_actions=actions, seed=0, init_kwargs={'sixteen_vector': vector}) actions = [(C, C), (C, C), (C, C), (D, C), (D, D), (C, D), (C, C)] self.versus_test(opponent=axelrod.TitForTat(), expected_actions=actions, seed=1, init_kwargs={'sixteen_vector': vector})
def test_fingeprint_explicit_probe(self): af = AshlockFingerprint(axl.TitForTat(), probe=axl.Random(p=0.1)) af.fingerprint(turns=10, repetitions=2, step=0.5, progress_bar=False) probes = af.spatial_tournament.players[1:] self.assertEqual( str(probes[0]), "Joss-Ann Random: 0.1: (0.0, 0.0)" ) # x + y < 1 self.assertEqual( str(probes[2]), "Dual Joss-Ann Random: 0.1: (1.0, 0.0)" ) # x + y = 1 self.assertEqual( str(probes[8]), "Dual Joss-Ann Random: 0.1: (0.0, 0.0)" ) # x + y > 1
def test_final_score_per_turn(self): turns = 3 player1 = axelrod.TitForTat() player2 = axelrod.Defector() match = axelrod.Match((player1, player2), turns) self.assertEqual(match.final_score_per_turn(), None) match.play() self.assertEqual(match.final_score_per_turn(), (2/float(turns), 7/float(turns))) match = axelrod.Match((player2, player1), turns) self.assertEqual(match.final_score_per_turn(), None) match.play() self.assertEqual(match.final_score_per_turn(), (7/float(turns), 2/float(turns)))
def test_strategies_without_countermeasures_return_their_strategy(self): tft = axl.TitForTat() inspector = axl.Alternator() match = axl.Match((tft, inspector), turns=1) match.play() self.assertEqual(tft.history, [C]) self.assertEqual(inspect_strategy(inspector=inspector, opponent=tft), C) match = axl.Match((tft, inspector), turns=2) match.play() self.assertEqual(tft.history, [C, C]) self.assertEqual(inspect_strategy(inspector=inspector, opponent=tft), D) self.assertEqual(tft.strategy(inspector), D)
def test_strategy(self): self.versus_test( opponent=axl.TitForTat(), expected_actions=[(C, C), (D, C), (C, D)] + [(C, C)] * 15, ) self.versus_test( opponent=axl.Cooperator(), expected_actions=[(C, C), (D, C), (C, C), (C, C)] + [(D, C)] * 15, ) self.versus_test( opponent=axl.Defector(), expected_actions=[(C, D), (D, D), (C, D), (C, D)] + [(D, D)] * 15, )
def init_players(): players = [ #axl.Cooperator(), #axl.Defector(), #axl.Random(), #axl.WinStayLoseShift(), axl.TitForTat(), #axl.GTFT(), #axl.ZDExtortion(), #axl.ZDExtort2(), #axl.ZDGTFT2(), axl.ZDSet2(), ] return players
def setUpClass(cls): players = [axl.Alternator(), axl.TitForTat()] tournament = axl.Tournament(players) cls.results = tournament.play() cls.data = TournamentResultsSerializer(cls.results).data cls.expected_keys = [ 'filename', 'num_interactions', 'players', 'repetitions', 'nplayers', 'match_lengths', 'wins', 'scores', 'normalised_scores', 'payoffs', 'score_diffs', 'cooperation', 'normalised_cooperation', 'initial_cooperation_count', 'good_partner_matrix', 'total_interactions', 'good_partner_rating', 'ranking', 'ranked_names', 'payoff_matrix', 'payoff_stddevs', 'payoff_diffs_means', 'vengeful_cooperation', 'cooperating_rating', 'initial_cooperation_rate', 'eigenjesus_rating', 'eigenmoses_rating', 'wins', ]
def test_clone(self): """Tests player cloning.""" player1 = axl.Random(p=0.75) # 0.5 is the default player2 = player1.clone() turns = 50 for op in [axl.Cooperator(), axl.Defector(), axl.TitForTat()]: player1.reset() player2.reset() seed = random.randint(0, 10 ** 6) for p in [player1, player2]: axl.seed(seed) m = axl.Match((p, op), turns=turns) m.play() self.assertEqual(len(player1.history), turns) self.assertEqual(player1.history, player2.history)
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) plot = axelrod.Plot(rs) self.assertEqual(plot.result_set, rs) self.assertEqual(matplotlib_installed, plot.matplotlib_installed)
def test_dual_tft_transformer(self): """Tests that DualTransformer produces the opposite results when faced with the same opponent history. """ p1 = axelrod.TitForTat() p2 = DualTransformer()(axelrod.TitForTat)() p3 = axelrod.CyclerCCD() # Cycles 'CCD' for _ in range(10): p1.play(p3) p3.reset() for _ in range(10): p2.play(p3) self.assertEqual(p1.history, [flip_action(x) for x in p2.history])
def test_example(self): run = fa.NewAnalysisRun() run.save_file_prefix = "example-" run.add_opponent(axl.TitForTat()) run.add_opponent(axl.Random()) run.add_opponent(axl.Grudger()) # must have 12 opponents; 10 Randoms and the other 2 self.assertEqual(len(run.opponent_list), 12) run.start() import glob all_files = glob.glob("./output/*.csv") # assert all files were created self.assertEqual(len(all_files), 12)
def test_play_single_interaction(self): players = [ axelrod.Alternator(), axelrod.Defector(), axelrod.TitForTat() ] rr = axelrod.RoundRobin(players=players, game=self.game, turns=20) player1 = players[0] player2 = players[2] classes = (player1.__class__, player2.__class__) scores, cooperation_rates = (rr._play_single_interaction( player1, player2, classes)) expected_scores = (53, 48) expected_cooperation_rates = (10, 11) self.assertEqual(expected_scores, scores) self.assertEqual(expected_cooperation_rates, cooperation_rates)
def test_particular_tournament(self): """A test for a tournament that has caused failures during some bug fixing""" players = [axelrod.Cooperator(), axelrod.Defector(), axelrod.TitForTat(), axelrod.Grudger()] edges = [(0, 2), (0, 3), (1, 2), (1, 3)] tournament = axelrod.SpatialTournament(players, edges=edges) results = tournament.play(progress_bar=False) expected_ranked_names = ['Cooperator', 'Tit For Tat', 'Grudger', 'Defector'] self.assertEqual(results.ranked_names, expected_ranked_names) # Check that this tournament runs with noise tournament = axelrod.SpatialTournament(players, edges=edges, noise=.5) results = tournament.play(progress_bar=False) self.assertIsInstance(results, axelrod.ResultSet)
def test_specific_set_of_results(self): """ This tests specific reported results as discussed in https://github.com/Axelrod-Python/Axelrod/issues/1294 The results there used a version of mistrust with a bug that corresponds to a memory one player that start by defecting and only cooperates if both players cooperated in the previous round. """ mistrust_with_bug = axl.MemoryOnePlayer( initial=D, four_vector=(1, 0, 0, 0), ) players = [ self.player(), axl.TitForTat(), axl.GoByMajority(), axl.Grudger(), axl.WinStayLoseShift(), axl.Prober(), axl.Defector(), mistrust_with_bug, axl.Cooperator(), axl.CyclerCCD(), axl.CyclerDDC(), ] axl.seed(1) tournament = axl.Tournament(players, turns=1000, repetitions=1) results = tournament.play(progress_bar=False) scores = [ round(average_score_per_turn * 1000, 1) for average_score_per_turn in results.payoff_matrix[0] ] expected_scores = [ 3000.0, 3000.0, 3000.0, 3000.0, 3000.0, 2999.0, 983.0, 983.0, 3000.0, 3596.0, 2302.0, ] self.assertEqual(scores, expected_scores)
def test_init(self): players = axelrod.Cooperator(), axelrod.Defector() mp = MoranProcess(players) self.assertEqual(mp.turns, axelrod.DEFAULT_TURNS) self.assertIsNone(mp.prob_end) self.assertIsNone(mp.game) self.assertEqual(mp.noise, 0) self.assertEqual(mp.initial_players, players) self.assertEqual(mp.players, list(players)) self.assertEqual(mp.populations, [Counter({ "Cooperator": 1, "Defector": 1 })]) self.assertIsNone(mp.winning_strategy_name) self.assertEqual(mp.mutation_rate, 0) self.assertEqual(mp.mode, "bd") self.assertEqual(mp.deterministic_cache, axelrod.DeterministicCache()) self.assertEqual(mp.mutation_targets, { "Cooperator": [players[1]], "Defector": [players[0]] }) self.assertEqual(mp.interaction_graph._edges, [(0, 1), (1, 0)]) self.assertEqual(mp.reproduction_graph._edges, [(0, 1), (1, 0), (0, 0), (1, 1)]) self.assertEqual(mp.fitness_transformation, None) self.assertEqual(mp.locations, [0, 1]) self.assertEqual(mp.index, {0: 0, 1: 1}) # Test non default graph cases players = axelrod.Cooperator(), axelrod.Defector(), axelrod.TitForTat() edges = [(0, 1), (2, 0), (1, 2)] graph = axelrod.graph.Graph(edges, directed=True) mp = MoranProcess(players, interaction_graph=graph) self.assertEqual(mp.interaction_graph._edges, [(0, 1), (2, 0), (1, 2)]) self.assertEqual( sorted(mp.reproduction_graph._edges), sorted([(0, 1), (2, 0), (1, 2), (0, 0), (1, 1), (2, 2)]), ) mp = MoranProcess(players, interaction_graph=graph, reproduction_graph=graph) self.assertEqual(mp.interaction_graph._edges, [(0, 1), (2, 0), (1, 2)]) self.assertEqual(mp.reproduction_graph._edges, [(0, 1), (2, 0), (1, 2)])
def setUpClass(cls): cls.filename = "test_outputs/test_results.csv" cls.players = [axelrod.Alternator(), axelrod.TitForTat(), axelrod.Defector()] cls.repetitions = 3 cls.turns = 5 cls.test_result_set = axelrod.ResultSet( cls.filename, cls.players, cls.repetitions, progress_bar=False ) cls.test_result_set = axelrod.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_update_matrices(self): players = [ axelrod.Alternator(), axelrod.Defector(), axelrod.TitForTat() ] rr = axelrod.RoundRobin(players=players, game=self.game, turns=20) scores = (53, 48) cooperation_rates = (0.5, 0.55) payoffs = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] cooperation = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] rr._update_matrices(0, 2, scores, payoffs, cooperation_rates, cooperation) expected_payoffs = [[0, 0, 53], [0, 0, 0], [48, 0, 0]] expected_cooperation = [[0, 0, 0.5], [0, 0, 0], [0.55, 0, 0]] self.assertEqual(expected_payoffs, payoffs) self.assertEqual(expected_cooperation, cooperation)
def playWithFixed(TD, DP, MC): C = axl.Cooperator() D = axl.Defector() TFT = axl.TitForTat() BUL = axl.Bully() PAV = Pavlov() APAV = axl.APavlov2011() for learner in [TD,DP,MC]: players = [C, D, TFT, BUL, PAV, APAV, learner] tournament = axl.Tournament(players, turns=10000) results = tournament.play() title = learner.name + " VS Fixed Strategy Players" plot = axl.Plot(results) p = plot.boxplot(title) p.savefig(learner.name)
def test_tournament(self): """ Test tournament """ P1 = axelrod.Cooperator() P2 = axelrod.TitForTat() P3 = axelrod.Defector() P4 = axelrod.Grudger() P5 = axelrod.GoByMajority() tournament = axelrod.Axelrod(P1, P2, P3, P4, P5) results = tournament.tournament(turns=200, repetitions=5) self.assertEqual(sorted([(str(player), results[player]) for player in sorted(results.keys())]), sorted([ ('Tit For Tat', [2001, 2001, 2001, 2001, 2001]), ('Cooperator', [2200, 2200, 2200, 2200, 2200]), ('Defector', [2388, 2388, 2388, 2388, 2388]), ('Grudger', [2001, 2001, 2001, 2001, 2001]), ('Go By Majority', [2001, 2001, 2001, 2001, 2001])]))
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) cls.expected_boxplot_dataset = [ [(17.0 / 5 + 9.0 / 5) / 2 for _ in range(3)], [(13.0 / 5 + 4.0 / 5) / 2 for _ in range(3)], [3.0 / 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.0 for _ in range(3)]), mean([17/5.0 for _ in range(3)])], [mean([4/5.0 for _ in range(3)]), 0, mean([13/5.0 for _ in range(3)])], [mean([2/5.0 for _ in range(3)]), mean([13/5.0 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_winner(self): player1 = axelrod.TitForTat() player2 = axelrod.Defector() match = axelrod.Match((player1, player2), 3) self.assertEqual(match.winner(), None) match.play() self.assertEqual(match.winner(), player2) match = axelrod.Match((player2, player1), 3) self.assertEqual(match.winner(), None) match.play() self.assertEqual(match.winner(), player2) player1 = axelrod.Defector() match = axelrod.Match((player1, player2), 3) self.assertEqual(match.winner(), None) match.play() self.assertEqual(match.winner(), False)
def setUpClass(cls): cls.game = axelrod.Game() cls.players = [ axelrod.Cooperator(), axelrod.TitForTat(), axelrod.Defector(), axelrod.Grudger(), axelrod.GoByMajority()] cls.player_names = [str(p) for p in cls.players] cls.test_name = 'test' cls.test_repetitions = 5 cls.expected_outcome = [ ('Cooperator', [180, 180, 180, 180, 180]), ('Defector', [172, 172, 172, 172, 172]), ('Grudger', [199, 199, 199, 199, 199]), ('Soft Go By Majority', [199, 199, 199, 199, 199]), ('Tit For Tat', [199, 199, 199, 199, 199])] cls.expected_outcome.sort()
def test_pair_of_players(self): players = [ axelrod.Cooperator(), axelrod.Defector(), axelrod.TitForTat() ] rr = axelrod.RoundRobin(players=players, game=self.game, turns=20) player1, player2, key = rr._pair_of_players(0, 2) self.assertEqual(player1.name, 'Cooperator') self.assertEqual(player2.name, 'Tit For Tat') self.assertEqual(key[0], axelrod.Cooperator) self.assertEqual(key[1], axelrod.TitForTat) player1, player2, key = rr._pair_of_players(0, 0) self.assertEqual(player1.name, player2.name) self.assertEqual(key[0], key[1]) self.assertNotEqual(player1, player2) # Check that the two player instances are wholly independent player1.name = 'player 1' player2.name = 'player 2' self.assertNotEqual(player1.name, player2.name)
class TestResultSetFromFile(unittest.TestCase): tournament = axelrod.Tournament(players=[ axelrod.Cooperator(), axelrod.TitForTat(), axelrod.Defector() ], turns=2, repetitions=2) tmp_file = tempfile.NamedTemporaryFile(mode='w', delete=False) tournament.play(filename=tmp_file.name) tmp_file.close() def test_init(self): rs = axelrod.ResultSetFromFile(self.tmp_file.name) players = ['Cooperator', 'Tit For Tat', 'Defector'] self.assertEqual(rs.players, players) self.assertEqual(rs.nplayers, len(players)) self.assertEqual(rs.nrepetitions, 2) 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')] }, { (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_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 setUpClass(cls): cls.game = axelrod.Game() cls.players = [ axelrod.Cooperator(), axelrod.TitForTat(), axelrod.Defector(), axelrod.Grudger(), axelrod.GoByMajority(), ] cls.player_names = [str(p) for p in cls.players] cls.test_name = "test" cls.test_repetitions = 3 cls.expected_outcome = [ ("Cooperator", [45, 45, 45]), ("Defector", [52, 52, 52]), ("Grudger", [49, 49, 49]), ("Soft Go By Majority", [49, 49, 49]), ("Tit For Tat", [49, 49, 49]), ] cls.expected_outcome.sort()
def test_clone(self, seed): # Test that the cloned player produces identical play player1 = self.player() player2 = player1.clone() self.assertEqual(len(player2.history), 0) self.assertEqual(player2.cooperations, 0) self.assertEqual(player2.defections, 0) self.assertEqual(player2.state_distribution, {}) self.assertEqual(player2.classifier, player1.classifier) self.assertEqual(player2.match_attributes, player1.match_attributes) turns = 10 for op in [ axl.Cooperator(), axl.Defector(), axl.TitForTat(), ]: for p in [player1, player2]: match = axl.Match((p, op), turns=turns, reset=True, seed=seed) match.play() self.assertEqual(len(player1.history), turns) self.assertEqual(player1.history, player2.history)
def main(): strategies = [ axelrod.Cooperator(), axelrod.Defector(), axelrod.Random(0.4), axelrod.Random(0.5), axelrod.Random(0.9), axelrod.Alternator(), axelrod.TitForTat(), axelrod.GTFT(), axelrod.WinStayLoseShift(), axelrod.ZDGTFT2(), axelrod.ZDExtort2(), axelrod.TitFor2Tats(), axelrod.TwoTitsForTat(), axelrod.CyclerCCD(), axelrod.CyclerCCCD(), axelrod.CyclerCCCCCD(), axelrod.HardTitForTat(), axelrod.AntiCycler(), axelrod.Grudger() ] for opponent in strategies: data_dict, test_results, estimate = infer_depth(opponent) print opponent print "-" * len(str(opponent)) print "Collected Data" print_dict(data_dict) C_count = sum(v[0] for (k, v) in data_dict.items()) D_count = sum(v[1] for (k, v) in data_dict.items()) print "C count, D count: %s, %s" % (C_count, D_count) print "\nFisher Exact Tests" print_dict(test_results) print "\nEstimated Memory One Probabilities" print_dict(estimate) print
def test_tft_fingerprint(self): axl.seed(0) # Fingerprinting is a random process. test_data = { Point(x=0.0, y=0.0): 3.000, Point(x=0.0, y=0.25): 1.820, Point(x=0.0, y=0.5): 1.130, Point(x=0.0, y=0.75): 1.050, Point(x=0.0, y=1.0): 0.980, Point(x=0.25, y=0.0): 3.000, Point(x=0.25, y=0.25): 2.440, Point(x=0.25, y=0.5): 1.770, Point(x=0.25, y=0.75): 1.700, Point(x=0.25, y=1.0): 1.490, Point(x=0.5, y=0.0): 3.000, Point(x=0.5, y=0.25): 2.580, Point(x=0.5, y=0.5): 2.220, Point(x=0.5, y=0.75): 2.000, Point(x=0.5, y=1.0): 1.940, Point(x=0.75, y=0.0): 3.000, Point(x=0.75, y=0.25): 2.730, Point(x=0.75, y=0.5): 2.290, Point(x=0.75, y=0.75): 2.310, Point(x=0.75, y=1.0): 2.130, Point(x=1.0, y=0.0): 3.000, Point(x=1.0, y=0.25): 2.790, Point(x=1.0, y=0.5): 2.480, Point(x=1.0, y=0.75): 2.310, Point(x=1.0, y=1.0): 2.180, } af = axl.AshlockFingerprint(axl.TitForTat(), axl.TitForTat) data = af.fingerprint(turns=50, repetitions=2, step=0.25, progress_bar=False) for key, value in data.items(): self.assertAlmostEqual(value, test_data[key], places=2)