def test_first_server_served_first(self):
match = tennis.Match(sets=[
tennis.Set(games=[tennis.Game()]),
tennis.Set(games=[tennis.Game()] * 2),
tennis.Set(games=[tennis.Game()] * 3),
tennis.Set(games=[tennis.Game()] * 4)
])
self.assertEqual(list(match.first_server_served_first),
[True, False, False, True])
def test_first_server_to_serve(self):
with self.assertRaisesRegex(
RuntimeError, '^{}$'.format(
re.escape(
'No server is to serve the next point because the set is over.'
))):
tennis.Set(games=[
tennis.Game(server_points=4),
tennis.Game(returner_points=4)
],
target_games=2).first_server_to_serve()
self.assertTrue(
tennis.Set(games=[tennis.Tiebreak(
first_server_points=0)]).first_server_to_serve())
self.assertFalse(
tennis.Set(games=[tennis.Tiebreak(
first_server_points=1)]).first_server_to_serve())
self.assertFalse(
tennis.Set(games=[tennis.Tiebreak(
first_server_points=2)]).first_server_to_serve())
self.assertTrue(
tennis.Set(games=[tennis.Tiebreak(
first_server_points=3)]).first_server_to_serve())
self.assertTrue(
tennis.Set(games=[tennis.Game()]).first_server_to_serve())
self.assertFalse(
tennis.Set(games=[tennis.Game()] * 2).first_server_to_serve())
self.assertTrue(
tennis.Set(games=[tennis.Game()] * 3).first_server_to_serve())
def test_init_inconsistent_tiebreak_args(self):
with self.assertRaisesRegex(
RuntimeError, '^{}$'.format(
re.escape(
'tiebreak_games and tiebreak_points must both be None or non-None.'
))):
tennis.Set(tiebreak_games=1, tiebreak_points=None)
with self.assertRaisesRegex(
RuntimeError, '^{}$'.format(
re.escape(
'tiebreak_games and tiebreak_points must both be None or non-None.'
))):
tennis.Set(tiebreak_games=None, tiebreak_points=1)
def test_init_negative_points(self):
with self.assertRaisesRegex(
RuntimeError, '^{}$'.format(
re.escape('Point scores must be non-negative.'))):
tennis.Set(target_games=-1)
with self.assertRaisesRegex(
RuntimeError, '^{}$'.format(
re.escape('Point scores must be non-negative.'))):
tennis.Set(tiebreak_games=-1, tiebreak_points=1)
with self.assertRaisesRegex(
RuntimeError, '^{}$'.format(
re.escape('Point scores must be non-negative.'))):
tennis.Set(tiebreak_games=1, tiebreak_points=-1)
def test_init_final_set(self):
match = tennis.Match(sets=None,
target_sets=1,
target_games=2,
deciding_point=False,
tiebreak_games=3,
tiebreak_points=4,
final_set_target_games=5,
final_set_deciding_point=True,
final_set_tiebreak_games=6,
final_set_tiebreak_points=7)
self.assertEqual(match.sets, [
tennis.Set(games=[
tennis.Game(
server_points=0, returner_points=0, deciding_point=True)
],
target_games=5,
deciding_point=True,
tiebreak_games=6,
tiebreak_points=7)
])
self.assertEqual(match.target_sets, 1)
self.assertEqual(match.target_games, 2)
self.assertFalse(match.deciding_point)
self.assertEqual(match.tiebreak_games, 3)
self.assertEqual(match.tiebreak_points, 4)
self.assertEqual(match.final_set_target_games, 5)
self.assertTrue(match.final_set_deciding_point)
self.assertEqual(match.final_set_tiebreak_games, 6)
self.assertEqual(match.final_set_tiebreak_points, 7)
def test_init_args(self):
with self.assertRaisesRegex(
TypeError, '^{}$'.format(
re.escape(
'__init__() takes 1 positional argument but 2 were given'
))):
tennis.Set([tennis.Game(server_points=1, returner_points=2)])
def test_init_no_args(self):
zet = tennis.Set()
self.assertEqual(zet.games,
[tennis.Game(server_points=0, returner_points=0)])
self.assertEqual(zet.target_games, 6)
self.assertFalse(zet.deciding_point)
self.assertEqual(zet.tiebreak_games, 6)
self.assertEqual(zet.tiebreak_points, 7)
def test_init_first_game(self):
zet = tennis.Set(games=None,
deciding_point=False,
tiebreak_games=1,
tiebreak_points=2)
self.assertEqual(zet.games, [tennis.Game(deciding_point=False)])
self.assertEqual(zet.tiebreak_games, 1)
self.assertEqual(zet.tiebreak_points, 2)
zet = tennis.Set(games=None,
deciding_point=True,
tiebreak_games=None,
tiebreak_points=None)
self.assertEqual(zet.games, [tennis.Game(deciding_point=True)])
self.assertIsNone(zet.tiebreak_games)
self.assertIsNone(zet.tiebreak_points)
def test_test_init_first_tiebreak(self):
zet = tennis.Set(games=None, tiebreak_games=0, tiebreak_points=3)
self.assertEqual(zet.games, [
tennis.Tiebreak(first_server_points=0,
first_returner_points=0,
target_points=3)
])
self.assertEqual(zet.tiebreak_games, 0)
self.assertEqual(zet.tiebreak_points, 3)
def test_init_kwargs(self):
match = tennis.Match(final_set_tiebreak_points=1,
final_set_tiebreak_games=2,
final_set_deciding_point=True,
final_set_target_games=3,
tiebreak_points=4,
tiebreak_games=5,
deciding_point=True,
target_games=6,
target_sets=7,
sets=[tennis.Set()])
self.assertEqual(match.sets, [tennis.Set()])
self.assertEqual(match.target_sets, 7)
self.assertEqual(match.target_games, 6)
self.assertTrue(match.deciding_point)
self.assertEqual(match.tiebreak_games, 5)
self.assertEqual(match.tiebreak_points, 4)
self.assertEqual(match.final_set_target_games, 3)
self.assertTrue(match.final_set_deciding_point)
self.assertEqual(match.final_set_tiebreak_games, 2)
self.assertEqual(match.final_set_tiebreak_points, 1)
def test_init_kwargs(self):
zet = tennis.Set(
tiebreak_points=1,
tiebreak_games=2,
deciding_point=True,
target_games=3,
games=[tennis.Game(server_points=3, returner_points=4)])
self.assertEqual(zet.games,
[tennis.Game(server_points=3, returner_points=4)])
self.assertEqual(zet.target_games, 3)
self.assertTrue(zet.deciding_point)
self.assertEqual(zet.tiebreak_games, 2)
self.assertEqual(zet.tiebreak_points, 1)
def test_sets(self):
sets = []
match = tennis.Match(sets=sets)
self.assertEqual(match.first_server_sets(), 0)
self.assertEqual(match.first_returner_sets(), 0)
sets.append(
tennis.Set(games=[
tennis.Game(server_points=4),
tennis.Game(returner_points=4)
],
target_games=2))
match = tennis.Match(sets=sets)
self.assertEqual(match.first_server_sets(), 1)
self.assertEqual(match.first_returner_sets(), 0)
sets.append(
tennis.Set(games=[tennis.Tiebreak(first_returner_points=7)],
tiebreak_games=0))
match = tennis.Match(sets=sets)
self.assertEqual(match.first_server_sets(), 1)
self.assertEqual(match.first_returner_sets(), 1)
sets.append(
tennis.Set(games=[
tennis.Game(server_points=4),
tennis.Game(returner_points=4)
],
target_games=2))
match = tennis.Match(sets=sets)
self.assertEqual(match.first_server_sets(), 1)
self.assertEqual(match.first_returner_sets(), 2)
sets.append(
tennis.Set(games=[tennis.Tiebreak(first_returner_points=7)],
tiebreak_games=0))
match = tennis.Match(sets=sets)
self.assertEqual(match.first_server_sets(), 2)
self.assertEqual(match.first_returner_sets(), 2)
sets.append(tennis.Set())
match = tennis.Match(sets=sets)
self.assertEqual(match.first_server_sets(), 2)
self.assertEqual(match.first_returner_sets(), 2)
sets.append(tennis.Set())
match = tennis.Match(sets=sets)
self.assertEqual(match.first_server_sets(), 2)
self.assertEqual(match.first_returner_sets(), 2)
def point(self, *, first_server):
if self.winner is not None:
raise RuntimeError(
'Cannot advance this match\'s score because the match is over.'
)
set_winner = self.sets[-1].point(first_server=list(
self.first_server_served_first)[-1] == first_server)
if set_winner is None:
return None
self.winner = self._compute_winner()
if self.winner is not None:
return self.winner
if len(self.sets) == 2 * (self.target_sets - 1):
self.sets.append(
tennis.Set(games=None,
target_games=self.final_set_target_games,
deciding_point=self.final_set_deciding_point,
tiebreak_games=self.final_set_tiebreak_games,
tiebreak_points=self.final_set_tiebreak_points))
else:
self.sets.append(
tennis.Set(games=None,
target_games=self.target_games,
deciding_point=self.deciding_point,
tiebreak_games=self.tiebreak_games,
tiebreak_points=self.tiebreak_points))
self.first_server_served_first = tuple(
list(self.first_server_served_first) + [
self.first_server_served_first[-1] != bool(
len(self.sets[-2].games) % 2)
])
def test_repr(self):
self.assertEqual(
repr(
tennis.Match(sets=[
tennis.Set(games=[
tennis.Game(server_points=1,
returner_points=2,
deciding_point=True)
],
target_games=3,
deciding_point=True,
tiebreak_games=4,
tiebreak_points=5)
],
target_sets=6,
target_games=3,
deciding_point=True,
tiebreak_games=4,
tiebreak_points=5,
final_set_target_games=7,
final_set_deciding_point=False,
final_set_tiebreak_games=8,
final_set_tiebreak_points=9)), 'Match('
'sets=[Set('
'games=[Game(server_points=1, returner_points=2, deciding_point=True)], '
'target_games=3, '
'deciding_point=True, '
'tiebreak_games=4, '
'tiebreak_points=5'
')], '
'target_sets=6, '
'target_games=3, '
'deciding_point=True, '
'tiebreak_games=4, '
'tiebreak_points=5, '
'final_set_target_games=7, '
'final_set_deciding_point=False, '
'final_set_tiebreak_games=8, '
'final_set_tiebreak_points=9'
')')
def test_init_no_args(self):
match = tennis.Match()
self.assertEqual(match.sets, [
tennis.Set(games=[
tennis.Game(
server_points=0, returner_points=0, deciding_point=False)
],
target_games=6,
deciding_point=False,
tiebreak_games=6,
tiebreak_points=7)
])
self.assertEqual(match.target_sets, 2)
self.assertEqual(match.target_games, 6)
self.assertFalse(match.deciding_point)
self.assertEqual(match.tiebreak_games, 6)
self.assertEqual(match.tiebreak_points, 7)
self.assertEqual(match.final_set_target_games, 6)
self.assertFalse(match.final_set_deciding_point)
self.assertEqual(match.final_set_tiebreak_games, 6)
self.assertEqual(match.final_set_tiebreak_points, 7)
def test_first_server_to_serve(self):
with self.assertRaisesRegex(
RuntimeError, '^{}$'.format(
re.escape(
'No server is to serve the next point because the match is over.'
))):
tennis.Match(sets=[
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0)
],
target_sets=1,
tiebreak_games=0).first_server_to_serve()
self.assertTrue(
tennis.Match(sets=[
tennis.Set(games=[tennis.Tiebreak(first_server_points=0)],
tiebreak_games=0)
],
tiebreak_games=0).first_server_to_serve())
self.assertFalse(
tennis.Match(sets=[
tennis.Set(games=[tennis.Tiebreak(first_server_points=1)],
tiebreak_games=0)
],
tiebreak_games=0).first_server_to_serve())
self.assertFalse(
tennis.Match(sets=[
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0),
tennis.Set(games=[tennis.Tiebreak(first_server_points=0)],
tiebreak_games=0)
],
tiebreak_games=0).first_server_to_serve())
self.assertTrue(
tennis.Match(sets=[
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0),
tennis.Set(games=[tennis.Tiebreak(first_server_points=1)],
tiebreak_games=0)
],
tiebreak_games=0).first_server_to_serve())
def test_repr(self):
self.assertEqual(
repr(
tennis.Set(games=[
tennis.Game(server_points=1,
returner_points=2,
deciding_point=True),
tennis.Tiebreak(first_server_points=3,
first_returner_points=4,
target_points=7)
],
target_games=8,
deciding_point=True,
tiebreak_games=5,
tiebreak_points=7)), 'Set('
'games=['
'Game(server_points=1, returner_points=2, deciding_point=True), '
'Tiebreak(first_server_points=3, first_returner_points=4, target_points=7)'
'], '
'target_games=8, '
'deciding_point=True, '
'tiebreak_games=5, '
'tiebreak_points=7'
')')
def test_winner(self):
self.assertIsNone(tennis.Match(sets=[]).winner)
self.assertIsNone(
tennis.Match(sets=[
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0)
]).winner)
self.assertIsNone(
tennis.Match(sets=[
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0),
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0)
]).winner)
self.assertTrue(
tennis.Match(sets=[
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0),
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0),
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0)
]).winner)
self.assertFalse(
tennis.Match(sets=[
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0),
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0),
tennis.Set(games=[tennis.Tiebreak(first_returner_points=7)],
tiebreak_games=0)
]).winner)
self.assertTrue(
tennis.Match(sets=[
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0)
],
target_sets=1).winner)
self.assertFalse(
tennis.Match(sets=[
tennis.Set(games=[tennis.Tiebreak(first_returner_points=7)],
tiebreak_games=0)
],
target_sets=1).winner)
def test_point(self):
with self.assertRaisesRegex(
RuntimeError, '^{}$'.format(
re.escape(
'Cannot advance this match\'s score because the match is over.'
))):
tennis.Match(sets=[
tennis.Set(games=[tennis.Tiebreak(first_server_points=7)],
tiebreak_games=0)
],
target_sets=1,
tiebreak_games=0).point(first_server=True)
match = tennis.Match(tiebreak_games=0, tiebreak_points=2)
self.assertIsNone(match.point(first_server=True))
self.assertEqual(
match,
tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_server_points=1, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2)
],
tiebreak_games=0,
tiebreak_points=2))
self.assertIsNone(match.point(first_server=True))
self.assertEqual(
match,
tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_server_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2),
tennis.Set(games=[tennis.Tiebreak(target_points=2)],
tiebreak_games=0,
tiebreak_points=2)
],
tiebreak_games=0,
tiebreak_points=2))
self.assertIsNone(match.point(first_server=True))
self.assertEqual(
match,
tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_server_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2),
tennis.Set(games=[
tennis.Tiebreak(first_returner_points=1, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2)
],
tiebreak_games=0,
tiebreak_points=2))
self.assertTrue(match.point(first_server=True))
self.assertEqual(
match,
tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_server_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2),
tennis.Set(games=[
tennis.Tiebreak(first_returner_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2)
],
tiebreak_games=0,
tiebreak_points=2))
match = tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_server_points=1, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2)
],
target_sets=1,
tiebreak_games=0,
tiebreak_points=2)
self.assertTrue(match.point(first_server=True))
self.assertEqual(
match,
tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_server_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2)
],
target_sets=1,
tiebreak_games=0,
tiebreak_points=2))
match = tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_returner_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2),
tennis.Set(games=[
tennis.Tiebreak(first_returner_points=1, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2)
],
tiebreak_games=0,
tiebreak_points=2,
final_set_target_games=3,
final_set_deciding_point=True,
final_set_tiebreak_games=4,
final_set_tiebreak_points=5)
self.assertIsNone(match.point(first_server=True))
self.assertEqual(
match,
tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_returner_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2),
tennis.Set(games=[
tennis.Tiebreak(first_returner_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2),
tennis.Set(games=[tennis.Game(deciding_point=True)],
target_games=3,
deciding_point=True,
tiebreak_games=4,
tiebreak_points=5)
],
tiebreak_games=0,
tiebreak_points=2,
final_set_target_games=3,
final_set_deciding_point=True,
final_set_tiebreak_games=4,
final_set_tiebreak_points=5))
match = tennis.Match(tiebreak_games=0, tiebreak_points=2)
self.assertIsNone(match.point(first_server=False))
self.assertEqual(
match,
tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_returner_points=1, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2)
],
tiebreak_games=0,
tiebreak_points=2))
self.assertIsNone(match.point(first_server=False))
self.assertEqual(
match,
tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_returner_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2),
tennis.Set(games=[tennis.Tiebreak(target_points=2)],
tiebreak_games=0,
tiebreak_points=2)
],
tiebreak_games=0,
tiebreak_points=2))
self.assertIsNone(match.point(first_server=False))
self.assertEqual(
match,
tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_returner_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2),
tennis.Set(games=[
tennis.Tiebreak(first_server_points=1, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2)
],
tiebreak_games=0,
tiebreak_points=2))
self.assertFalse(match.point(first_server=False))
self.assertEqual(
match,
tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_returner_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2),
tennis.Set(games=[
tennis.Tiebreak(first_server_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2)
],
tiebreak_games=0,
tiebreak_points=2))
match = tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_returner_points=1, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2)
],
target_sets=1,
tiebreak_games=0,
tiebreak_points=2)
self.assertFalse(match.point(first_server=False))
self.assertEqual(
match,
tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_returner_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2)
],
target_sets=1,
tiebreak_games=0,
tiebreak_points=2))
match = tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_server_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2),
tennis.Set(games=[
tennis.Tiebreak(first_server_points=1, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2)
],
tiebreak_games=0,
tiebreak_points=2,
final_set_target_games=3,
final_set_deciding_point=True,
final_set_tiebreak_games=4,
final_set_tiebreak_points=5)
self.assertIsNone(match.point(first_server=False))
self.assertEqual(
match,
tennis.Match(sets=[
tennis.Set(games=[
tennis.Tiebreak(first_server_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2),
tennis.Set(games=[
tennis.Tiebreak(first_server_points=2, target_points=2)
],
tiebreak_games=0,
tiebreak_points=2),
tennis.Set(games=[tennis.Game(deciding_point=True)],
target_games=3,
deciding_point=True,
tiebreak_games=4,
tiebreak_points=5)
],
tiebreak_games=0,
tiebreak_points=2,
final_set_target_games=3,
final_set_deciding_point=True,
final_set_tiebreak_games=4,
final_set_tiebreak_points=5))
def test_point(self):
with self.assertRaisesRegex(
RuntimeError, '^{}$'.format(
re.escape(
'Cannot advance this set\'s score because the set is over.'
))):
tennis.Set(games=[
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4)
] * 3).point(first_server=True)
zet = tennis.Set(deciding_point=True)
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=1,
returner_points=0,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=2,
returner_points=0,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=3,
returner_points=0,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=1,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=2,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=3,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=1,
returner_points=0,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=2,
returner_points=0,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=3,
returner_points=0,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=1,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=2,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=3,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=1,
returner_points=0,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=2,
returner_points=0,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=3,
returner_points=0,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=1,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=2,
deciding_point=True)
],
deciding_point=True))
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=3,
deciding_point=True)
],
deciding_point=True))
self.assertTrue(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True),
tennis.Game(server_points=4,
returner_points=0,
deciding_point=True),
tennis.Game(server_points=0,
returner_points=4,
deciding_point=True)
],
deciding_point=True))
zet = tennis.Set()
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(
games=[tennis.Game(server_points=0, returner_points=1)]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(
games=[tennis.Game(server_points=0, returner_points=2)]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(
games=[tennis.Game(server_points=0, returner_points=3)]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game()
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=1, returner_points=0)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=2, returner_points=0)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=3, returner_points=0)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game()
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=1)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=2)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=3)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game()
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=1, returner_points=0)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=2, returner_points=0)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=3, returner_points=0)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game()
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=1)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=2)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=3)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game()
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=1, returner_points=0)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=2, returner_points=0)
]))
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=3, returner_points=0)
]))
self.assertFalse(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0)
]))
zet = tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 3 + \
[tennis.Game(server_points=3, returner_points=0)],
tiebreak_games=2,
tiebreak_points=3
)
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 4 + \
[tennis.Tiebreak(first_server_points=0, first_returner_points=0, target_points=3)],
tiebreak_games=2,
tiebreak_points=3
)
)
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 4 + \
[tennis.Tiebreak(first_server_points=1, first_returner_points=0, target_points=3)],
tiebreak_games=2,
tiebreak_points=3
)
)
self.assertIsNone(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 4 + \
[tennis.Tiebreak(first_server_points=2, first_returner_points=0, target_points=3)],
tiebreak_games=2,
tiebreak_points=3
)
)
self.assertTrue(zet.point(first_server=True))
self.assertEqual(
zet,
tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 4 + \
[tennis.Tiebreak(first_server_points=3, first_returner_points=0, target_points=3)],
tiebreak_games=2,
tiebreak_points=3
)
)
zet = tennis.Set(games=[
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=3, returner_points=0)
],
tiebreak_games=1,
tiebreak_points=2)
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 2 + \
[tennis.Tiebreak(first_server_points=0, first_returner_points=0, target_points=2)],
tiebreak_games=1,
tiebreak_points=2
)
)
self.assertIsNone(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 2 + \
[tennis.Tiebreak(first_server_points=0, first_returner_points=1, target_points=2)],
tiebreak_games=1,
tiebreak_points=2
)
)
self.assertFalse(zet.point(first_server=False))
self.assertEqual(
zet,
tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 2 + \
[tennis.Tiebreak(first_server_points=0, first_returner_points=2, target_points=2)],
tiebreak_games=1,
tiebreak_points=2
)
)
def test_winner(self):
self.assertIsNone(tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 2 + \
[tennis.Tiebreak(first_server_points=0, first_returner_points=0, target_points=2)],
tiebreak_games=1,
tiebreak_points=2
).winner)
self.assertTrue(
tennis.Set(games=[
tennis.Tiebreak(first_server_points=2,
first_returner_points=0,
target_points=0)
],
tiebreak_games=0,
tiebreak_points=0).winner)
self.assertFalse(tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 4 + \
[tennis.Tiebreak(first_server_points=0, first_returner_points=4, target_points=4)],
tiebreak_games=2,
tiebreak_points=4
).winner)
self.assertIsNone(
tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 10 +
[tennis.Game()],
tiebreak_games=None,
tiebreak_points=None).winner)
self.assertIsNone(
tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 11 +
[tennis.Game()],
tiebreak_games=None,
tiebreak_points=None).winner)
self.assertIsNone(
tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 12 +
[tennis.Game()],
tiebreak_games=None,
tiebreak_points=None).winner)
self.assertIsNone(
tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 13 +
[tennis.Game()],
tiebreak_games=None,
tiebreak_points=None).winner)
self.assertTrue(tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 13 + \
[tennis.Game(server_points=0, returner_points=4)],
tiebreak_games=None,
tiebreak_points=None
).winner)
self.assertIsNone(tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 12 + \
[tennis.Game(server_points=0, returner_points=4), tennis.Game()],
tiebreak_games=None,
tiebreak_points=None
).winner)
self.assertFalse(
tennis.Set(
games=[tennis.Game(server_points=4, returner_points=0)] * 12 +
[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0)
],
tiebreak_games=None,
tiebreak_points=None).winner)
self.assertTrue(
tennis.Set(games=[
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4)
],
target_games=2).winner)
self.assertFalse(
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0)
],
target_games=2).winner)
def test_eq(self):
self.assertEqual(
tennis.Match(sets=[
tennis.Set(games=[
tennis.Game(server_points=1,
returner_points=2,
deciding_point=True)
],
target_games=3,
deciding_point=True,
tiebreak_games=4,
tiebreak_points=5)
],
target_sets=6,
target_games=3,
deciding_point=True,
tiebreak_games=4,
tiebreak_points=5,
final_set_target_games=6,
final_set_deciding_point=False,
final_set_tiebreak_games=7,
final_set_tiebreak_points=8),
tennis.Match(sets=[
tennis.Set(games=[
tennis.Game(server_points=1,
returner_points=2,
deciding_point=True)
],
target_games=3,
deciding_point=True,
tiebreak_games=4,
tiebreak_points=5)
],
target_sets=6,
target_games=3,
deciding_point=True,
tiebreak_games=4,
tiebreak_points=5,
final_set_target_games=6,
final_set_deciding_point=False,
final_set_tiebreak_games=7,
final_set_tiebreak_points=8))
self.assertNotEqual(tennis.Match(sets=None), tennis.Match(sets=[]))
self.assertNotEqual(tennis.Match(target_sets=1),
tennis.Match(target_sets=2))
self.assertNotEqual(tennis.Match(target_games=3),
tennis.Match(target_games=4))
self.assertNotEqual(tennis.Match(deciding_point=True),
tennis.Match(deciding_point=False))
self.assertNotEqual(tennis.Match(tiebreak_games=5),
tennis.Match(tiebreak_games=6))
self.assertNotEqual(tennis.Match(tiebreak_points=7),
tennis.Match(tiebreak_points=8))
self.assertNotEqual(tennis.Match(final_set_target_games=9),
tennis.Match(final_set_target_games=10))
self.assertNotEqual(tennis.Match(final_set_deciding_point=True),
tennis.Match(final_set_deciding_point=False))
self.assertNotEqual(tennis.Match(final_set_tiebreak_games=11),
tennis.Match(final_set_tiebreak_games=12))
self.assertNotEqual(tennis.Match(final_set_tiebreak_points=13),
tennis.Match(final_set_tiebreak_points=14))
def test_first_returner_games(self):
self.assertEqual(tennis.Set().first_returner_games(), 0)
self.assertEqual(
tennis.Set(games=[tennis.Game(server_points=0, returner_points=4)
]).first_returner_games(), 1)
self.assertEqual(
tennis.Set(games=[tennis.Game(server_points=4, returner_points=0)
]).first_returner_games(), 0)
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game()
]).first_returner_games(), 1)
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=0, returner_points=4)
]).first_returner_games(), 1)
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0)
]).first_returner_games(), 2)
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Tiebreak(first_server_points=0,
first_returner_points=0,
target_points=7)
]).first_returner_games(), 2)
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Tiebreak(first_server_points=0,
first_returner_points=7,
target_points=7)
]).first_returner_games(), 3)
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=0, returner_points=4),
tennis.Game(server_points=4, returner_points=0),
tennis.Tiebreak(first_server_points=7,
first_returner_points=0,
target_points=7)
]).first_returner_games(), 2)
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=4, returner_points=0),
tennis.Game()
]).first_returner_games(), 0)
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=0, returner_points=4)
]).first_returner_games(), 0)
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=4, returner_points=0)
]).first_returner_games(), 1)
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=4, returner_points=0),
tennis.Tiebreak(first_server_points=0,
first_returner_points=0,
target_points=7)
]).first_returner_games(), 1)
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=4, returner_points=0),
tennis.Tiebreak(first_server_points=0,
first_returner_points=7,
target_points=7)
]).first_returner_games(), 2)
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=4, returner_points=0),
tennis.Game(server_points=4, returner_points=0),
tennis.Tiebreak(first_server_points=7,
first_returner_points=0,
target_points=7)
]).first_returner_games(), 1)
def __init__(self,
*,
sets=None,
target_sets=2,
target_games=6,
deciding_point=False,
tiebreak_games=6,
tiebreak_points=7,
final_set_target_games=6,
final_set_deciding_point=False,
final_set_tiebreak_games=6,
final_set_tiebreak_points=7):
# TODO(abw333): validate sets
if target_sets < 1:
raise RuntimeError('target_sets must be at least 1.')
if min(target_games, final_set_target_games) < 0:
raise RuntimeError('Point scores must be non-negative.')
if (tiebreak_games is None) != (tiebreak_points is None):
raise RuntimeError(
'tiebreak_games and tiebreak_points must both be None or non-None.'
)
if (final_set_tiebreak_games is None) != (final_set_tiebreak_points is
None):
raise RuntimeError(
'final_set_tiebreak_games and final_set_tiebreak_points must both be None or non-None.'
)
if tiebreak_games is not None and min(tiebreak_games,
tiebreak_points) < 0:
raise RuntimeError('Point scores must be non-negative.')
if final_set_tiebreak_games is not None:
if min(final_set_tiebreak_games, final_set_tiebreak_points) < 0:
raise RuntimeError('Point scores must be non-negative.')
if sets is not None:
self.sets = sets
elif target_sets == 1:
self.sets = [
tennis.Set(games=None,
target_games=final_set_target_games,
deciding_point=final_set_deciding_point,
tiebreak_games=final_set_tiebreak_games,
tiebreak_points=final_set_tiebreak_points)
]
else:
self.sets = [
tennis.Set(games=None,
target_games=target_games,
deciding_point=deciding_point,
tiebreak_games=tiebreak_games,
tiebreak_points=tiebreak_points)
]
self.target_sets = target_sets
self.target_games = target_games
self.deciding_point = deciding_point
self.tiebreak_games = tiebreak_games
self.tiebreak_points = tiebreak_points
self.final_set_target_games = final_set_target_games
self.final_set_deciding_point = final_set_deciding_point
self.final_set_tiebreak_games = final_set_tiebreak_games
self.final_set_tiebreak_points = final_set_tiebreak_points
self.first_server_served_first = tuple(
self._compute_first_server_served_first())
self.winner = self._compute_winner()
def test_eq(self):
self.assertEqual(
tennis.Set(games=[
tennis.Game(server_points=1,
returner_points=2,
deciding_point=True)
],
target_games=4,
deciding_point=True,
tiebreak_games=2,
tiebreak_points=3),
tennis.Set(games=[
tennis.Game(server_points=1,
returner_points=2,
deciding_point=True)
],
target_games=4,
deciding_point=True,
tiebreak_games=2,
tiebreak_points=3))
self.assertNotEqual(tennis.Set(games=None),
tennis.Set(games=[tennis.Tiebreak()]))
self.assertNotEqual(tennis.Set(target_games=5),
tennis.Set(target_games=6))
self.assertNotEqual(tennis.Set(deciding_point=True),
tennis.Set(deciding_point=False))
self.assertNotEqual(tennis.Set(tiebreak_games=1),
tennis.Set(tiebreak_games=2))
self.assertNotEqual(tennis.Set(tiebreak_points=3),
tennis.Set(tiebreak_points=4))
