trackler 2.2.1.151 → 2.2.1.152

data/tracks/csharp/exercises/yacht/YachtTest.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;
 
@@ -82,6 +82,12 @@ public void Two_pair_is_not_a_full_house()
         Assert.Equal(0, YachtGame.Score(new[] { 2, 2, 4, 4, 5 }, YachtCategory.FullHouse));
     }
 
+    [Fact(Skip = "Remove to run test")]
+    public void Four_of_a_kind_is_not_a_full_house()
+    {
+        Assert.Equal(0, YachtGame.Score(new[] { 1, 4, 4, 4, 4 }, YachtCategory.FullHouse));
+    }
+
     [Fact(Skip = "Remove to run test")]
     public void Yacht_is_not_a_full_house()
     {

data/tracks/csharp/exercises/zebra-puzzle/Example.cs

@@ -96,16 +96,16 @@ private static bool MatchesSmokeRules(Color[] colors, Nationality[] nationalitie
     
     private static Solution Solve() => Solutions().First();
     
-    public static Nationality WhoDrinks(Drink drink)
+    public static Nationality DrinksWater()
     {
         var solution = Solve();
-        return solution.Nationalities[Array.IndexOf(solution.Drinks, drink)];
+        return solution.Nationalities[Array.IndexOf(solution.Drinks, Drink.Water)];
     }
 
-    public static Nationality WhoOwns(Pet pet)
+    public static Nationality OwnsZebra()
     {
         var solution = Solve();
-        return solution.Nationalities[Array.IndexOf(solution.Pets, pet)];
+        return solution.Nationalities[Array.IndexOf(solution.Pets, Pet.Zebra)];
     }
 
     private static bool IsIndexMatch<T1, T2>(T1[] values1, T1 value1, T2[] values2, T2 value2) => values2[Array.IndexOf(values1, value1)].Equals(value2);

data/tracks/csharp/exercises/zebra-puzzle/ZebraPuzzle.cs

@@ -10,12 +10,12 @@ public enum Smoke { OldGold , Kools , Chesterfields , LuckyStrike , Parliaments
 
 public static class ZebraPuzzle
 {
-    public static Nationality WhoDrinks(Drink drink)
+    public static Nationality DrinksWater()
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public static Nationality WhoOwns(Pet pet)
+    public static Nationality OwnsZebra()
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/zebra-puzzle/ZebraPuzzleTest.cs

@@ -1,16 +1,18 @@
-using Xunit;
+// This file was auto-generated based on version 1.1.0 of the canonical data.
+
+using Xunit;
 
 public class ZebraPuzzleTest
 {
     [Fact]
-    public void Who_drinks_water()
+    public void Resident_who_drinks_water()
     {
-        Assert.Equal(Nationality.Norwegian, ZebraPuzzle.WhoDrinks(Drink.Water));
+        Assert.Equal(Nationality.Norwegian, ZebraPuzzle.DrinksWater());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Who_owns_the_zebra()
+    public void Resident_who_owns_zebra()
     {
-        Assert.Equal(Nationality.Japanese, ZebraPuzzle.WhoOwns(Pet.Zebra));
+        Assert.Equal(Nationality.Japanese, ZebraPuzzle.OwnsZebra());
     }
 }

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

@@ -10,6 +10,7 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
+                canonicalDataCase.Input["digits"] = ConvertHelper.ToArray<int>(canonicalDataCase.Input["digits"]);
                 canonicalDataCase.ExceptionThrown = canonicalDataCase.Expected is Dictionary<string, object> ? typeof(ArgumentException) : null;
                 canonicalDataCase.UseVariablesForInput = true;
                 canonicalDataCase.UseVariableForExpected = true;

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

@@ -21,8 +21,11 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
             }
         }
 
-        private static dynamic ConvertExpected(CanonicalDataCase canonicalDataCase) 
-            => ((Dictionary<string, object>)canonicalDataCase.Expected).ToDictionary(kv => kv.Key[0], kv => int.Parse(kv.Value.ToString()));
+        private static dynamic ConvertExpected(CanonicalDataCase canonicalDataCase)
+        {
+            Dictionary<string, object> expected = canonicalDataCase.Expected;
+            return 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/BeerSong.cs

@@ -7,7 +7,10 @@ public class BeerSong : GeneratorExercise
         protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
+            {
                 canonicalDataCase.UseVariableForExpected = true;
+                canonicalDataCase.Expected = ConvertHelper.ToMultiLineString(canonicalDataCase.Expected);
+            }
         }
     }
 }

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

@@ -8,6 +8,7 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
+                canonicalDataCase.Input["array"] = ConvertHelper.ToArray<int>(canonicalDataCase.Input["array"]);
                 canonicalDataCase.UseVariablesForConstructorParameters = true;
                 canonicalDataCase.SetConstructorInputParameters("array");
             }

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

@@ -8,6 +8,8 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
+                canonicalDataCase.Expected = canonicalDataCase.Expected / 100.0f;
+                canonicalDataCase.Input["basket"] = ConvertHelper.ToArray<int>(canonicalDataCase.Input["basket"]);
                 canonicalDataCase.SetInputParameters("basket");
                 canonicalDataCase.UseVariablesForInput = true;
             }

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

@@ -8,17 +8,17 @@ namespace Generators.Exercises
 {
     public class Bowling : GeneratorExercise
     {
-        private const string PreviousRolls = "previous_rolls";
+        private const string PreviousRolls = "previousRolls";
 
         protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
-                if(!(canonicalDataCase.Expected is long))
+                if (!(canonicalDataCase.Expected is int))
                 {
                     canonicalDataCase.ExceptionThrown = typeof(ArgumentException);
                 }
-                else 
+                else
                 {
                     canonicalDataCase.UseVariableForTested = true;
 
@@ -32,12 +32,19 @@ protected override string RenderTestMethodBodyArrange(TestMethodBody testMethodB
             var builder = new StringBuilder();
             builder.AppendLine("var sut = new BowlingGame();");
 
-            if (testMethodBody.CanonicalDataCase.Properties.ContainsKey(PreviousRolls))
+            if (testMethodBody.CanonicalDataCase.Input.ContainsKey(PreviousRolls))
             {
-                int[] array = testMethodBody.CanonicalDataCase.Properties[PreviousRolls];
-                    builder.Append("var previousRolls = new int[] {");
+                var array = testMethodBody.CanonicalDataCase.Input[PreviousRolls] as int[];
+                if (array == null)
+                {
+                    builder.Append("var previousRolls = new int[0];");
+                }
+                else
+                {
+                    builder.Append("var previousRolls = new [] { ");
                     builder.AppendJoin(", ", array);
-                    builder.AppendLine("};");
+                    builder.AppendLine(" };");
+                }
             }
 
             return builder.ToString();
@@ -46,21 +53,20 @@ protected override string RenderTestMethodBodyArrange(TestMethodBody testMethodB
         protected override string RenderTestMethodBodyAssert(TestMethodBody testMethodBody)
         {
             var template = string.Empty;
-            if(testMethodBody.CanonicalDataCase.ExceptionThrown != null && testMethodBody.CanonicalDataCase.Properties.ContainsKey("roll"))
+            if (testMethodBody.CanonicalDataCase.ExceptionThrown != null && testMethodBody.CanonicalDataCase.Input.ContainsKey("roll"))
             {
                 template = "Assert.Throws<ArgumentException>(() => sut.Roll({{RollVal}}));";
                 var templateParams = new
                 {
-                    RollVal = testMethodBody.CanonicalDataCase.Properties["roll"]
+                    RollVal = testMethodBody.CanonicalDataCase.Input["roll"]
                 };
                 return TemplateRenderer.RenderInline(template, templateParams);
             }
-            else if (testMethodBody.CanonicalDataCase.ExceptionThrown != null && testMethodBody.CanonicalDataCase.Property == "score") 
+            else if (testMethodBody.CanonicalDataCase.ExceptionThrown != null && testMethodBody.CanonicalDataCase.Property == "score")
             {
                 template = "Assert.Throws<ArgumentException>(() => sut.Score());";
                 return template;
             }
-            
 
             return base.RenderTestMethodBodyAssert(testMethodBody);
         }
@@ -71,12 +77,12 @@ protected override string RenderTestMethodBodyAct(TestMethodBody testMethodBody)
 @"DoRoll(previousRolls, sut);
 ";
 
-            if(testMethodBody.CanonicalDataCase.ExceptionThrown != null)
+            if (testMethodBody.CanonicalDataCase.ExceptionThrown != null)
             {
                 return template;
             }
 
-            if (testMethodBody.CanonicalDataCase.Properties.ContainsKey("roll"))
+            if (testMethodBody.CanonicalDataCase.Input.ContainsKey("roll"))
             {
                 template +=
 @"sut.Roll({{RolVal}});
@@ -84,14 +90,13 @@ protected override string RenderTestMethodBodyAct(TestMethodBody testMethodBody)
 ";
                 var templateParameters = new
                 {
-                    RolVal = testMethodBody.CanonicalDataCase.Properties["roll"]
+                    RolVal = testMethodBody.CanonicalDataCase.Input["roll"]
                 };
                 return TemplateRenderer.RenderInline(template, templateParameters);
             }
 
             template += "var actual = sut.Score();";
             return template;
-
         }
 
         protected override string[] RenderAdditionalMethods()

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

@@ -8,7 +8,7 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
-                canonicalDataCase.Properties["input"] = canonicalDataCase.Properties["input"].Replace("\\", "\\\\");
+                canonicalDataCase.Input["value"] = canonicalDataCase.Input["value"].Replace("\\", "\\\\");
                 canonicalDataCase.UseVariablesForInput = true;
             }
         }

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

@@ -0,0 +1,20 @@
+using System;
+using Generators.Input;
+
+namespace Generators.Exercises
+{
+    public class Change : GeneratorExercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.UseVariablesForInput = true;
+                canonicalDataCase.UseVariableForExpected = true;
+
+                if (canonicalDataCase.Expected is int)
+                    canonicalDataCase.ExceptionThrown = typeof(ArgumentException);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Generators.Input;
+using Generators.Output;
+
+namespace Generators.Exercises
+{
+    public class CircularBuffer : GeneratorExercise
+    {
+        protected override string RenderTestMethodBodyAssert(TestMethodBody testMethodBody)
+        {
+            var lines = new StringBuilder();
+            lines.AppendLine(RenderSut(testMethodBody.CanonicalDataCase));
+
+            foreach (var operation in testMethodBody.CanonicalDataCase.Input["operations"])
+                lines.AppendLine(RenderOperation(operation));
+
+            return lines.ToString();
+        }
+
+        private static string RenderSut(CanonicalDataCase canonicalDataCase)
+        {
+            var capacity = canonicalDataCase.Input["capacity"];
+            return $"var buffer = new CircularBuffer<int>(capacity: {capacity});";
+        }
+
+        private static string RenderOperation(dynamic operation)
+        {
+            switch (operation["operation"])
+            {
+                case "read":
+                    return RenderReadOperation(operation);
+                case "write":
+                    return RenderWriteOperation(operation);
+                case "overwrite":
+                    return RenderOverwriteOperation(operation);
+                case "clear":
+                    return RenderClearOperation(operation);
+                default:
+                    throw new ArgumentOutOfRangeException($"Unknown operation type: {operation["operation"]}");
+            }
+        }
+
+        private static string RenderReadOperation(dynamic operation)
+        {
+            if (operation["should_succeed"])
+            {
+                return $"Assert.Equal({operation["expected"]}, buffer.Read());";
+            }
+
+            return "Assert.Throws<InvalidOperationException>(() => buffer.Read());";
+        }
+
+        private static string RenderWriteOperation(dynamic operation)
+        {
+            if (operation["should_succeed"])
+            {
+                return $"buffer.Write({operation["item"]});";
+            }
+
+            return $"Assert.Throws<InvalidOperationException>(() => buffer.Write({operation["item"]}));";
+        }
+
+        private static string RenderOverwriteOperation(dynamic operation)
+            => $"buffer.Overwrite({operation["item"]});";
+
+        private static string RenderClearOperation(dynamic operation)
+            => "buffer.Clear();";
+
+        protected override HashSet<string> AddAdditionalNamespaces()
+            => new HashSet<string> { typeof(InvalidOperationException).Namespace };
+    }
+}

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

@@ -15,7 +15,6 @@ public class Clock : GeneratorExercise
         private const string PropertyEqual = "equal";
         private const string PropertyEquals = "equals";
         private const string PropertyToString = "to_string";
-        private const string PropertyEqualityExpectance = "expected";
 
         protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
@@ -27,10 +26,10 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
                 }
                 else
                 {
-                    canonicalDataCase.SetConstructorInputParameters(ParamClock1);
+                    canonicalDataCase.SetConstructorInputParameters(ParamClock2);
 
-                    var result = (Dictionary<string, object>)canonicalDataCase.Properties[ParamClock2];
-                    canonicalDataCase.Properties[ParamClock2] = new UnescapedValue($"new Clock({result[ParamHour]}, {result[ParamMinute]})");
+                    var result = (Dictionary<string, object>)canonicalDataCase.Input[ParamClock1];
+                    canonicalDataCase.Input[ParamClock1] = new UnescapedValue($"new Clock({result[ParamHour]}, {result[ParamMinute]})");
                 }
 
                 if (canonicalDataCase.Property == PropertyCreate)
@@ -69,11 +68,11 @@ private static string RenderConsistencyToAssert(TestMethodBody testMethodBody)
 
         private static string RenderEqualToAssert(TestMethodBody testMethodBody)
         {
-            var ExpectedParameter = testMethodBody.CanonicalDataCase.Input[ParamClock2];
-            var TestedValue = "sut";
-            var expectedEqual = testMethodBody.CanonicalDataCase.Properties[PropertyEqualityExpectance];
+            var expectedParameter = testMethodBody.CanonicalDataCase.Input[ParamClock1];
+            var testedValue = "sut";
+            var expectedEqual = testMethodBody.CanonicalDataCase.Expected;
 
-            testMethodBody.AssertTemplateParameters = new { ExpectedParameter, TestedValue};
+            testMethodBody.AssertTemplateParameters = new { expectedParameter, testedValue };
 
             var template = expectedEqual
                 ? $"Assert.Equal({{{{ ExpectedParameter }}}}, {{{{ TestedValue }}}}); "

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

@@ -13,35 +13,26 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             canonicalData.Exercise = "complex-number";
 
-            // Ensure the Real and Imaginary methods are tested first as they're used later to assert equality between complex numbers
-            canonicalData.Cases = canonicalData.Cases.OrderBy(c => c.Property == "real" || c.Property == "imaginary" ? 0 : 1).ToArray();
-
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
-                // Process expected
-                if (IsComplexNumber(canonicalDataCase.Expected))
-                    canonicalDataCase.UseVariableForExpected = true;
-
+                canonicalDataCase.UseVariableForExpected = IsComplexNumber(canonicalDataCase.Expected);
                 canonicalDataCase.Expected = ConvertToType(canonicalDataCase.Expected);
 
-                // Process constructor param
-                var constructorParamName = canonicalDataCase.Input.ContainsKey("input") ? "input" : "z1";
-
-                canonicalDataCase.Properties["real"] = ConvertMathDouble(canonicalDataCase.Input[constructorParamName][0]);
-                canonicalDataCase.Properties["imaginary"] = ConvertMathDouble(canonicalDataCase.Input[constructorParamName][1]);
+                var constructorParamName = canonicalDataCase.Input.ContainsKey("z") ? "z" : "z1";
+                canonicalDataCase.Input["real"] = ConvertMathDouble(canonicalDataCase.Input[constructorParamName][0]);
+                canonicalDataCase.Input["imaginary"] = ConvertMathDouble(canonicalDataCase.Input[constructorParamName][1]);
 
-                canonicalDataCase.SetConstructorInputParameters("real", "imaginary");
                 canonicalDataCase.SetInputParameters(GetInputParameters(canonicalDataCase, constructorParamName));
+                canonicalDataCase.SetConstructorInputParameters("real", "imaginary");
 
-                // Process function param
                 var keys = canonicalDataCase.Input.Keys.ToArray();
 
                 foreach (var key in keys)
-                    canonicalDataCase.Properties[key] = ConvertToType(canonicalDataCase.Properties[key]);
+                    canonicalDataCase.Input[key] = ConvertToType(canonicalDataCase.Input[key]);
             }
         }
 
-        private static string[] GetInputParameters(CanonicalDataCase canonicalDataCase, string constructorParamName) 
+        private static string[] GetInputParameters(CanonicalDataCase canonicalDataCase, string constructorParamName)
             => canonicalDataCase.Input.Keys.Where(x => x != constructorParamName).ToArray();
 
         protected override string RenderTestMethodBodyAssert(TestMethodBody testMethodBody)
@@ -82,6 +73,8 @@ private static object ConvertMathDouble(dynamic value)
                     return new UnescapedValue("Math.E");
                 case "pi":
                     return new UnescapedValue("Math.PI");
+                case "ln(2)":
+                    return new UnescapedValue("Math.Log(2.0)");
                 default:
                     return double.Parse(value.ToString());
             }

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

@@ -12,19 +12,19 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
                 canonicalDataCase.UseVariablesForConstructorParameters = true;
                 canonicalDataCase.SetConstructorInputParameters("board");
                 canonicalDataCase.Property = "result";
-                canonicalDataCase.Properties["board"] = ToMultiLineString(canonicalDataCase.Properties["board"]);
+                canonicalDataCase.Input["board"] = ToMultiLineString(canonicalDataCase.Input["board"]);
 
                 //convert to enum
-                switch (canonicalDataCase.Properties["expected"])
+                switch (canonicalDataCase.Expected)
                 {
                     case "X":
-                        canonicalDataCase.Properties["expected"] = new UnescapedValue("ConnectWinner.Black");
+                        canonicalDataCase.Expected = new UnescapedValue("ConnectWinner.Black");
                         break;
                     case "O":
-                        canonicalDataCase.Properties["expected"] = new UnescapedValue("ConnectWinner.White");
+                        canonicalDataCase.Expected = new UnescapedValue("ConnectWinner.White");
                         break;
                     case "":
-                        canonicalDataCase.Properties["expected"] = new UnescapedValue("ConnectWinner.None");
+                        canonicalDataCase.Expected = new UnescapedValue("ConnectWinner.None");
                         break;
                 }
             }
@@ -32,7 +32,7 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
 
         private UnescapedValue ToMultiLineString(string[] input)
         {
-            const string template = 
+            const string template =
 @"new [] 
 { 
     {% if input.size == 0 %}string.Empty{% else %}{% for item in {{input}} %}{% if forloop.length == 1 %}""{{item}}""{% break %}{% endif %}""{{item}}""{% if forloop.last == false %},{% else %}{{string.Empty}}{% endif %}