def test_tenth_frame_spare():
game = Game()
for _ in range(9):
game.add(10)
game.add(9)
game.add(1)
game.add(1)
assert game.score == 270
class BowlingTest(unittest.TestCase):
def setUp(self):
self.game = Game()
def test_all_gutterballs(self):
self.helper_test_roll(20, 0)
self.assertEqual(0, self.game.score())
def helper_test_roll(self, rolls, pins):
for roll in range(rolls):
self.game.roll(pins)
def test_perfect_game(self):
self.helper_test_roll(12, 10)
self.assertEqual(300, self.game.score())
def test_end_of_array():
game = Game()
for _ in range(9):
game.add(0)
game.add(0)
game.add(2)
game.add(8)
game.add(10)
assert game.score == 20
def test_simple_spare():
game = Game()
game.add(3)
game.add(7)
game.add(3)
assert game.score_for_frame(1) == 13
assert game.current_frame == 2
def test_simple_strike():
game = Game()
game.add(10)
game.add(3)
game.add(6)
assert game.score_for_frame(1) == 19
assert game.score_for_frame(2) == 28
assert game.current_frame == 3
def test_four_throws_no_mark():
game = Game()
game.add(5)
game.add(4)
game.add(7)
game.add(2)
assert game.score == 18
assert game.score_for_frame(1) == 9
assert game.score_for_frame(2) == 18
assert game.current_frame == 3
class BowlingTest(unittest.TestCase):
def rollMany(self, n, pins):
for i in range(n):
self.g.roll(pins)
def rollSpare(self):
self.g.roll(5)
self.g.roll(5)
def rollStrike(self):
self.g.roll(10)
def setUp(self):
self.g = Game()
def test_gutterGame(self):
self.rollMany(20,0)
self.assertEqual(0, self.g.score())
def test_allOnes(self):
self.rollMany(20,1)
self.assertEqual(20, self.g.score())
def test_oneSpare(self):
self.rollSpare()
self.g.roll(3)
self.rollMany(17, 0)
self.assertEqual(16, self.g.score())
def test_oneStrike(self):
self.rollStrike()
self.g.roll(3)
self.g.roll(4)
self.rollMany(17, 0)
self.assertEqual(24, self.g.score())
def test_perfectGame(self):
self.rollMany(12, 10)
self.assertEqual(300, self.g.score())
class BowlingTest(unittest.TestCase):
def test_gutter_game(self):
self.__setup()
self.__roll_many(n=20, pins=0)
self.assertEqual(self.g.score(), 0)
def test_all_ones(self):
self.__setup()
self.__roll_many(n=20, pins=1)
self.assertEqual(self.g.score(), 20)
def test_one_spare(self):
self.__setup()
self.__roll_spare()
self.g.roll(3)
self.__roll_many(n=17, pins=0)
self.assertEqual(self.g.score(), 16)
def test_one_strike(self):
self.__setup()
self.__roll_strike()
self.g.roll(3)
self.g.roll(4)
self.__roll_many(n=16, pins=0)
self.assertEqual(self.g.score(), 24)
def test_perfect_game(self):
self.__setup()
self.__roll_many(n=12, pins=10)
self.assertEqual(self.g.score(), 300)
def __setup(self):
self.g = Game()
def __roll_many(self, n, pins):
for i in range(n):
self.g.roll(pins)
def __roll_spare(self):
self.g.roll(5)
self.g.roll(5)
def __roll_strike(self):
self.g.roll(10)
def test_sample_game():
game = Game()
game.add(1)
game.add(4)
game.add(4)
game.add(5)
game.add(6)
game.add(4)
game.add(5)
game.add(5)
game.add(10)
game.add(0)
game.add(1)
game.add(7)
game.add(3)
game.add(6)
game.add(4)
game.add(10)
game.add(2)
game.add(8)
game.add(6)
assert game.score == 133
def test_perfect_game(self):
game = Game("XXXXXXXXXXXX")
self.assertEqual(game.score(), 300)
def setUp(self): self.g = Game()
def setUp(self):
self.game = Game(1)
class GameTest(unittest.TestCase):
def setUp(self):
self.g = Game()
def roll_many(self, n, pins):
for i in range(n):
self.g.roll(pins)
def spare(self):
self.roll_many(2, 5)
def test_gutter_game(self):
self.roll_many(20, 0)
self.assertEqual(0, self.g.score())
def test_all_ones(self):
self.roll_many(20, 1)
self.assertEqual(20, self.g.score())
def test_spare(self):
self.spare()
self.g.roll(3)
self.roll_many(17, 0)
self.assertEqual(16, self.g.score())
def test_no_spare(self):
self.g.roll(2)
self.g.roll(6)
self.g.roll(4)
self.roll_many(17, 0)
self.assertEqual(12, self.g.score())
def test_strike(self):
self.g.roll(10)
self.g.roll(6)
self.g.roll(3)
self.assertEqual(28, self.g.score())
def test_perfect_game(self):
self.roll_many(12, 10)
self.assertEqual(300, self.g.score())
def test_two_throws_no_mark():
game = Game()
game.add(5)
game.add(4)
assert game.score == 9
assert game.current_frame == 2
def test_heart_break():
game = Game()
for _ in range(11):
game.add(10)
game.add(9)
assert game.score == 299
def test_gutter_game(self):
game = Game(roll_many("-", 20))
self.assertEqual(game.score(), 0)
def test_all_ones(self):
game = Game(roll_many("1", 20))
self.assertEqual(game.score(), 20)
def test_spare_game(self):
game = Game("5/5/5/5/5/5/5/5/5/5/5")
self.assertEqual(game.score(), 150)
def test_heartbreak_game(self):
game = Game("9-9-9-9-9-9-9-9-9-9-")
self.assertEqual(game.score(), 90)
def setUp(self):
""" Pretty much every single test is going to require a game, so we set one up by default."""
self.game = Game()
class TestBowling(unittest.TestCase):
"""
Unit tests for a bowling game.
"""
def setUp(self):
self.game = Game()
def test_number_of_pins_down(self):
"""
Tests the number of pins down in a roll.
The number of pins down can't be less than zero and greater than ten.
"""
self.assertRaises(PinsDownError, self.game.roll, -1)
self.assertRaises(PinsDownError, self.game.roll, 11)
self.game.roll(5)
self.assertEqual(self.game.score, 5)
self.assertRaises(PinsDownError, self.game.roll, 6)
self.game.roll(4)
self.assertEqual(self.game.score, 9)
def test_number_of_frames(self):
"""
Tests the number of frames and rolls in a game.
A bowling game has ten frames, and each frame has two rolls.
"""
for i in range(10):
self.game.roll(1)
self.game.roll(1)
self.assertEqual(len(self.game.frames[i]), 2)
self.assertEqual(len(self.game.frames), 10)
self.assertRaises(NumberOfFramesError, self.game.roll, 1)
def test_frame_with_strike(self):
"""
Tests a frame with an strike.
When the bowler gets an strike, the frame is over.
"""
self.game.roll(10)
self.assertEqual(len(self.game.frames), 1)
self.assertEqual(len(self.game.frames[0]), 1)
def test_final_score_without_strikes_and_spares(self):
"""
Tests the final score of a game without any strike or spare.
"""
for i in range(10):
self.game.roll(1)
self.game.roll(1)
self.assertEqual(self.game.score, 20)
def test_spare_score(self):
"""
Tests the partial score of an spare.
The score of an spare is ten plus the score of the following roll.
"""
self.game.roll(9)
self.game.roll(1)
self.game.roll(1)
self.assertEqual(self.game.score, 12)
def test_strike_score(self):
"""
Tests the partial score of an strike.
The score of an strike is ten plus the score of the following two rolls.
"""
self.game.roll(10)
self.game.roll(1)
self.game.roll(1)
self.assertEqual(self.game.score, 14)
def test_final_score_with_all_spares(self):
"""
Tests the final score of a bowling game with all spares.
"""
for i in range(10):
self.game.roll(1)
self.game.roll(9)
self.assertEqual(self.game.score, 109)
# When the last frame is an spare, bowler gets an extra roll
self.game.roll(1)
self.assertEqual(self.game.score, 110)
def test_final_score_with_all_strikes(self):
"""
Tests the final score of a bowling game with all strikes.
"""
for i in range(10):
self.game.roll(10)
self.assertEqual(self.game.score, 270)
# When the last frame is an strike, bowler gets two extra rolls
self.game.roll(10)
self.game.roll(10)
self.assertEqual(self.game.score, 300)
def test_strike(self):
game = Game("X34" + roll_many("-", 16))
self.assertEqual(game.score(), 24)
class PythonBowlingGame(unittest.TestCase):
# initialise game in setup, exit in tear town
def setUp(self):
self.game = Game(1)
def test_gutter_game(self):
self.roll_many(20, 0)
self.assertEqual(0, self.game.score()[0])
def test_all_ones(self):
self.roll_many(20, 1)
self.assertEqual(20, self.game.score()[0])
def test_one_spare(self):
self.game.roll(5)
self.game.roll(5)
self.game.roll(3)
self.roll_many(17,0)
self.assertEqual(16, self.game.score()[0])
def test_one_strike(self):
self.game.roll(10)
self.game.roll(3)
self.game.roll(4)
self.roll_many(16, 0)
self.assertEqual(24, self.game.score()[0])
def test_perfect_game(self):
self.roll_many(12,10)
self.assertEqual(300, self.game.score()[0])
# may also be worth testing that the maximum number of rolls on last turn is 3
def roll_many(self, n, pins):
for i in range(n):
self.game.roll(pins)
def test_spare(self):
game = Game("4/34" + roll_many("-", 16))
self.assertEqual(game.score(), 20)
def game():
return Game()
def setUp(self):
super(GameTestCase, self).setUp()
self.game = Game()
class BowlingGameTest(unittest.TestCase):
def setUp(self):
self.g = Game()
def testGutterGame(self):
self.__rollMany(0,0)
def testAllOnes(self):
self.__rollMany(1,20)
def testAddFrame(self):
self.g.add_frame(Frame())
self.assertEquals(1, len(self.g.frames))
def testBuildFramesWhileRolling(self):
self.g.roll(10)
self.assertEqual([[10]], self.g.frames_to_list())
self.g.roll(2)
self.assertEqual([[10], [2]], self.g.frames_to_list())
self.g.roll(4)
self.assertEqual([[10], [2,4]], self.g.frames_to_list())
self.g.roll(10)
self.assertEqual([[10], [2,4], [10]], self.g.frames_to_list())
def testSpare(self):
self.g.roll(4)
self.g.roll(6)
self.g.roll(4)
self.assertEqual(14+4, self.g.get_score())
def testStrike(self):
self.g.roll(10)
self.g.roll(2)
self.g.roll(4)
self.assertEqual(10+6+6, self.g.get_score())
def testShouldNotAddMoreThenTenFrames(self):
for i in range(10):
self.g.add_frame(Frame())
self.assertFalse(self.g.add_frame(Frame()))
self.assertEqual(10, len(self.g.frames))
def testPerfectGame(self):
for i in range(12):
self.g.roll(10)
self.assertEqual(300, self.g.get_score())
def __rollMany(self, pins, expected_score):
for i in range(20):
self.g.roll(pins)
self.assertEqual(expected_score, self.g.get_score())
class BowlingGameTest(unittest.TestCase):
def setUp(self):
self.g = Game()
def testGutterGame(self):
self.__rollMany(0, 0)
def testAllOnes(self):
self.__rollMany(1, 20)
def testAddFrame(self):
self.g.add_frame(Frame())
self.assertEquals(1, len(self.g.frames))
def testBuildFramesWhileRolling(self):
self.g.roll(10)
self.assertEqual([[10]], self.g.frames_to_list())
self.g.roll(2)
self.assertEqual([[10], [2]], self.g.frames_to_list())
self.g.roll(4)
self.assertEqual([[10], [2, 4]], self.g.frames_to_list())
self.g.roll(10)
self.assertEqual([[10], [2, 4], [10]], self.g.frames_to_list())
def testSpare(self):
self.g.roll(4)
self.g.roll(6)
self.g.roll(4)
self.assertEqual(14 + 4, self.g.get_score())
def testStrike(self):
self.g.roll(10)
self.g.roll(2)
self.g.roll(4)
self.assertEqual(10 + 6 + 6, self.g.get_score())
def testShouldNotAddMoreThenTenFrames(self):
for i in range(10):
self.g.add_frame(Frame())
self.assertFalse(self.g.add_frame(Frame()))
self.assertEqual(10, len(self.g.frames))
def testPerfectGame(self):
for i in range(12):
self.g.roll(10)
self.assertEqual(300, self.g.get_score())
def __rollMany(self, pins, expected_score):
for i in range(20):
self.g.roll(pins)
self.assertEqual(expected_score, self.g.get_score())
def __setup(self):
self.g = Game()
class TestGame(TestCase):
def setUp(self):
""" Pretty much every single test is going to require a game, so we set one up by default."""
self.game = Game()
def test_perfect_game(self):
"""If all 10 frames in a game are strike, we should have a perfect game and should score 300."""
for _ in range(9):
self.game.add_frame(Frame(10))
self.game.add_frame(Frame(10, 10, 10))
self.assertTrue(self.game.is_perfect_game)
self.assertEqual(self.game.total_score, 300)
self.assertFalse(self.game.is_gutter_game)
def test_gutter_game(self):
"""If no pins were down in the entire game, we should have a gutter game."""
for _ in range(10):
self.game.add_frame(Frame(0, 0))
self.assertTrue(self.game.is_gutter_game)
self.assertFalse(self.game.is_perfect_game)
def test_fill_allowed_if_strike(self):
"""Ensure fill frames are allowed is a strike is rolled on the last frame."""
for _ in range(9):
self.game.add_frame(Frame(0, 0))
self.game.add_frame(
(Frame(10, 10,
10))) # Last frame has extra rolls because it's a strike
def test_fill_allowed_if_spare(self):
"""Ensure fill frames are allowed is a spare is rolled on the last frame."""
for _ in range(9):
self.game.add_frame(Frame(0, 0))
self.game.add_frame((Frame(7, 3, 5)))
def test_fill_not_allowed_if_not_all_down(self):
"""Fill frames are only allowed if all 10 pins come down in the first 2 rolls."""
for _ in range(9):
self.game.add_frame(Frame(0, 0))
with self.assertRaises(AttributeError):
self.game.add_frame(Frame(2, 3, 9))
def test_fill_not_allowed_if_not_last(self):
"""Test that a fill frame is only allowed if it's the last roll."""
self.game.add_frame(Frame(5, 3))
with self.assertRaises(AttributeError):
self.game.add_frame(Frame(10, 10, 10))
def test_addiing_11_frames(self):
"""Only 11 frames are allowed in any one game of 10-pin bowling"""
for _ in range(10):
self.game.add_frame(Frame(4, 3))
# Adding the 11th frame should raise an exception
with self.assertRaises(IndexError):
self.game.add_frame(Frame(10))
def test_score_with_strike(self):
"""Basic test to ensure strikes are calculated correctly.
This is test by rolling a strike, followed by a (5, 3) and a (6, 3).
We should have (10 + 5 + 3) + 8 + 9 points == 35"""
self.game.add_frame(Frame(10)) # Strike
self.game.add_frame(Frame(5, 3))
self.game.add_frame(Frame(6, 3))
self.assertEqual(self.game.total_score, 35)
def test_consecutive_strikes(self):
"""
Ensure score is calculated correctly if we roll several strikes in a row.
The score should be (10 + 10 + 10) + (10 + 10 + 5) + (10 + 5 + 3) + 8 + 9 == 90.
"""
self.game.add_frame(Frame(10)) # Strike
self.game.add_frame(Frame(10)) # Strike
self.game.add_frame(Frame(10)) # Strike
self.game.add_frame(Frame(5, 3))
self.game.add_frame(Frame(6, 3))
self.assertEqual(self.game.total_score, 90)
def test_score_with_spare(self):
"""Basic test to ensure spares are calculated correctly.
This is done by rolling a spare (10 points) + 8 pins.
We should end up with (10 + 5) + 8 points.
"""
self.game.add_frame(Frame(6, 4)) # Spare
self.game.add_frame(Frame(5, 3))
self.assertEqual(self.game.total_score, 23)
def test_score_with_consecutive_spares(self):
"""
Ensure score is calculated correctly if we roll several spares in a row.
The score should be (10 + 2) + (10 + 7) + (10 + 5) + 8 == 66.
"""
self.game.add_frame(Frame(6, 4)) # Spare
self.game.add_frame(Frame(2, 8)) # Spare
self.game.add_frame(Frame(7, 3)) # Spare
self.game.add_frame(Frame(5, 3))
self.assertEqual(self.game.total_score, 52)
def test_score_with_strike_spare_combo(self):
"""
Ensure score is calculated correctly if we mix spares and strikes in consecutive frames.
The score should be (10 + 10) + (10 + 7 + 3) + (10 + 10) (10 + 5 + 5) + 10 == 100.
"""
self.game.add_frame(Frame(6, 4)) # Spare
self.game.add_frame(Frame(10)) # Strike
self.game.add_frame(Frame(7, 3)) # Spare
self.game.add_frame(Frame(10)) # Strike
self.game.add_frame(Frame(5, 5)) # Spare
self.assertEqual(self.game.total_score, 90)
def test_score_with_regular_simple_scores(self):
"""
This is to test the scoring works with some regular casual rolls.
Game and score was created using https://www.bowlinggenius.com/.
"""
self.game.add_frame(Frame(8, 2))
self.game.add_frame(Frame(6, 4))
self.game.add_frame(Frame(3, 2))
self.game.add_frame(Frame(6, 2))
self.game.add_frame(Frame(1, 3))
self.game.add_frame(Frame(4, 5))
self.game.add_frame(Frame(4, 3))
self.game.add_frame(Frame(9, 1))
self.game.add_frame(Frame(10))
self.game.add_frame(Frame(0, 2))
self.assertEqual(self.game.total_score, 96)
class GameTestCase(TestCase):
def setUp(self):
super(GameTestCase, self).setUp()
self.game = Game()
def tearDown(self):
super(GameTestCase, self).tearDown()
def testAllGutter(self):
self.rollMany(20, 0)
self.assertEqual(0, self.game.score())
def testAllOne(self):
self.rollMany(20, 1)
self.assertEqual(20, self.game.score())
def testOneSpare(self):
self.rollSpare()
self.game.roll(3)
self.rollMany(17, 0)
self.assertEqual(16, self.game.score())
def testAllStrikeButLastFrame(self):
self.rollMany(9, 10)
self.rollMany(2, 0)
self.assertEquals(240, self.game.score())
def testAllStrikeButLastThrow(self):
self.rollMany(11, 10)
self.game.roll(9)
self.assertEquals(299, self.game.score())
def testAllStrikeButFirstFrameIsSpare(self):
self.rollSpare()
self.rollMany(11, 10)
self.assertEquals(290, self.game.score())
def testAllStrikeButFirstFrameIsNotSpare(self):
self.game.roll(5)
self.game.roll(4)
self.rollMany(11, 10)
self.assertEquals(279, self.game.score())
def testTwoSpares(self):
self.rollSpare()
self.rollSpare()
self.game.roll(3)
self.game.roll(3)
self.rollMany(14, 0)
self.assertEqual(15 + 13 + 6, self.game.score())
def testOneStrike(self):
self.rollStrike()
self.game.roll(3)
self.game.roll(4)
self.rollMany(16, 0)
self.assertEqual(24, self.game.score())
def testPerfectGame(self):
self.rollMany(12, 10)
self.assertEqual(300, self.game.score())
def rollStrike(self):
self.game.roll(10)
def rollSpare(self):
self.game.roll(5)
self.game.roll(5) #spare
def rollMany(self, n, pins):
map(lambda x: self.game.roll(pins=pins), range(0, n))
def test_always_normal(self):
game = Game("12345123451234512345")
self.assertEqual(game.score(), 60)
def setUp(self):
self.game = Game()
def test_perfect_game():
game = Game()
for _ in range(12):
game.add(10)
assert game.score == 300
assert game.current_frame == 11
def setUp(self):
self.g = Game()
def test_functional_2_hit(self):
game = Game(game_result='12')
result = game.calculate_result()
self.assertEqual(
result, 3,
'Не верно рассчитываются очки за 2 попадания 2 бросками !')
