Merge pull request #206 from rpottsoh/updateBowling

Author: rpottsoh

exercises/bowling/uBowlingExample.pas

@@ -5,7 +5,7 @@ interface
 type
    IBowlingGame = interface(IInvokable)
    ['{D4A292B6-BC15-48ED-AE04-2D34759017CB}']
-     procedure Roll(aPins: integer);
+     function Roll(aPins: integer): Boolean;
      function Score: integer;
    end;
 
@@ -28,10 +28,11 @@    TBowlingGame = class(TInterfacedObject, IBowlingGame)
      function SpareBonus(aFrameIndex: integer): integer;
      function SumOfPinsInFrame(aFrameIndex: integer): integer;
      function CorrectNumberOfRolls(aFrameIndex: integer): boolean;
+     function ValidInput(aPin: integer): Boolean;
    public
      constructor create;
      function Score: integer;
-     procedure Roll(aPins: integer);
+     function Roll(aPins: integer): Boolean;
    end;
 
 function NewBowlingGame: IBowlingGame;
@@ -44,8 +45,11 @@ constructor TBowlingGame.create;
   fRolls := TList<integer>.Create;
 end;
 
-procedure TBowlingGame.Roll(aPins: Integer);
+function TBowlingGame.Roll(aPins: Integer): Boolean;
 begin
+  if not ValidInput(aPins) then
+    exit(false);
+
   fRolls.Add(aPins);
 end;
 
@@ -59,6 +63,8 @@ function TBowlingGame.Score: integer;
   lScore := 0;
   lFrameIndex := 0;
   try
+    if (fRolls.Count < 12) or (fRolls.Count > 21) then
+      raise EArgumentException.Create('Not a proper game');
     for i := 1 to fNumberOfFrames do
     begin
       if fRolls.Count <= lFrameIndex then
@@ -70,7 +76,7 @@ function TBowlingGame.Score: integer;
           raise EArgumentException.Create('Not a proper game');
 
         lStrikeBonus := StrikeBonus(lFrameIndex);
-        if (lStrikeBonus > fMaximumFrameScore) and not IsStrike(lFrameIndex + 1) then
+        if (lStrikeBonus > fMaximumFrameScore) and not IsStrike(lFrameIndex + 1) or (lStrikeBonus > 20) then
           raise EArgumentException.Create('Not a proper game');
 
         lScore := lScore + 10 + lStrikeBonus;
@@ -126,6 +132,27 @@ function TBowlingGame.SumOfPinsInFrame(aFrameIndex: Integer): integer;
   result := fRolls[aFrameIndex] + fRolls[aFrameIndex + 1];
 end;
 
+function TBowlingGame.ValidInput(aPin: integer): Boolean;
+begin
+  result := true;
+  if (fRolls.Count >= 21) or (aPin < 0) or (aPin > 10) or
+      ((fRolls.Count + 1) mod 2 = 0) and (fRolls[fRolls.Count - 1] <> 10) and ((fRolls[fRolls.Count - 1] + aPin) > 10) then
+    exit(false);
+
+  if (fRolls.Count = 20) then
+  begin
+    if (fRolls[18] <> 10) and (fRolls[18] + fRolls[19] <> 10) then
+      exit(false);
+
+    if (aPin = 10) and ((fRolls[18] <> 10) or (fRolls[19] <> 10) or (fRolls[19] + aPin > 10) and (fRolls[19] + aPin <> 20)) and
+        (fRolls[18] + fRolls[19] <> 10) then
+      exit(false);
+
+    if (aPin <> 10) and (fRolls[19] + aPin > 10) and (fRolls[19] <> 10) then
+      exit(false);
+  end;
+end;
+
 function TBowlingGame.CorrectNumberOfRolls(aFrameIndex: Integer): boolean;
 begin
   result := aFrameIndex = fRolls.Count;

exercises/bowling/uBowlingTests.pas

@@ -5,6 +5,9 @@ interface
   DUnitX.TestFramework,
   uBowling;
 
+const
+  CanonicalVersion = '1.2.0';
+
 type
 
   [TestFixture]
@@ -13,7 +16,7 @@   BowlingTests = class(TObject)
     class function RollMany(pins: array of integer; game: IBowlingGame): IBowlingGame; static;
   public
     [Test]
-//  [Ignore('Comment the "[Ignore]" statement to run the test')]
+//    [Ignore('Comment the "[Ignore]" statement to run the test')]
     procedure Should_be_able_to_score_a_game_with_all_zeros;
 
     [Test]
@@ -80,10 +83,26 @@   BowlingTests = class(TObject)
     [Ignore]
     procedure Two_rolls_in_a_frame_cannot_score_more_than_10_points;
 
+    [Test]
+    [Ignore]
+    procedure Bonus_roll_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points;
+
     [Test]
     [Ignore]
     procedure Two_bonus_rolls_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points;
 
+    [Test]
+    [Ignore]
+    procedure Two_bonus_rolls_after_a_strike_in_the_last_frame_can_score_more_than_10_points_if_one_is_a_strike;
+
+    [Test]
+    [Ignore]
+    procedure The_second_bonus_rolls_after_a_strike_in_the_last_frame_cannot_be_a_strike_if_the_first_one_is_not_a_strike;
+
+    [Test]
+    [Ignore]
+    procedure Second_bonus_roll_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points;
+
     [Test]
     [Ignore]
     procedure An_unstarted_game_cannot_be_scored;
@@ -94,7 +113,7 @@   BowlingTests = class(TObject)
 
     [Test]
     [Ignore]
-    procedure A_game_with_more_than_ten_frames_cannot_be_scored;
+    procedure Cannot_roll_if_game_already_has_ten_frames;
 
     [Test]
     [Ignore]
@@ -107,11 +126,26 @@   BowlingTests = class(TObject)
     [Test]
     [Ignore]
     procedure Bonus_roll_for_a_spare_in_the_last_frame_must_be_rolled_before_score_can_be_calculated;
+
+    [Test]
+    [Ignore]
+    procedure Cannot_roll_after_bonus_roll_for_spare;
+
+    [Test]
+    [Ignore]
+    procedure Cannot_roll_after_bonus_rolls_for_strike;
   end;
 
 implementation
 uses System.SysUtils;
 
+procedure BowlingTests.Second_bonus_roll_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10], NewBowlingGame);
+  Assert.IsFalse(game.Roll(11));
+end;
+
 procedure BowlingTests.Should_be_able_to_score_a_game_with_all_zeros;
 var game: IBowlingGame;
 begin
@@ -231,13 +265,27 @@ procedure BowlingTests.Two_rolls_in_a_frame_cannot_score_more_than_10_points;
   Assert.AreEqual(-1, game.Score);
 end;
 
+procedure BowlingTests.The_second_bonus_rolls_after_a_strike_in_the_last_frame_cannot_be_a_strike_if_the_first_one_is_not_a_strike;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6], NewBowlingGame);
+  Assert.IsFalse(game.Roll(10));
+end;
+
 procedure BowlingTests.Two_bonus_rolls_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points;
 var game: IBowlingGame;
 begin
   game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 6], NewBowlingGame);
   Assert.AreEqual(-1, game.Score);
 end;
 
+procedure BowlingTests.Two_bonus_rolls_after_a_strike_in_the_last_frame_can_score_more_than_10_points_if_one_is_a_strike;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6], NewBowlingGame);
+  Assert.AreEqual(26, game.Score);
+end;
+
 procedure BowlingTests.An_unstarted_game_cannot_be_scored;
 var game: IBowlingGame;
 begin
@@ -252,11 +300,25 @@ procedure BowlingTests.An_incomplete_game_cannot_be_scored;
   Assert.AreEqual(-1, game.Score);
 end;
 
-procedure BowlingTests.A_game_with_more_than_ten_frames_cannot_be_scored;
+procedure BowlingTests.Cannot_roll_after_bonus_rolls_for_strike;
 var game: IBowlingGame;
 begin
-  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], NewBowlingGame);
-  Assert.AreEqual(-1, game.Score);
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 3, 2], NewBowlingGame);
+  Assert.IsFalse(game.Roll(2));
+end;
+
+procedure BowlingTests.Cannot_roll_after_bonus_roll_for_spare;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 2], NewBowlingGame);
+  Assert.IsFalse(game.Roll(2));
+end;
+
+procedure BowlingTests.Cannot_roll_if_game_already_has_ten_frames;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], NewBowlingGame);
+  Assert.IsFalse(game.Roll(0));
 end;
 
 procedure BowlingTests.Bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated;
@@ -273,6 +335,20 @@ procedure BowlingTests.Both_bonus_rolls_for_a_strike_in_the_last_frame_must_be_r
   Assert.AreEqual(-1, game.Score);
 end;
 
+procedure BowlingTests.Bonus_roll_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points;
+var game: IBowlingGame;
+begin
+  game := RollMany([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10], NewBowlingGame);
+  Assert.IsFalse(game.Roll(11));
+    (*{
+        var sut = new BowlingGame();
+        var previousRolls = new int[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10};
+        DoRoll(previousRolls, sut);
+        Assert.Throws<ArgumentException>(() => sut.Roll(11));
+    } (**)
+
+end;
+
 procedure BowlingTests.Bonus_roll_for_a_spare_in_the_last_frame_must_be_rolled_before_score_can_be_calculated;
 var game: IBowlingGame;
 begin