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)