def test_too_much_pins_error(self):
"""
Checks if the good error is raised when too much pins seem to have been knocked out
"""
frame = BowlingFrame("test")
self.assertRaises(PinsOverflowError, frame.registerThrowing, 19)
frame.registerThrowing(9)
self.assertRaises(PinsOverflowError, frame.registerThrowing, 3)
def test_finish_strike(self):
"""
Tests that the frame consider itself as finished after a strike
"""
frame = BowlingFrame("test")
self.assertFalse(frame.isFinished)
frame.registerThrowing(10)
self.assertTrue(frame.isFinished)
def test_is_strike(self):
"""
Tests that the frame detects the strike
"""
frame = BowlingFrame("test")
self.assertFalse(frame.isHole() or frame.isSpare() or frame.isStrike())
frame.registerThrowing(10)
self.assertTrue(frame.isStrike())
self.assertFalse(frame.isHole() or frame.isSpare())
def test_number_pins(self):
"""
Checks if the number of knocked down pins is returned correctly
"""
frame = BowlingFrame("test")
self.assertEqual(frame.getNbOfKnockedDownPins(), 0)
frame.registerThrowing(5)
self.assertEqual(frame.getNbOfKnockedDownPins(), 5)
frame.registerThrowing(5)
self.assertEqual(frame.getNbOfKnockedDownPins(), 10)
self.assertEqual(frame.getNbOfKnockedDownPins(1), 5)
self.assertEqual(frame.getNbOfKnockedDownPins(2), 10)
def test_score_hole(self):
"""
Tests that the score of a frame is updated directly after the hole is finished
"""
frame = BowlingFrame("test")
self.assertTrue(frame.getScore() is None)
frame.registerThrowing(4)
self.assertTrue(frame.getScore() is None)
frame.registerThrowing(5)
self.assertEqual(frame.getScore(), 9)
def test_compute_max_score_on_frames(self):
"""
Tests if the maximum score is computed correctly
"""
frames = []
for _ in range(9):
frame = BowlingFrame("test")
frame.registerThrowing(10)
frames.append(frame)
frame = BowlingFrame("test", ending=True)
# Three strikes are allowed in the ending frame
frame.registerThrowing(10)
frame.registerThrowing(10)
frame.registerThrowing(10)
frames.append(frame)
self.assertEqual(BowlingGame.computeScoreOnFrames(frames), 300)
def test_get_throwing(self):
"""
Tests if the get throwing method returns a tuple with all the throwing
"""
frame = BowlingFrame("test")
frame.registerThrowing(3)
self.assertEqual(frame.getThrowing(), (3,))
frame.registerThrowing(5)
self.assertEqual(frame.getThrowing(), (3, 5))
def test_str_strike_ending(self):
"""
Checks if the string representation of the ending frame is correct for a strike
"""
frame = BowlingFrame("test", ending=True)
frame.registerThrowing(10)
frame.registerThrowing(10)
frame.registerThrowing(10)
self.assertEqual(frame.__str__(), '| |X|X|X|')
self.assertEqual(frame.__str__(True), '| 30 |')
def test_str_spare_ending(self):
"""
Checks if the string representation of the ending frame is correct for a spare
"""
frame = BowlingFrame("test", ending=True)
frame.registerThrowing(5)
frame.registerThrowing(5)
frame.registerThrowing(6)
self.assertEqual(frame.__str__(), '| |5|/|6|')
self.assertEqual(frame.__str__(True), '| 16 |')
def calculate_score(self):
score = 0
index = 0
for i in range(10):
first_roll = self.rolls[index]
second_roll = self.rolls[index + 1]
try:
third_roll = self.rolls[index + 2]
f = BowlingFrame([first_roll, second_roll, third_roll])
except IndexError:
f = BowlingFrame([first_roll, second_roll])
score += f.calculate_score()
index += f.calculate_offset()
return score
def test_str(self):
"""
Tests if the string representation of the game is correct
"""
frame1 = BowlingFrame("test")
frame2 = BowlingFrame("test")
game = BowlingGame(['test'])
game.frames = {"test": [frame1, frame2]}
representation = 'test\n' + frame1.__str__() + ' ' + frame2.__str__() + ' \n' + \
frame1.__str__(True) + ' ' + frame2.__str__(True) + ' \n'
self.assertEqual(str(game).strip(), representation.strip())
def test_finish_strike_ending3(self):
"""
Tests that an ending frame does not consider itself as finished after three strikes on the two first throwing
"""
frame = BowlingFrame("test", True)
self.assertFalse(frame.isFinished)
frame.registerThrowing(10)
self.assertFalse(frame.isFinished)
frame.registerThrowing(10)
self.assertFalse(frame.isFinished)
frame.registerThrowing(10)
self.assertTrue(frame.isFinished)
def test_finish_spare_ending(self):
"""
Tests that an ending frame does not consider itself as finished after a spare on the two first throwing
"""
frame = BowlingFrame("test", True)
self.assertFalse(frame.isFinished)
frame.registerThrowing(3)
self.assertFalse(frame.isFinished)
frame.registerThrowing(7)
self.assertFalse(frame.isFinished)
frame.registerThrowing(4)
self.assertTrue(frame.isFinished)
def test_str_spare(self):
"""
Checks if the string representation of the frame is correct for a spare
"""
frame = BowlingFrame("test")
frame.registerThrowing(3)
frame.registerThrowing(7)
self.assertEqual(frame.__str__(), '| |3|/|')
self.assertEqual(frame.__str__(True), '| |')
def test_str_hole_ending(self):
"""
Checks if the string representation of the frame is correct for a hole
"""
frame = BowlingFrame("test", ending=True)
frame.registerThrowing(3)
frame.registerThrowing(4)
self.assertEqual(frame.__str__(), '| |3|4| |')
self.assertEqual(frame.__str__(True), '| 7 |')
def test_spare_frame():
f = BowlingFrame([6, 4, 8])
assert f.calculate_score() == 18, 'got 18 for the frame'
assert f.calculate_offset() == 2, 'got 2 for offset'
def test_compute_undefined_score_on_frames(self):
"""
Tests if the score is undefined on an incomplete game ending on a strike
"""
frames = []
frame = BowlingFrame("test")
frame.registerThrowing(2)
frame.registerThrowing(3)
frames.append(frame)
frame = BowlingFrame("test")
frame.registerThrowing(6)
frame.registerThrowing(4)
frames.append(frame) # Spare
frame = BowlingFrame("test")
frame.registerThrowing(8)
frame.registerThrowing(1)
frames.append(frame)
frame = BowlingFrame("test")
frame.registerThrowing(10)
frames.append(frame) # Strike
self.assertEqual(BowlingGame.computeScoreOnFrames(frames), None)
def test_compute_incomplete_score_on_frames(self):
"""
Tests if the score is computed correctly on an incomplete game
"""
frames = []
frame = BowlingFrame("test")
frame.registerThrowing(2)
frame.registerThrowing(3)
frames.append(frame)
frame = BowlingFrame("test")
frame.registerThrowing(6)
frame.registerThrowing(4)
frames.append(frame) # Spare
frame = BowlingFrame("test")
frame.registerThrowing(8)
frame.registerThrowing(1)
frames.append(frame)
frame = BowlingFrame("test")
frame.registerThrowing(10)
frames.append(frame) # Strike
frame = BowlingFrame("test")
frame.registerThrowing(3)
frame.registerThrowing(0)
frames.append(frame)
self.assertEqual(BowlingGame.computeScoreOnFrames(frames), 48)
def test_error_incomplete_frame2(self):
"""
Tests if the good error is raised when a frame is not complete
"""
frames = [BowlingFrame("test")]
self.assertRaises(ValueError, BowlingGame.computeScoreOnFrames, frames)
def test_negative_pins_error(self):
"""
Checks if the good error is raised when a negative number of pins is passed
"""
frame = BowlingFrame("test")
self.assertRaises(ValueError, frame.registerThrowing, -1)
def test_number_pins_ending(self):
"""
Checks if the number of knocked down pins is returned correctly, even for an ending frame
"""
frame = BowlingFrame("test", ending=True)
self.assertEqual(frame.getNbOfKnockedDownPins(), 0)
frame.registerThrowing(5)
self.assertEqual(frame.getNbOfKnockedDownPins(), 5)
frame.registerThrowing(5)
self.assertEqual(frame.getNbOfKnockedDownPins(), 10)
frame.registerThrowing(7)
self.assertEqual(frame.getNbOfKnockedDownPins(), 17)
self.assertEqual(frame.getNbOfKnockedDownPins(1), 5)
self.assertEqual(frame.getNbOfKnockedDownPins(2), 10)
self.assertEqual(frame.getNbOfKnockedDownPins(3), 17)
def test_get_throwing_ending(self):
"""
Tests if the get throwing method returns a tuple with all the throwing, even in an ending frame
"""
frame = BowlingFrame("test", ending=True)
frame.registerThrowing(3)
self.assertEqual(frame.getThrowing(), (3,))
frame.registerThrowing(7)
self.assertEqual(frame.getThrowing(), (3, 7))
frame.registerThrowing(6)
self.assertEqual(frame.getThrowing(), (3, 7, 6))
def test_previous_score_hole(self):
"""
Tests that the score of a frame is updated directly after the hole is finished, taking into account the
previous score
"""
frame = BowlingFrame("test")
self.assertTrue(frame.getScore() is None)
frame.registerThrowing(4)
self.assertTrue(frame.getScore() is None)
frame.registerThrowing(5)
self.assertEqual(frame.getScore(), 9)
frame.setPreviousScore(10)
self.assertEqual(frame.getScore(), 19)
def test_score_spare2(self):
"""
Tests that the score of a frame is updated correctly after the spare and the strike of the next frame are
finished
"""
frame1 = BowlingFrame("test")
frame2 = BowlingFrame("test")
frame1.registerThrowing(9)
frame1.registerThrowing(1)
self.assertTrue(frame1.getScore() is None)
frame2.registerThrowing(10)
frame1.computeScore(frame2)
self.assertEqual(frame1.getScore(), 20)
self.assertTrue(frame2.getScore() is None)
def test_score_strike(self):
"""
Tests that the score of a frame is updated correctly after a single strike
"""
frame1 = BowlingFrame("test")
frame2 = BowlingFrame("test")
frame1.registerThrowing(10)
self.assertTrue(frame1.getScore() is None)
frame2.registerThrowing(2)
self.assertTrue(frame1.getScore() is None)
frame2.registerThrowing(5)
frame1.computeScore(frame2)
self.assertEqual(frame1.getScore(), 17)
def test_strike_frame():
f = BowlingFrame([10, 3, 6])
assert f.calculate_score() == 19, 'got 19 for the frame'
assert f.calculate_offset() == 1, 'got 1 for offset'
def test_normal_frame():
f = BowlingFrame([3, 5])
assert f.calculate_score() == 8, 'got 8 for the frame'
assert f.calculate_offset() == 2, 'got 2 for offset'
def test_score_strike3(self):
"""
Tests that the score of a frame is updated correctly after three strikes in a row
"""
frame1 = BowlingFrame("test")
frame2 = BowlingFrame("test")
frame3 = BowlingFrame("test")
frame1.registerThrowing(10)
self.assertTrue(frame1.getScore() is None)
frame2.registerThrowing(10)
self.assertTrue(frame1.getScore() is None)
frame3.registerThrowing(10)
frame1.computeScore(frame2, frame3)
self.assertEqual(frame1.getScore(), 30)
