trackler 2.2.1.27 → 2.2.1.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eba2a1d8fc60987a49bd6540cf30c56d898dfe20
-  data.tar.gz: 2069c1589727e3589cecae15f17e43a754775bd2
+  metadata.gz: c3a805b6e7e811932f76b9d6546d5aed224b27fe
+  data.tar.gz: f782c09ccca7e40a7beaa87d7519b7646046f29b
 SHA512:
-  metadata.gz: f2f016ddebdcd29c9fb0ae96a094ce764608fb8ccc6606ee11f4ddaef15ba301db50f66376546e2d9943a834a91365843afdf858221a917a79c7a69569d7f29d
-  data.tar.gz: 56edea83d76ba56b4761b77a6a506b485d9582ae2ca9e3ea800f766b551561d0d3b2e09d345a8ea791a81bfa1587ac46c8006c386725c0a717f94225d2cfe09e
+  metadata.gz: c09dd81f75ca8b03185a1cb660ecf868d71fa3cba133f530a7893ef7928c110e0e119584d4c652d1b39b35bf934bb5139f3419d81284fb8f79d5ec96d6d17e4c
+  data.tar.gz: 351bf0b1cc22a89c2e1e72d784f60f58271f248aed4e5e97ee926db9e457ae45037bcca81dcca81322b6dd83f5823dcd61bf7f5027e84921c26d1ed22b825a64

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.27"
+  VERSION = "2.2.1.28"
 end

data/problem-specifications/exercises/palindrome-products/canonical-data.json

@@ -0,0 +1,138 @@
+{
+    "exercise": "palindrome-products",
+    "version": "1.0.0",
+    "cases": [{
+            "description": "finds the smallest palindrome from single digit factors",
+            "property": "smallest",
+            "input_min": 1,
+            "input_max": 9,
+            "expected": {
+                "value": 1,
+                "factors": [
+                    [1, 1]
+                ]
+            }
+        },
+        {
+            "description": "finds the largest palindrome from single digit factors",
+            "property": "largest",
+            "input_min": 1,
+            "input_max": 9,
+            "expected": {
+                "value": 9,
+                "factors": [
+                    [1, 9],
+                    [3, 3]
+                ]
+            }
+        },
+        {
+            "description": "find the smallest palindrome from double digit factors",
+            "property": "smallest",
+            "input_min": 10,
+            "input_max": 99,
+            "expected": {
+                "value": 121,
+                "factors": [
+                    [11, 11]
+                ]
+            }
+        },
+        {
+            "description": "find the largest palindrome from double digit factors",
+            "property": "largest",
+            "input_min": 10,
+            "input_max": 99,
+            "expected": {
+                "value": 9009,
+                "factors": [
+                    [91, 99]
+                ]
+            }
+        },
+        {
+            "description": "find smallest palindrome from triple digit factors",
+            "property": "smallest",
+            "input_min": 100,
+            "input_max": 999,
+            "expected": {
+                "value": 10201,
+                "factors": [
+                    [101, 101]
+                ]
+            }
+        },
+        {
+            "description": "find the largest palindrome from triple digit factors",
+            "property": "largest",
+            "input_min": 100,
+            "input_max": 999,
+            "expected": {
+                "value": 906609,
+                "factors": [
+                    [913, 993]
+                ]
+            }
+        },
+        {
+            "description": "find smallest palindrome from four digit factors",
+            "property": "smallest",
+            "input_min": 1000,
+            "input_max": 9999,
+            "expected": {
+                "value": 1002001,
+                "factors": [
+                    [1001, 1001]
+                ]
+            }
+        },
+        {
+            "description": "find the largest palindrome from four digit factors",
+            "property": "largest",
+            "input_min": 1000,
+            "input_max": 9999,
+            "expected": {
+                "value": 99000099,
+                "factors": [
+                    [9901, 9999]
+                ]
+            }
+        },
+        {
+            "description": "empty result for smallest if no palindrome in the range",
+            "property": "smallest",
+            "input_min": 1002,
+            "input_max": 1003,
+            "expected": {
+                "error": "no palindrome with factors in the range 1002 to 1003"
+            }
+        },
+        {
+            "description": "empty result for largest if no palindrome in the range",
+            "property": "largest",
+            "input_min": 15,
+            "input_max": 15,
+            "expected": {
+                "error": "no palindrome with factors in the range 15 to 15"
+            }
+        },
+        {
+            "description": "error result for smallest if min is more than max",
+            "property": "smallest",
+            "input_min": 10000,
+            "input_max": 1,
+            "expected": {
+                "error": "invalid input: min is 10000 and max is 1"
+            }
+        },
+        {
+            "description": "error result for largest if min is more than max",
+            "property": "largest",
+            "input_min": 2,
+            "input_max": 1,
+            "expected": {
+                "error": "invalid input: min is 2 and max is 1"
+            }
+        }
+    ]
+}

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

@@ -7,91 +7,91 @@ public class BookStoreTest
     [Fact]
     public void Only_a_single_book()
     {
-        var input = new[] { 1 };
-        Assert.Equal(8, BookStore.Total(input));
+        var basket = new[] { 1 };
+        Assert.Equal(8, BookStore.Total(basket));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Two_of_the_same_book()
     {
-        var input = new[] { 2, 2 };
-        Assert.Equal(16, BookStore.Total(input));
+        var basket = new[] { 2, 2 };
+        Assert.Equal(16, BookStore.Total(basket));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Empty_basket()
     {
-        var input = new int[0];
-        Assert.Equal(0, BookStore.Total(input));
+        var basket = new int[0];
+        Assert.Equal(0, BookStore.Total(basket));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Two_different_books()
     {
-        var input = new[] { 1, 2 };
-        Assert.Equal(15.2, BookStore.Total(input));
+        var basket = new[] { 1, 2 };
+        Assert.Equal(15.2, BookStore.Total(basket));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Three_different_books()
     {
-        var input = new[] { 1, 2, 3 };
-        Assert.Equal(21.6, BookStore.Total(input));
+        var basket = new[] { 1, 2, 3 };
+        Assert.Equal(21.6, BookStore.Total(basket));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Four_different_books()
     {
-        var input = new[] { 1, 2, 3, 4 };
-        Assert.Equal(25.6, BookStore.Total(input));
+        var basket = new[] { 1, 2, 3, 4 };
+        Assert.Equal(25.6, BookStore.Total(basket));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Five_different_books()
     {
-        var input = new[] { 1, 2, 3, 4, 5 };
-        Assert.Equal(30, BookStore.Total(input));
+        var basket = new[] { 1, 2, 3, 4, 5 };
+        Assert.Equal(30, BookStore.Total(basket));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Two_groups_of_four_is_cheaper_than_group_of_five_plus_group_of_three()
     {
-        var input = new[] { 1, 1, 2, 2, 3, 3, 4, 5 };
-        Assert.Equal(51.2, BookStore.Total(input));
+        var basket = new[] { 1, 1, 2, 2, 3, 3, 4, 5 };
+        Assert.Equal(51.2, BookStore.Total(basket));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Group_of_four_plus_group_of_two_is_cheaper_than_two_groups_of_three()
     {
-        var input = new[] { 1, 1, 2, 2, 3, 4 };
-        Assert.Equal(40.8, BookStore.Total(input));
+        var basket = new[] { 1, 1, 2, 2, 3, 4 };
+        Assert.Equal(40.8, BookStore.Total(basket));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Two_each_of_first_4_books_and_1_copy_each_of_rest()
     {
-        var input = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5 };
-        Assert.Equal(55.6, BookStore.Total(input));
+        var basket = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5 };
+        Assert.Equal(55.6, BookStore.Total(basket));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Two_copies_of_each_book()
     {
-        var input = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5 };
-        Assert.Equal(60, BookStore.Total(input));
+        var basket = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5 };
+        Assert.Equal(60, BookStore.Total(basket));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Three_copies_of_first_book_and_2_each_of_remaining()
     {
-        var input = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1 };
-        Assert.Equal(68, BookStore.Total(input));
+        var basket = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1 };
+        Assert.Equal(68, BookStore.Total(basket));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Three_each_of_first_2_books_and_2_each_of_remaining_books()
     {
-        var input = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2 };
-        Assert.Equal(75.2, BookStore.Total(input));
+        var basket = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2 };
+        Assert.Equal(75.2, BookStore.Total(basket));
     }
 }

data/tracks/csharp/exercises/complex-numbers/ComplexNumbersTest.cs

@@ -52,8 +52,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(0, 1);
         var expected = new ComplexNumber(-1, 0);
-        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 1)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 1)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 1)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 1)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -61,8 +61,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(1, 0);
         var expected = new ComplexNumber(3, 0);
-        Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(2, 0)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(2, 0)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(2, 0)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(2, 0)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -70,8 +70,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(0, 1);
         var expected = new ComplexNumber(0, 3);
-        Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(0, 2)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(0, 2)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(0, 2)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(0, 2)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -79,8 +79,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(1, 2);
         var expected = new ComplexNumber(4, 6);
-        Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(3, 4)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(3, 4)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(3, 4)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(3, 4)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -88,8 +88,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(1, 0);
         var expected = new ComplexNumber(-1, 0);
-        Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(2, 0)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(2, 0)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(2, 0)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(2, 0)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -97,8 +97,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(0, 1);
         var expected = new ComplexNumber(0, -1);
-        Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(0, 2)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(0, 2)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(0, 2)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(0, 2)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -106,8 +106,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(1, 2);
         var expected = new ComplexNumber(-2, -2);
-        Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(3, 4)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(3, 4)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(3, 4)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(3, 4)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -115,8 +115,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(1, 0);
         var expected = new ComplexNumber(2, 0);
-        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(2, 0)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(2, 0)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(2, 0)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(2, 0)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -124,8 +124,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(0, 1);
         var expected = new ComplexNumber(-2, 0);
-        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 2)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 2)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 2)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 2)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -133,8 +133,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(1, 2);
         var expected = new ComplexNumber(-5, 10);
-        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(3, 4)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(3, 4)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(3, 4)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(3, 4)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -142,8 +142,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(1, 0);
         var expected = new ComplexNumber(0.5, 0);
-        Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(2, 0)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(2, 0)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(2, 0)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(2, 0)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -151,8 +151,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(0, 1);
         var expected = new ComplexNumber(0.5, 0);
-        Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(0, 2)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(0, 2)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(0, 2)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(0, 2)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -160,8 +160,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(1, 2);
         var expected = new ComplexNumber(0.44, 0.08);
-        Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(3, 4)).Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(3, 4)).Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(3, 4)).Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(3, 4)).Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -204,8 +204,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(5, 0);
         var expected = new ComplexNumber(5, 0);
-        Assert.Equal(expected.Real(), sut.Conjugate().Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Conjugate().Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -213,8 +213,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(0, 5);
         var expected = new ComplexNumber(0, -5);
-        Assert.Equal(expected.Real(), sut.Conjugate().Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Conjugate().Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -222,8 +222,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(1, 1);
         var expected = new ComplexNumber(1, -1);
-        Assert.Equal(expected.Real(), sut.Conjugate().Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Conjugate().Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -231,8 +231,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(0, Math.PI);
         var expected = new ComplexNumber(-1, 0);
-        Assert.Equal(expected.Real(), sut.Exp().Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Exp().Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -240,8 +240,8 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(0, 0);
         var expected = new ComplexNumber(1, 0);
-        Assert.Equal(expected.Real(), sut.Exp().Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Exp().Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), precision: 15);
     }
 
     [Fact(Skip = "Remove to run test")]
@@ -249,7 +249,7 @@ public class ComplexNumbersTest
     {
         var sut = new ComplexNumber(1, 0);
         var expected = new ComplexNumber(Math.E, 0);
-        Assert.Equal(expected.Real(), sut.Exp().Real(), 15);
-        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), 15);
+        Assert.Equal(expected.Real(), sut.Exp().Real(), precision: 15);
+        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), precision: 15);
     }
 }

data/tracks/csharp/generators/Exercises/AllYourBase.cs

@@ -9,8 +9,6 @@ namespace Generators.Exercises
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
-                canonicalDataCase.Input["input_digits"] = canonicalDataCase.Input["input_digits"].ConvertToEnumerable<int>();
-
                 canonicalDataCase.ExceptionThrown = canonicalDataCase.Expected is null ? typeof(ArgumentException) : null;
                 canonicalDataCase.UseVariablesForInput = true;
                 canonicalDataCase.UseVariableForExpected = true;

data/tracks/csharp/generators/Exercises/Allergies.cs

@@ -1,8 +1,5 @@
-using System.Collections.Generic;
-using System.Linq;
-using Generators.Input;
+using Generators.Input;
 using Generators.Output;
-using Newtonsoft.Json.Linq;
 
 namespace Generators.Exercises
 {
@@ -13,19 +10,11 @@ namespace Generators.Exercises
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
                 if (canonicalDataCase.Property == "allergicTo")
-                {
                     canonicalDataCase.Property = "IsAllergicTo";
-                }
                 else if (canonicalDataCase.Property == "list")
-                { 
-                    canonicalDataCase.Expected = canonicalDataCase.Expected.ConvertToEnumerable<string>();
                     canonicalDataCase.UseVariableForExpected = true;
-                }
 
-                canonicalDataCase.ConstructorInput = new Dictionary<string, object>
-                {
-                    ["score"] = canonicalDataCase.Properties["score"]
-                };
+                canonicalDataCase.SetConstructorInputParameters("score");
             }
         }
 
@@ -41,17 +30,10 @@ namespace Generators.Exercises
         {
             const string template =
                 @"{%- for allergy in Allergies -%}
-Assert.{% if allergy.Result %}True{% else %}False{% endif %}(sut.IsAllergicTo(""{{ allergy.Substance }}""));
+Assert.{% if allergy.result %}True{% else %}False{% endif %}(sut.IsAllergicTo(""{{ allergy.substance }}""));
 {%- endfor -%}";
-
-            var templateParameters = new
-            {
-                Allergies = ((JArray) testMethodBody.CanonicalDataCase.Expected)
-                .Children<JObject>()
-                .Select(x => new {Result = x["result"].Value<bool>(), Substance = x["substance"].Value<string>()})
-                .ToArray()
-            };
-
+            
+            var templateParameters = new { Allergies = testMethodBody.CanonicalDataCase.Expected };
             return TemplateRenderer.RenderInline(template, templateParameters);
         }
     }

data/tracks/csharp/generators/Exercises/Alphametics.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Generators.Input;
-using Newtonsoft.Json.Linq;
 
 namespace Generators.Exercises
 {
@@ -17,16 +17,13 @@ namespace Generators.Exercises
                 if (canonicalDataCase.Expected == null)
                     canonicalDataCase.ExceptionThrown = typeof(ArgumentException);
                 else
-                    canonicalDataCase.Expected = ((JObject)canonicalDataCase.Expected).ToObject<Dictionary<char, int>>();
+                    canonicalDataCase.Expected = ConvertExpected(canonicalDataCase);
             }
         }
 
-        protected override HashSet<string> AddAdditionalNamespaces()
-        {
-            return new HashSet<string>()
-            {
-                typeof(Dictionary<char, int>).Namespace
-            };
-        }
+        private static dynamic ConvertExpected(CanonicalDataCase canonicalDataCase) 
+            => ((Dictionary<string, object>)canonicalDataCase.Expected).ToDictionary(kv => kv.Key[0], kv => int.Parse(kv.Value.ToString()));
+
+        protected override HashSet<string> AddAdditionalNamespaces() => new HashSet<string> { typeof(Dictionary<char, int>).Namespace };
     }
 }

data/tracks/csharp/generators/Exercises/Anagram.cs

@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using Generators.Input;
 
 namespace Generators.Exercises
@@ -9,15 +8,9 @@ namespace Generators.Exercises
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
-                canonicalDataCase.ConstructorInput = new Dictionary<string, object>
-                {
-                    ["subject"] = canonicalDataCase.Input["subject"]
-                };
-                canonicalDataCase.Input["candidates"] = canonicalDataCase.Input["candidates"].ConvertToEnumerable<string>();
-                canonicalDataCase.Expected = canonicalDataCase.Expected.ConvertToEnumerable<string>();
-
                 canonicalDataCase.UseVariablesForInput = true;
                 canonicalDataCase.UseVariableForExpected = true;
+                canonicalDataCase.SetConstructorInputParameters("subject");
             }
         }
     }

data/tracks/csharp/generators/Exercises/BinarySearch.cs

@@ -1,5 +1,4 @@
-using System.Collections.Generic;
-using Generators.Input;
+using Generators.Input;
 
 namespace Generators.Exercises
 {
@@ -9,12 +8,8 @@ namespace Generators.Exercises
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
-                canonicalDataCase.ConstructorInput = new Dictionary<string, object>
-                {
-                    ["array"] = canonicalDataCase.Input["array"].ConvertToEnumerable<int>()
-                };
-
                 canonicalDataCase.UseVariablesForConstructorParameters = true;
+                canonicalDataCase.SetConstructorInputParameters("array");
             }
         }
     }

data/tracks/csharp/generators/Exercises/BookStore.cs

@@ -1,5 +1,4 @@
-using System.Collections.Generic;
-using Generators.Input;
+using Generators.Input;
 
 namespace Generators.Exercises
 {
@@ -9,10 +8,7 @@ namespace Generators.Exercises
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
-                canonicalDataCase.Input = new Dictionary<string, object>
-                {
-                    ["input"] = canonicalDataCase.Input["basket"].ConvertToEnumerable<int>()
-                };
+                canonicalDataCase.SetInputParameters("basket");
                 canonicalDataCase.UseVariablesForInput = true;
             }
         }

data/tracks/csharp/generators/Exercises/BracketPush.cs

@@ -8,7 +8,7 @@ namespace Generators.Exercises
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
-                canonicalDataCase.Input["input"] = ((string)canonicalDataCase.Input["input"]).Replace("\\", "\\\\");
+                canonicalDataCase.Properties["input"] = canonicalDataCase.Properties["input"].Replace("\\", "\\\\");
                 canonicalDataCase.UseVariablesForInput = true;
             }
         }

data/tracks/csharp/generators/Exercises/CollatzConjecture.cs

@@ -8,9 +8,7 @@ namespace Generators.Exercises
         protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
-            {
-                canonicalDataCase.ExceptionThrown = (long)canonicalDataCase.Input["number"] <= 0 ? typeof(ArgumentException) : null;
-            }
+                canonicalDataCase.ExceptionThrown = canonicalDataCase.Input["number"] <= 0 ? typeof(ArgumentException) : null;
         }
     }
 }