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)' )