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))
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_eq(self):
self.assertEqual(
tennis.Game(server_points=1, returner_points=2),
tennis.Game(server_points=1, returner_points=2)
)
self.assertNotEqual(
tennis.Game(server_points=1, returner_points=2),
tennis.Game(server_points=2, returner_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 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_init_negative_points(self):
with self.assertRaisesRegex(
RuntimeError,
'^{}$'.format(re.escape('Point scores must be non-negative.'))
):
tennis.Game(server_points=0, returner_points=-1)
with self.assertRaisesRegex(
RuntimeError,
'^{}$'.format(re.escape('Point scores must be non-negative.'))
):
tennis.Game(server_points=-1, returner_points=0)
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_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_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 point(self, *, first_server):
if self.winner is not None:
raise RuntimeError('Cannot advance this set\'s score because the set is over.')
game_winner = self.games[-1].point(first_server=(len(self.games) % 2 == 1) == first_server)
if game_winner is None:
return None
self.winner = self._compute_winner()
if self.winner is not None:
return self.winner
if self.tiebreak_games is not None and \
self.first_server_games() == self.tiebreak_games and \
self.first_returner_games() == self.tiebreak_games:
self.games.append(tennis.Tiebreak(
first_server_points=0,
first_returner_points=0,
target_points=self.tiebreak_points
))
self._first_server_to_serve = None
else:
self.games.append(tennis.Game(
server_points=0,
returner_points=0,
deciding_point=self.deciding_point
))
self._first_server_to_serve = not self._first_server_to_serve
def test_point(self):
with self.assertRaisesRegex(
RuntimeError,
'^{}$'.format(re.escape('Cannot advance this game\'s score because the game is over.'))
):
tennis.Game(server_points=4, returner_points=0).point(first_server=True)
game = tennis.Game(server_points=0, returner_points=0)
self.assertIsNone(game.point(first_server=True))
self.assertEqual(game.server_points, 1)
self.assertEqual(game.returner_points, 0)
self.assertIsNone(game.point(first_server=False))
self.assertEqual(game.server_points, 1)
self.assertEqual(game.returner_points, 1)
self.assertTrue(tennis.Game(server_points=3, returner_points=0).point(first_server=True))
self.assertFalse(tennis.Game(server_points=0, returner_points=3).point(first_server=False))
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_init_unreachable_points(self):
with self.assertRaisesRegex(
RuntimeError,
'^{}$'.format(re.escape('Point scores must be reachable.'))
):
tennis.Game(server_points=5, returner_points=2)
with self.assertRaisesRegex(
RuntimeError,
'^{}$'.format(re.escape('Point scores must be reachable.'))
):
tennis.Game(server_points=2, returner_points=5)
with self.assertRaisesRegex(
RuntimeError,
'^{}$'.format(re.escape('Point scores must be reachable.'))
):
tennis.Game(server_points=4, returner_points=4, deciding_point=True)
with self.assertRaisesRegex(
RuntimeError,
'^{}$'.format(re.escape('Point scores must be reachable.'))
):
tennis.Game(server_points=5, returner_points=3, deciding_point=True)
with self.assertRaisesRegex(
RuntimeError,
'^{}$'.format(re.escape('Point scores must be reachable.'))
):
tennis.Game(server_points=3, returner_points=5, deciding_point=True)
tennis.Game(server_points=5, returner_points=3)
tennis.Game(server_points=3, returner_points=5)
tennis.Game(server_points=4, returner_points=1)
tennis.Game(server_points=1, returner_points=4)
tennis.Game(server_points=4, returner_points=4)
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 __init__(
self,
*,
games=None,
target_games=6,
deciding_point=False,
tiebreak_games=6,
tiebreak_points=7
):
# TODO(abw333): validate games
if 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 tiebreak_games is not None and min(tiebreak_games, tiebreak_points) < 0:
raise RuntimeError('Point scores must be non-negative.')
if games is not None:
self.games = games
elif tiebreak_games != 0:
self.games = [tennis.Game(server_points=0, returner_points=0, deciding_point=deciding_point)]
else:
self.games = [tennis.Tiebreak(
first_server_points=0,
first_returner_points=0,
target_points=tiebreak_points
)]
self.target_games = target_games
self.deciding_point = deciding_point
self.tiebreak_games = tiebreak_games
self.tiebreak_points = tiebreak_points
self.winner = self._compute_winner()
self._first_server_to_serve = self._compute_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_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_init_kwargs(self):
game = tennis.Game(deciding_point=True, returner_points=4, server_points=3)
self.assertEqual(game.server_points, 3)
self.assertEqual(game.returner_points, 4)
self.assertTrue(game.deciding_point)
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_init_no_args(self):
game = tennis.Game()
self.assertEqual(game.server_points, 0)
self.assertEqual(game.returner_points, 0)
self.assertFalse(game.deciding_point)
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_winner(self):
self.assertIsNone(tennis.Game(server_points=0, returner_points=0).winner)
self.assertIsNone(tennis.Game(server_points=4, returner_points=3).winner)
self.assertIsNone(tennis.Game(server_points=3, returner_points=4).winner)
self.assertTrue(tennis.Game(server_points=4, returner_points=0).winner)
self.assertTrue(tennis.Game(server_points=4, returner_points=2).winner)
self.assertTrue(tennis.Game(server_points=5, returner_points=3).winner)
self.assertTrue(tennis.Game(server_points=4, returner_points=3, deciding_point=True).winner)
self.assertFalse(tennis.Game(server_points=0, returner_points=4).winner)
self.assertFalse(tennis.Game(server_points=2, returner_points=4).winner)
self.assertFalse(tennis.Game(server_points=3, returner_points=5).winner)
self.assertFalse(tennis.Game(server_points=3, returner_points=4, deciding_point=True).winner)
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 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))
from mamba import description, context, it
from expects import expect, equal
import tennis
with description('Tennis') as self:
with it('starts with 0 - 0 score'):
rafa_nadal = "Rafa Nadal"
roger_federer = "Roger Federer"
game = tennis.Game(rafa_nadal, roger_federer)
expect(game.score()).to(equal((0, 0)))
def setUp(self): self.g = tennis.Game();
def test_repr(self):
self.assertEqual(
repr(tennis.Game(server_points=1, returner_points=2, deciding_point=True)),
'Game(server_points=1, returner_points=2, deciding_point=True)'
)
