trackler 2.2.1.151 → 2.2.1.152

data/tracks/csharp/exercises/atbash-cipher/AtbashCipherTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 using Xunit;
 

data/tracks/csharp/exercises/beer-song/BeerSong.cs

@@ -2,12 +2,7 @@
 
 public static class BeerSong
 {
-    public static string Verse(int number)
-    {
-        throw new NotImplementedException("You need to implement this function.");
-    }
-
-    public static string Verses(int begin, int end)
+    public static string Recite(int startBottles, int takeDown)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/beer-song/BeerSongTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 2.1.0 of the canonical data.
 
 using Xunit;
 
@@ -9,9 +9,8 @@ public void First_generic_verse()
     {
         var expected = 
             "99 bottles of beer on the wall, 99 bottles of beer.\n" +
-            "Take one down and pass it around, 98 bottles of beer on the wall.\n" +
-            "";
-        Assert.Equal(expected, BeerSong.Verse(99));
+            "Take one down and pass it around, 98 bottles of beer on the wall.";
+        Assert.Equal(expected, BeerSong.Recite(99, 1));
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -19,39 +18,35 @@ public void Last_generic_verse()
     {
         var expected = 
             "3 bottles of beer on the wall, 3 bottles of beer.\n" +
-            "Take one down and pass it around, 2 bottles of beer on the wall.\n" +
-            "";
-        Assert.Equal(expected, BeerSong.Verse(3));
+            "Take one down and pass it around, 2 bottles of beer on the wall.";
+        Assert.Equal(expected, BeerSong.Recite(3, 1));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Verse_2()
+    public void Verse_with_2_bottles()
     {
         var expected = 
             "2 bottles of beer on the wall, 2 bottles of beer.\n" +
-            "Take one down and pass it around, 1 bottle of beer on the wall.\n" +
-            "";
-        Assert.Equal(expected, BeerSong.Verse(2));
+            "Take one down and pass it around, 1 bottle of beer on the wall.";
+        Assert.Equal(expected, BeerSong.Recite(2, 1));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Verse_1()
+    public void Verse_with_1_bottle()
     {
         var expected = 
             "1 bottle of beer on the wall, 1 bottle of beer.\n" +
-            "Take it down and pass it around, no more bottles of beer on the wall.\n" +
-            "";
-        Assert.Equal(expected, BeerSong.Verse(1));
+            "Take it down and pass it around, no more bottles of beer on the wall.";
+        Assert.Equal(expected, BeerSong.Recite(1, 1));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Verse_0()
+    public void Verse_with_0_bottles()
     {
         var expected = 
             "No more bottles of beer on the wall, no more bottles of beer.\n" +
-            "Go to the store and buy some more, 99 bottles of beer on the wall.\n" +
-            "";
-        Assert.Equal(expected, BeerSong.Verse(0));
+            "Go to the store and buy some more, 99 bottles of beer on the wall.";
+        Assert.Equal(expected, BeerSong.Recite(0, 1));
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -62,9 +57,8 @@ public void First_two_verses()
             "Take one down and pass it around, 98 bottles of beer on the wall.\n" +
             "\n" +
             "98 bottles of beer on the wall, 98 bottles of beer.\n" +
-            "Take one down and pass it around, 97 bottles of beer on the wall.\n" +
-            "";
-        Assert.Equal(expected, BeerSong.Verses(99, 98));
+            "Take one down and pass it around, 97 bottles of beer on the wall.";
+        Assert.Equal(expected, BeerSong.Recite(99, 2));
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -78,9 +72,8 @@ public void Last_three_verses()
             "Take it down and pass it around, no more bottles of beer on the wall.\n" +
             "\n" +
             "No more bottles of beer on the wall, no more bottles of beer.\n" +
-            "Go to the store and buy some more, 99 bottles of beer on the wall.\n" +
-            "";
-        Assert.Equal(expected, BeerSong.Verses(2, 0));
+            "Go to the store and buy some more, 99 bottles of beer on the wall.";
+        Assert.Equal(expected, BeerSong.Recite(2, 3));
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -385,8 +378,7 @@ public void All_verses()
             "Take it down and pass it around, no more bottles of beer on the wall.\n" +
             "\n" +
             "No more bottles of beer on the wall, no more bottles of beer.\n" +
-            "Go to the store and buy some more, 99 bottles of beer on the wall.\n" +
-            "";
-        Assert.Equal(expected, BeerSong.Verses(99, 0));
+            "Go to the store and buy some more, 99 bottles of beer on the wall.";
+        Assert.Equal(expected, BeerSong.Recite(99, 100));
     }
 }

data/tracks/csharp/exercises/beer-song/Example.cs

@@ -7,16 +7,16 @@ public static string Verse(int number)
         switch (number)
         {
             case 0:
-                return "No more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall.\n";
+                return "No more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall.";
             case 1:
-                return "1 bottle of beer on the wall, 1 bottle of beer.\nTake it down and pass it around, no more bottles of beer on the wall.\n";
+                return "1 bottle of beer on the wall, 1 bottle of beer.\nTake it down and pass it around, no more bottles of beer on the wall.";
             case 2:
-                return "2 bottles of beer on the wall, 2 bottles of beer.\nTake one down and pass it around, 1 bottle of beer on the wall.\n";
+                return "2 bottles of beer on the wall, 2 bottles of beer.\nTake one down and pass it around, 1 bottle of beer on the wall.";
             default:
-                return string.Format("{0} bottles of beer on the wall, {0} bottles of beer.\nTake one down and pass it around, {1} bottles of beer on the wall.\n", number, number - 1);
+                return string.Format("{0} bottles of beer on the wall, {0} bottles of beer.\nTake one down and pass it around, {1} bottles of beer on the wall.", number, number - 1);
         }
     }
 
-    public static string Verses(int begin, int end)
-        => string.Join("\n", Enumerable.Range(end, begin - end + 1).Reverse().Select(Verse));
+    public static string Recite(int startBottles, int takeDown)
+        => string.Join("\n\n", Enumerable.Range(startBottles - takeDown + 1, takeDown).Reverse().Select(Verse));
 }

data/tracks/csharp/exercises/binary-search/BinarySearchTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 using Xunit;
 

data/tracks/csharp/exercises/bob/BobTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.1.0 of the canonical data.
+// This file was auto-generated based on version 1.2.0 of the canonical data.
 
 using Xunit;
 

data/tracks/csharp/exercises/book-store/BookStoreTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.1.0 of the canonical data.
+// This file was auto-generated based on version 1.3.0 of the canonical data.
 
 using Xunit;
 

data/tracks/csharp/exercises/bowling/BowlingTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.1 of the canonical data.
+// This file was auto-generated based on version 1.2.0 of the canonical data.
 
 using Xunit;
 using System;
@@ -10,7 +10,7 @@ public class BowlingTest
     public void Should_be_able_to_score_a_game_with_all_zeros()
     {
         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, 0, 0};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(0, actual);
@@ -20,7 +20,7 @@ public void Should_be_able_to_score_a_game_with_all_zeros()
     public void Should_be_able_to_score_a_game_with_no_strikes_or_spares()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6};
+        var previousRolls = new [] { 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(90, actual);
@@ -30,7 +30,7 @@ public void Should_be_able_to_score_a_game_with_no_strikes_or_spares()
     public void A_spare_followed_by_zeros_is_worth_ten_points()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+        var previousRolls = new [] { 6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(10, actual);
@@ -40,7 +40,7 @@ public void A_spare_followed_by_zeros_is_worth_ten_points()
     public void Points_scored_in_the_roll_after_a_spare_are_counted_twice()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+        var previousRolls = new [] { 6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(16, actual);
@@ -50,7 +50,7 @@ public void Points_scored_in_the_roll_after_a_spare_are_counted_twice()
     public void Consecutive_spares_each_get_a_one_roll_bonus()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+        var previousRolls = new [] { 5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(31, actual);
@@ -60,7 +60,7 @@ public void Consecutive_spares_each_get_a_one_roll_bonus()
     public void A_spare_in_the_last_frame_gets_a_one_roll_bonus_that_is_counted_once()
     {
         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, 7, 3, 7};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(17, actual);
@@ -70,7 +70,7 @@ public void A_spare_in_the_last_frame_gets_a_one_roll_bonus_that_is_counted_once
     public void A_strike_earns_ten_points_in_a_frame_with_a_single_roll()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+        var previousRolls = new [] { 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(10, actual);
@@ -80,7 +80,7 @@ public void A_strike_earns_ten_points_in_a_frame_with_a_single_roll()
     public void Points_scored_in_the_two_rolls_after_a_strike_are_counted_twice_as_a_bonus()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+        var previousRolls = new [] { 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(26, actual);
@@ -90,7 +90,7 @@ public void Points_scored_in_the_two_rolls_after_a_strike_are_counted_twice_as_a
     public void Consecutive_strikes_each_get_the_two_roll_bonus()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+        var previousRolls = new [] { 10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(81, actual);
@@ -100,7 +100,7 @@ public void Consecutive_strikes_each_get_the_two_roll_bonus()
     public void A_strike_in_the_last_frame_gets_a_two_roll_bonus_that_is_counted_once()
     {
         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, 7, 1};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(18, actual);
@@ -110,7 +110,7 @@ public void A_strike_in_the_last_frame_gets_a_two_roll_bonus_that_is_counted_onc
     public void Rolling_a_spare_with_the_two_roll_bonus_does_not_get_a_bonus_roll()
     {
         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, 7, 3};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(20, actual);
@@ -120,7 +120,7 @@ public void Rolling_a_spare_with_the_two_roll_bonus_does_not_get_a_bonus_roll()
     public void Strikes_with_the_two_roll_bonus_do_not_get_bonus_rolls()
     {
         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, 10, 10};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(30, actual);
@@ -130,7 +130,7 @@ public void Strikes_with_the_two_roll_bonus_do_not_get_bonus_rolls()
     public void A_strike_with_the_one_roll_bonus_after_a_spare_in_the_last_frame_does_not_get_a_bonus()
     {
         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, 7, 3, 10};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(20, actual);
@@ -140,7 +140,7 @@ public void A_strike_with_the_one_roll_bonus_after_a_spare_in_the_last_frame_doe
     public void All_strikes_is_a_perfect_game()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+        var previousRolls = new [] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(300, actual);
@@ -150,7 +150,7 @@ public void All_strikes_is_a_perfect_game()
     public void Rolls_cannot_score_negative_points()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {};
+        var previousRolls = new int[0];
         DoRoll(previousRolls, sut);
         Assert.Throws<ArgumentException>(() => sut.Roll(-1));
     }
@@ -159,7 +159,7 @@ public void Rolls_cannot_score_negative_points()
     public void A_roll_cannot_score_more_than_10_points()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {};
+        var previousRolls = new int[0];
         DoRoll(previousRolls, sut);
         Assert.Throws<ArgumentException>(() => sut.Roll(11));
     }
@@ -168,7 +168,7 @@ public void A_roll_cannot_score_more_than_10_points()
     public void Two_rolls_in_a_frame_cannot_score_more_than_10_points()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {5};
+        var previousRolls = new [] { 5 };
         DoRoll(previousRolls, sut);
         Assert.Throws<ArgumentException>(() => sut.Roll(6));
     }
@@ -177,7 +177,7 @@ public void Two_rolls_in_a_frame_cannot_score_more_than_10_points()
     public void Bonus_roll_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points()
     {
         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};
+        var previousRolls = new [] { 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));
     }
@@ -186,7 +186,7 @@ public void Bonus_roll_after_a_strike_in_the_last_frame_cannot_score_more_than_1
     public void Two_bonus_rolls_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points()
     {
         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, 5};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5 };
         DoRoll(previousRolls, sut);
         Assert.Throws<ArgumentException>(() => sut.Roll(6));
     }
@@ -195,7 +195,7 @@ public void Two_bonus_rolls_after_a_strike_in_the_last_frame_cannot_score_more_t
     public void Two_bonus_rolls_after_a_strike_in_the_last_frame_can_score_more_than_10_points_if_one_is_a_strike()
     {
         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, 10, 6};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6 };
         DoRoll(previousRolls, sut);
         var actual = sut.Score();
         Assert.Equal(26, actual);
@@ -205,7 +205,7 @@ public void Two_bonus_rolls_after_a_strike_in_the_last_frame_can_score_more_than
     public void The_second_bonus_rolls_after_a_strike_in_the_last_frame_cannot_be_a_strike_if_the_first_one_is_not_a_strike()
     {
         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, 6};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6 };
         DoRoll(previousRolls, sut);
         Assert.Throws<ArgumentException>(() => sut.Roll(10));
     }
@@ -214,7 +214,7 @@ public void The_second_bonus_rolls_after_a_strike_in_the_last_frame_cannot_be_a_
     public void Second_bonus_roll_after_a_strike_in_the_last_frame_cannot_score_more_than_10_points()
     {
         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, 10};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10 };
         DoRoll(previousRolls, sut);
         Assert.Throws<ArgumentException>(() => sut.Roll(11));
     }
@@ -223,7 +223,7 @@ public void Second_bonus_roll_after_a_strike_in_the_last_frame_cannot_score_more
     public void An_unstarted_game_cannot_be_scored()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {};
+        var previousRolls = new int[0];
         DoRoll(previousRolls, sut);
         Assert.Throws<ArgumentException>(() => sut.Score());
     }
@@ -232,7 +232,7 @@ public void An_unstarted_game_cannot_be_scored()
     public void An_incomplete_game_cannot_be_scored()
     {
         var sut = new BowlingGame();
-        var previousRolls = new int[] {0, 0};
+        var previousRolls = new [] { 0, 0 };
         DoRoll(previousRolls, sut);
         Assert.Throws<ArgumentException>(() => sut.Score());
     }
@@ -241,7 +241,7 @@ public void An_incomplete_game_cannot_be_scored()
     public void Cannot_roll_if_game_already_has_ten_frames()
     {
         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, 0, 0};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
         DoRoll(previousRolls, sut);
         Assert.Throws<ArgumentException>(() => sut.Roll(0));
     }
@@ -250,7 +250,7 @@ public void Cannot_roll_if_game_already_has_ten_frames()
     public void Bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated()
     {
         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};
+        var previousRolls = new [] { 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.Score());
     }
@@ -259,7 +259,7 @@ public void Bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_sco
     public void Both_bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_before_score_can_be_calculated()
     {
         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, 10};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10 };
         DoRoll(previousRolls, sut);
         Assert.Throws<ArgumentException>(() => sut.Score());
     }
@@ -268,11 +268,29 @@ public void Both_bonus_rolls_for_a_strike_in_the_last_frame_must_be_rolled_befor
     public void Bonus_roll_for_a_spare_in_the_last_frame_must_be_rolled_before_score_can_be_calculated()
     {
         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, 7, 3};
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3 };
         DoRoll(previousRolls, sut);
         Assert.Throws<ArgumentException>(() => sut.Score());
     }
 
+    [Fact(Skip = "Remove to run test")]
+    public void Cannot_roll_after_bonus_roll_for_spare()
+    {
+        var sut = new BowlingGame();
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 2 };
+        DoRoll(previousRolls, sut);
+        Assert.Throws<ArgumentException>(() => sut.Roll(2));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Cannot_roll_after_bonus_rolls_for_strike()
+    {
+        var sut = new BowlingGame();
+        var previousRolls = new [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 3, 2 };
+        DoRoll(previousRolls, sut);
+        Assert.Throws<ArgumentException>(() => sut.Roll(2));
+    }
+
     public void DoRoll(ICollection<int> rolls, BowlingGame sut)
     {
         foreach (var roll in rolls)

data/tracks/csharp/exercises/bracket-push/BracketPushTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.1.0 of the canonical data.
+// This file was auto-generated based on version 1.3.0 of the canonical data.
 
 using Xunit;
 
@@ -7,98 +7,105 @@ public class BracketPushTest
     [Fact]
     public void Paired_square_brackets()
     {
-        var input = "[]";
-        Assert.True(BracketPush.IsPaired(input));
+        var value = "[]";
+        Assert.True(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Empty_string()
     {
-        var input = "";
-        Assert.True(BracketPush.IsPaired(input));
+        var value = "";
+        Assert.True(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Unpaired_brackets()
     {
-        var input = "[[";
-        Assert.False(BracketPush.IsPaired(input));
+        var value = "[[";
+        Assert.False(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Wrong_ordered_brackets()
     {
-        var input = "}{";
-        Assert.False(BracketPush.IsPaired(input));
+        var value = "}{";
+        Assert.False(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Wrong_closing_bracket()
     {
-        var input = "{]";
-        Assert.False(BracketPush.IsPaired(input));
+        var value = "{]";
+        Assert.False(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Paired_with_whitespace()
     {
-        var input = "{ }";
-        Assert.True(BracketPush.IsPaired(input));
+        var value = "{ }";
+        Assert.True(BracketPush.IsPaired(value));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Partially_paired_brackets()
+    {
+        var value = "{[])";
+        Assert.False(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Simple_nested_brackets()
     {
-        var input = "{[]}";
-        Assert.True(BracketPush.IsPaired(input));
+        var value = "{[]}";
+        Assert.True(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Several_paired_brackets()
     {
-        var input = "{}[]";
-        Assert.True(BracketPush.IsPaired(input));
+        var value = "{}[]";
+        Assert.True(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Paired_and_nested_brackets()
     {
-        var input = "([{}({}[])])";
-        Assert.True(BracketPush.IsPaired(input));
+        var value = "([{}({}[])])";
+        Assert.True(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Unopened_closing_brackets()
     {
-        var input = "{[)][]}";
-        Assert.False(BracketPush.IsPaired(input));
+        var value = "{[)][]}";
+        Assert.False(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Unpaired_and_nested_brackets()
     {
-        var input = "([{])";
-        Assert.False(BracketPush.IsPaired(input));
+        var value = "([{])";
+        Assert.False(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Paired_and_wrong_nested_brackets()
     {
-        var input = "[({]})";
-        Assert.False(BracketPush.IsPaired(input));
+        var value = "[({]})";
+        Assert.False(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Math_expression()
     {
-        var input = "(((185 + 223.85) * 15) - 543)/2";
-        Assert.True(BracketPush.IsPaired(input));
+        var value = "(((185 + 223.85) * 15) - 543)/2";
+        Assert.True(BracketPush.IsPaired(value));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Complex_latex_expression()
     {
-        var input = "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)";
-        Assert.True(BracketPush.IsPaired(input));
+        var value = "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)";
+        Assert.True(BracketPush.IsPaired(value));
     }
 }