def test():
print("Création d'un tournois de 4 rounds avec 8 joueurs.")
rounds_to_test = 4
tournois = Tournament({"rounds": rounds_to_test})
properties = [
{
"surname": "DUPUIS",
"forename": "Mélanie",
"birthday": 22,
"sex": False,
"rank": 1092,
},
{
"surname": "DUBOIS",
"forename": "Natasha",
"birthday": 20,
"sex": False,
"rank": 1083,
},
{
"surname": "MARK",
"forename": "Henry",
"birthday": 42,
"sex": True,
"rank": 2093,
},
{
"surname": "MALORY",
"forename": "Lucie",
"birthday": 45,
"sex": False,
"rank": 2099,
},
{
"surname": "DUCHATEAU",
"forename": "Edouard",
"birthday": 57,
"sex": True,
"rank": 1021,
},
{
"surname": "ARMAND",
"forename": "Jacques",
"birthday": 37,
"sex": True,
"rank": 2097,
},
{
"surname": "LOPEZ",
"forename": "Julia",
"birthday": 19,
"sex": False,
"rank": 2000,
},
{
"surname": "LYNCH",
"forename": "David",
"birthday": 99,
"sex": True,
"rank": 1999,
},
]
for _ in properties:
tournois.add_player(_)
# Testing object properties (player's name)
# for player in tournois.players:
# print(player.surname)
print("Jouer les tournois et simuler les résultats.")
for _ in range(tournois.rounds + 1):
print(f"Tour numéro {_ + 1}")
if not tournois.new_tour():
continue
tournois.stop_tour()
simulate_match(tournois)
print("\nAffichage des résultats des joueurs:"
"\n------------------------------------")
for player in tournois.players:
print(f"Affichage du score de {player.surname}"
f" {player.forename}: {tournois.score_player(player)}")
# Players by rank
print("\nAffichage des joueurs par rang:\n"
"-------------------------------\n")
ranked_players = tournois.list_players_by_rank()
rank = 0
for _ in ranked_players:
rank += 1
print(f"{rank} - {_.rank} {_.surname}" f" {_.forename}")
# Players by names
print("\nAffichage des joueurs par ordre alphabétique:\n"
"---------------------------------------------\n")
ranked_players = tournois.list_players_by_names()
rank = 0
for _ in ranked_players:
rank += 1
print(f"{rank} - {_.surname} {_.forename}")
#!/usr/bin/env python3
"""Test script to make sure the fixedmem player behave correctly"""
# All the "simpleplayers" can be implemented as depth 0 or 1 fixedmem players
from ast import literal_eval
from fixedmem import FixedMemPlayer, imp_simple_player
from tournament import Tournament
if __name__ == '__main__':
tourn = Tournament(rounds=8)
tourn.verbosity = 3
player = imp_simple_player('male', 'contrary')
tourn.add_player(player)
print('name {} hist_params {} action_params {}'.format(player.name, player.hist_params, player.action_params))
player = imp_simple_player('male', 'alt')
#tourn.add_player(player)
player = imp_simple_player('male', 'titfortat')
#tourn.add_player(player)
player = imp_simple_player('male', 'coop')
#tourn.add_player(player)
player = imp_simple_player('female', 'dom')
#tourn.add_player(player)
player = imp_simple_player('female', 'random')
#tourn.add_player(player)
player = imp_simple_player('female', 'random')
tourn.add_player(player)
player = imp_simple_player('female', 'coop')
#tourn.add_player(player)
print('name {} hist_params {} action_params {}'.format(player.name, player.hist_params, player.action_params))
tourn.resolve()
class TestMatchupPossibilities(unittest.TestCase):
def setUp(self):
self.tournament = Tournament(matchup_strategies.min_cost)
self.players = [Player(str(i)) for i in range(32)]
def test_6_players_have_1_possible_matchups(self):
for i in range(6):
self.tournament.add_player(self.players[i])
self.assertEqual(self.tournament.number_of_possible_pairings(), 1)
def test_7_players_have_1_possible_matchups(self):
for i in range(7):
self.tournament.add_player(self.players[i])
self.assertEqual(self.tournament.number_of_possible_pairings(), 1)
def test_players_face_closest_player_in_list(self):
for i in range(6):
self.tournament.add_player(self.players[i])
matchups = self.tournament.pairings()
self.assertTrue(matchups.players_are_matched(self.players[0], \
self.players[1]))
self.assertTrue(matchups.players_are_matched(self.players[2], \
self.players[3]))
self.assertTrue(matchups.players_are_matched(self.players[4], \
self.players[5]))
def test_players_face_closest_player_in_list_after_one_round(self):
for i in range(8):
self.tournament.add_player(self.players[i])
matchups = self.tournament.pairings()
for matchup in matchups.pairs:
self.tournament.add_result(matchup.player_a, matchup.player_b, 1, 0)
self.assertEqual(self.tournament.match_log().times_match_win(self.players[0]), 1)
self.assertEqual(self.tournament.match_log().times_match_win(self.players[1]), 0)
self.assertEqual(self.tournament.match_log().times_match_win(self.players[2]), 1)
self.assertEqual(self.tournament.match_log().times_match_win(self.players[3]), 0)
self.assertEqual(self.tournament.match_log().times_match_win(self.players[4]), 1)
self.assertEqual(self.tournament.match_log().times_match_win(self.players[5]), 0)
self.assertEqual(self.tournament.match_log().times_match_win(self.players[6]), 1)
self.assertEqual(self.tournament.match_log().times_match_win(self.players[7]), 0)
matchups = self.tournament.pairings()
self.assertTrue(matchups.players_are_matched(self.players[0], \
self.players[2]))
self.assertTrue(matchups.players_are_matched(self.players[4], \
self.players[6]))
self.assertTrue(matchups.players_are_matched(self.players[1], \
self.players[3]))
self.assertTrue(matchups.players_are_matched(self.players[5], \
self.players[7]))
def test_4_players_two_rounds(self):
for i in range(4):
self.tournament.add_player(self.players[i])
# First round
matchups = self.tournament.pairings()
for matchup in matchups.pairs:
self.tournament.add_result(matchup.player_a, matchup.player_b, 1, 0)
ranking = self.tournament.ranking()
self.assertEqual(ranking.entries()[0].score(), 1)
self.assertEqual(ranking.entries()[1].score(), 1)
self.assertEqual(ranking.entries()[2].score(), 0)
self.assertEqual(ranking.entries()[3].score(), 0)
# Second round
matchups = self.tournament.pairings()
for matchup in matchups.pairs:
self.tournament.add_result(matchup.player_a, matchup.player_b, 1, 0)
ranking = self.tournament.ranking()
self.assertEqual(ranking.entries()[0].score(), 2)
self.assertEqual(ranking.entries()[1].score(), 1)
self.assertEqual(ranking.entries()[2].score(), 1)
self.assertEqual(ranking.entries()[3].score(), 0)
def test_8_players_three_rounds(self):
for i in range(8):
self.tournament.add_player(self.players[i])
# First round
matchups = self.tournament.pairings()
for matchup in matchups.pairs:
self.tournament.add_result(matchup.player_a, matchup.player_b, 1, 0)
ranking = self.tournament.ranking()
self.assertEqual(ranking.entries()[0].score(), 1)
self.assertEqual(ranking.entries()[1].score(), 1)
self.assertEqual(ranking.entries()[2].score(), 1)
self.assertEqual(ranking.entries()[3].score(), 1)
self.assertEqual(ranking.entries()[4].score(), 0)
self.assertEqual(ranking.entries()[5].score(), 0)
self.assertEqual(ranking.entries()[6].score(), 0)
self.assertEqual(ranking.entries()[7].score(), 0)
# Second round
matchups = self.tournament.pairings()
for matchup in matchups.pairs:
self.tournament.add_result(matchup.player_a, matchup.player_b, 1, 0)
ranking = self.tournament.ranking()
self.assertEqual(ranking.entries()[0].score(), 2)
self.assertEqual(ranking.entries()[1].score(), 2)
self.assertEqual(ranking.entries()[2].score(), 1)
self.assertEqual(ranking.entries()[3].score(), 1)
self.assertEqual(ranking.entries()[4].score(), 1)
self.assertEqual(ranking.entries()[5].score(), 1)
self.assertEqual(ranking.entries()[6].score(), 0)
self.assertEqual(ranking.entries()[7].score(), 0)
# Third round
matchups = self.tournament.pairings()
for matchup in matchups.pairs:
self.tournament.add_result(matchup.player_a, matchup.player_b, 1, 0)
ranking = self.tournament.ranking()
self.assertEqual(ranking.entries()[0].score(), 3)
self.assertEqual(ranking.entries()[1].score(), 2)
self.assertEqual(ranking.entries()[2].score(), 2)
self.assertEqual(ranking.entries()[3].score(), 2)
self.assertEqual(ranking.entries()[4].score(), 1)
self.assertEqual(ranking.entries()[5].score(), 1)
self.assertEqual(ranking.entries()[6].score(), 1)
self.assertEqual(ranking.entries()[7].score(), 0)
def test_no_players(self):
m = self.tournament.pairings()
self.assertEqual(m.pairs, [])
self.assertIsNone(m.bye_player, None)
self.assertEqual(self.tournament.number_of_possible_pairings(), 1)
def test_one_player(self):
self.tournament.add_player(self.players[0])
m = self.tournament.pairings()
self.assertEqual(m.pairs, [])
self.assertEqual(m.bye_player, self.players[0])
self.assertEqual(self.tournament.number_of_possible_pairings(), 1)
def test_two_players(self):
self.tournament.add_player(self.players[0])
self.tournament.add_player(self.players[1])
m = self.tournament.pairings()
self.assertTrue(m.players_are_matched(self.players[0], self.players[1]))
self.assertEqual(len(m.pairs), 1)
self.assertIsNone(m.bye_player, None)
self.assertEqual(self.tournament.number_of_possible_pairings(), 1)
def test_player_added_twice_should_be_the_same_as_added_once(self):
self.tournament.add_player(self.players[0])
self.tournament.add_player(self.players[0])
m = self.tournament.pairings()
self.assertEqual(m.pairs, [])
self.assertEqual(m.bye_player, self.players[0])
self.assertEqual(self.tournament.number_of_possible_pairings(), 1)
def test_three_players_worst_performer_gets_bye(self):
self.tournament.add_player(self.players[0])
self.tournament.add_player(self.players[1])
self.tournament.add_player(self.players[2])
self.tournament.add_result(self.players[0], self.players[1], 1, 0)
self.tournament.add_result(self.players[1], self.players[2], 1, 0)
m = self.tournament.pairings()
self.assertTrue(m.players_are_matched(self.players[0], self.players[1]))
self.assertEqual(len(m.pairs), 1)
self.assertEqual(m.bye_player, self.players[2])
self.assertEqual(self.tournament.number_of_possible_pairings(), 1)
def test_byed_player_dont_get_byed_again(self):
self.tournament.add_player(self.players[0])
self.tournament.add_player(self.players[1])
self.tournament.add_player(self.players[2])
self.tournament.add_result(self.players[0], self.players[1], 1, 0)
self.tournament.add_result(self.players[0], self.players[2], 1, 0)
self.tournament.add_bye(self.players[1])
self.tournament.add_bye(self.players[2])
m = self.tournament.pairings()
self.assertTrue(m.players_are_matched(self.players[1], self.players[2]))
self.assertEqual(len(m.pairs), 1)
self.assertEqual(m.bye_player, self.players[0])
self.assertEqual(self.tournament.number_of_possible_pairings(), 1)
def test_smoke_ranking_string(self):
self.tournament.add_player(self.players[0])
s = self.tournament.ranking().string()
self.assertTrue("#1" in s)
self.assertTrue("(0 wins)" in s)
self.tournament.add_player(self.players[1])
s = self.tournament.ranking().string()
self.assertTrue("#2" in s)
def test_smoke_pairings_string(self):
self.tournament.add_player(self.players[0])
self.tournament.add_player(self.players[1])
s = self.tournament.pairings().string()
vs_s = self.players[0].name() + ' VS. ' + self.players[1].name()
self.assertEqual(s, vs_s)
if __name__ == '__main__':
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('--rounds', type=int, default=10)
parser.add_argument('--verbosity', type=int, default=1)
parser.add_argument('--generations', type=int, default=1)
parser.add_argument('--mult', type=int, default=1, help='multiplier of distribution')
parser.add_argument('--dist', help='distribution', default=None)
args = parser.parse_args()
if args.dist:
dist = literal_eval(args.dist)
if 'both' in dist:
for sex in ['male', 'female']:
if sex in dist:
dist[sex].update(dist['both'])
else:
dist[sex] = dist['both']
print(repr(dist))
tourn = Tournament(rounds=args.rounds)
tourn.verbosity = args.verbosity
for sex in ['male', 'female']:
for name in dist[sex]:
for ii in range(dist[sex][name] * args.mult):
tourn.add_player(create_simple_player(sex=sex, name=name))
for gen in range(args.generations):
tourn.resolve()
tourn.reproduce()
print()
tourn.show_distribution()
print()
