trackler 2.2.1.151 → 2.2.1.152

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

@@ -0,0 +1,56 @@
+using Generators.Input;
+using Generators.Output;
+
+namespace Generators.Exercises
+{
+    public class CustomSet : GeneratorExercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.UseVariablesForInput = true;
+
+                if (canonicalDataCase.Input.ContainsKey("set"))
+                {
+                    if (!(canonicalDataCase.Input["set"] is int[]))
+                    {
+                        canonicalDataCase.Input["set"] = new UnescapedValue("");
+                    }
+
+                    canonicalDataCase.SetConstructorInputParameters("set");
+                }
+                else
+                {
+                    if (!(canonicalDataCase.Input["set1"] is int[]))
+                    {
+                        canonicalDataCase.Input["set1"] = new UnescapedValue("");
+                    }
+
+                    canonicalDataCase.SetConstructorInputParameters("set1");
+                    canonicalDataCase.Input["set2"] = ConvertCustomSet(canonicalDataCase.Input["set2"]);
+
+                    if (canonicalDataCase.Property == "equal")
+                    {
+                        canonicalDataCase.Property = "Equals";
+                    }
+                }
+
+                canonicalDataCase.Expected = ConvertCustomSet(canonicalDataCase.Expected);
+            }
+        }
+
+        private static dynamic ConvertCustomSet(dynamic value)
+        {
+            if (value is bool)
+                return value;
+
+            if (value is int[] values && values.Length > 0)
+            {
+                return new UnescapedValue($"new CustomSet({ValueFormatter.Format(values)})");
+            }
+
+            return new UnescapedValue($"new CustomSet()");
+        }
+    }
+}

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

@@ -14,10 +14,10 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
                 canonicalDataCase.UseVariablesForInput = true;
-                canonicalDataCase.Properties["input"] = ConvertInput(canonicalDataCase.Properties["input"]);
+                canonicalDataCase.Input["dominoes"] = ConvertInput(canonicalDataCase.Input["dominoes"]);
             }
         }
-        
+
         protected override HashSet<string> AddAdditionalNamespaces() => new HashSet<string>() { typeof(Tuple).Namespace };
 
         private UnescapedValue ConvertInput(dynamic input)

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

@@ -13,48 +13,20 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
             {
                 canonicalDataCase.UseVariablesForInput = true;
                 canonicalDataCase.UseVariableForExpected = true;
-                // Make sure to convert keys to ints as stated in canonical data
-                canonicalDataCase.Properties["input"] = ConvertInput(canonicalDataCase.Properties["input"]);
+                canonicalDataCase.Input = ConvertInput(canonicalDataCase.Input);
                 canonicalDataCase.Expected = ConvertExpected(canonicalDataCase.Expected);
+                canonicalDataCase.SetInputParameters("input");
             }
         }
 
-        protected override string RenderTestMethodBodyArrange(TestMethodBody testMethodBody)
-        {
-            // The ValueFormatter doesn't handle Dictionary<int, IList<string>>. Need to format manually.
-            Dictionary<int, string[]> inputDictionary = testMethodBody.CanonicalDataCase.Properties["input"];
-            var newInput = FormatMultiLineEnumerable(
-                inputDictionary.Keys.Select((key, i) => $"[{ValueFormatter.Format(key)}] = {ValueFormatter.Format(inputDictionary[key])}" + (i < inputDictionary.Keys.Count - 1 ? "," : "")), 
-                "input", "new Dictionary<int, IList<string>>");
-            newInput = AddTrailingSemicolon(newInput);
-
-            var arrangeVariables = testMethodBody.Data.Variables.ToList();
-            arrangeVariables.RemoveAt(0);
-            arrangeVariables.InsertRange(0, newInput);
-            testMethodBody.ArrangeTemplateParameters = new { Variables = arrangeVariables };
-
-            return base.RenderTestMethodBodyArrange(testMethodBody);
-        }
-
         private static dynamic ConvertExpected(dynamic expected)
             => ((Dictionary<string, object>)expected).ToDictionary(kv => kv.Key, kv => int.Parse($"{kv.Value}"));
 
-        private static dynamic ConvertInput(dynamic input)
-            => ((Dictionary<string, object>)input).ToDictionary(kv => int.Parse(kv.Key), kv => (string[])kv.Value);
-
-        private static string[] FormatMultiLineEnumerable(IEnumerable<string> enumerable, string name, string constructor = null)
-            => FormatMultiLineVariable(enumerable.Prepend("{").Append("}"), name, constructor);
-
-        private static string[] FormatMultiLineVariable(IEnumerable<string> enumerable, string name, string constructor = null)
-            => enumerable.Select(line => line == "{" || line == "}" ? line : line.Indent())
-                .Prepend($"var {name} = {constructor}")
-                .ToArray();
-
-        private static string[] AddTrailingSemicolon(string[] array)
-        {
-            array[array.Length - 1] += ";";
-            return array;
-        }
+        private static IDictionary<string, dynamic> ConvertInput(IDictionary<string, dynamic> input)
+            => new Dictionary<string, dynamic>
+            {
+                ["input"] = input.ToDictionary(kv => int.Parse(kv.Key), kv => (string[])kv.Value)
+            };
 
         protected override HashSet<string> AddAdditionalNamespaces() => new HashSet<string> { typeof(Dictionary<string, int>).Namespace };
     }

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

@@ -5,31 +5,27 @@ namespace Generators.Exercises
 {
     public class FlattenArray : GeneratorExercise
     {
-    	protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
                 canonicalDataCase.UseVariablesForInput = true;
                 canonicalDataCase.UseVariableForExpected = true;
 
-                string stringInput = canonicalDataCase.Properties["input"].ToString();
+                var stringInput = canonicalDataCase.Input["array"].ToString();
 
                 // We skip reformatting of pure int arrays.
-                if(stringInput.Contains("System.Int32"))
+                if (stringInput.Contains("System.Int32"))
                     continue;
 
-                string properInput = ToProperObjArray(stringInput);
-
-                canonicalDataCase.Properties["input"] = new UnescapedValue(properInput);
+                canonicalDataCase.Input["array"] = new UnescapedValue(ToProperObjArray(stringInput));
             }
         }
 
-        private string ToProperObjArray(string input) 
-        {
-            string res = input.Replace("System.Int32", "");
-            res = res.Replace("]", "}");
-            res = res.Replace("[", "new object[] {");
-            return res;
-        }
+        private string ToProperObjArray(string input)
+            => input
+                .Replace("System.Int32", "")
+                .Replace("]", "}")
+                .Replace("[", "new object[] {");
     }
 }

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

@@ -10,6 +10,11 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
             {
                 canonicalDataCase.Expected = ConvertHelper.ToMultiLineString(canonicalDataCase.Expected);
                 canonicalDataCase.UseVariableForExpected = true;
+
+                if (canonicalDataCase.Input["startVerse"] == canonicalDataCase.Input["endVerse"])
+                {
+                    canonicalDataCase.SetInputParameters("startVerse");
+                }
             }
         }
     }

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

@@ -0,0 +1,25 @@
+using System;
+using Generators.Input;
+
+namespace Generators.Exercises
+{
+    public class Forth : GeneratorExercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.UseFullDescriptionPath = true;
+
+                if (canonicalDataCase.Expected == null)
+                {
+                    canonicalDataCase.ExceptionThrown = typeof(InvalidOperationException);
+                }
+                else
+                {
+                    canonicalDataCase.Expected = string.Join(" ", canonicalDataCase.Expected);
+                }
+            }
+        }
+    }
+}

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

@@ -11,10 +11,10 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
             {
-                var input = DateTime.Parse(canonicalDataCase.Properties["input"].ToString());
-                canonicalDataCase.Properties["input"] = new UnescapedValue(FormatDateTime(input));
-                
-                canonicalDataCase.Expected = new UnescapedValue(FormatDateTime((DateTime)canonicalDataCase.Expected));                
+                var input = DateTime.Parse(canonicalDataCase.Input["birthdate"].ToString());
+                canonicalDataCase.Input["birthdate"] = new UnescapedValue(FormatDateTime(input));
+
+                canonicalDataCase.Expected = new UnescapedValue(FormatDateTime((DateTime)canonicalDataCase.Expected));
             }
         }
 

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

@@ -16,6 +16,6 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
             }
         }
 
-        private static bool ShouldThrowException(dynamic value) => value == -1;
+        private static bool ShouldThrowException(dynamic value) => value is int i && i == -1;
     }
 }

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

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Generators.Input;
+using Generators.Output;
+using Newtonsoft.Json.Linq;
+
+namespace Generators.Exercises
+{
+    public class Grep : GeneratorExercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.Property = "Match";
+                canonicalDataCase.Input["flags"] = string.Join(" ", canonicalDataCase.Input["flags"]);
+                canonicalDataCase.Expected = ConvertExpected(canonicalDataCase.Expected);
+                canonicalDataCase.UseVariablesForInput = true;
+                canonicalDataCase.UseVariableForExpected = true;
+            }
+        }
+        private static dynamic ConvertExpected(dynamic expected)
+        {
+            var arr = expected as object[];
+
+            if (arr == null || arr.Length == 0)
+                return "";
+
+            return new UnescapedValue("\n" + string.Join("\n", arr.Select(((x, i) => $"    \"{x}\\n\"{(i < arr.Length - 1 ? " +" : "")}"))));
+        }
+
+        protected override TestClass CreateTestClass()
+        {
+            var testClass = base.CreateTestClass();
+            testClass.TemplateName = "TestClassDisposable";
+
+            return testClass;
+        }
+
+        protected override HashSet<string> AddAdditionalNamespaces()
+        {
+            return new HashSet<string>
+            {
+                typeof(IDisposable).Namespace,
+                typeof(System.IO.File).Namespace
+            };
+        }
+
+        protected override string[] RenderAdditionalMethods()
+        {
+            return new[]
+            {
+                @"
+private const string IliadFileName = ""iliad.txt"";
+private const string IliadContents =
+    ""Achilles sing, O Goddess! Peleus' son;\n"" +
+    ""His wrath pernicious, who ten thousand woes\n"" +
+    ""Caused to Achaia's host, sent many a soul\n"" +
+    ""Illustrious into Ades premature,\n"" +
+    ""And Heroes gave (so stood the will of Jove)\n"" +
+    ""To dogs and to all ravening fowls a prey,\n"" +
+    ""When fierce dispute had separated once\n"" +
+    ""The noble Chief Achilles from the son\n"" +
+    ""Of Atreus, Agamemnon, King of men.\n"";",
+            @"
+private const string MidsummerNightFileName = ""midsummer-night.txt"";
+private const string MidsummerNightContents =
+    ""I do entreat your grace to pardon me.\n"" +
+    ""I know not by what power I am made bold,\n"" +
+    ""Nor how it may concern my modesty,\n"" +
+    ""In such a presence here to plead my thoughts;\n"" +
+    ""But I beseech your grace that I may know\n"" +
+    ""The worst that may befall me in this case,\n"" +
+    ""If I refuse to wed Demetrius.\n"";",
+            @"
+private const string ParadiseLostFileName = ""paradise-lost.txt"";
+private const string ParadiseLostContents =
+    ""Of Mans First Disobedience, and the Fruit\n"" +
+    ""Of that Forbidden Tree, whose mortal tast\n"" +
+    ""Brought Death into the World, and all our woe,\n"" +
+    ""With loss of Eden, till one greater Man\n"" +
+    ""Restore us, and regain the blissful Seat,\n"" +
+    ""Sing Heav'nly Muse, that on the secret top\n"" +
+    ""Of Oreb, or of Sinai, didst inspire\n"" +
+    ""That Shepherd, who first taught the chosen Seed\n"";",
+            @"
+public GrepTest()
+{
+    Directory.SetCurrentDirectory(Path.GetTempPath());
+    File.WriteAllText(IliadFileName, IliadContents);
+    File.WriteAllText(MidsummerNightFileName, MidsummerNightContents);
+    File.WriteAllText(ParadiseLostFileName, ParadiseLostContents);
+}",
+            @"
+public void Dispose()
+{
+    Directory.SetCurrentDirectory(Path.GetTempPath());
+    File.Delete(IliadFileName);
+    File.Delete(MidsummerNightFileName);
+    File.Delete(ParadiseLostFileName);
+}"
+            };
+        }
+    }
+}

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

@@ -8,7 +8,7 @@ public class Hamming : GeneratorExercise
         protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in canonicalData.Cases)
-                canonicalDataCase.ExceptionThrown = canonicalDataCase.Expected is long ? null : typeof(ArgumentException);
+                canonicalDataCase.ExceptionThrown = canonicalDataCase.Expected is int ? null : typeof(ArgumentException);
         }
     }
 }

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

@@ -10,6 +10,11 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
             {
                 canonicalDataCase.UseVariableForExpected = true;
                 canonicalDataCase.Expected = ConvertHelper.ToMultiLineString(canonicalDataCase.Expected);
+
+                if (canonicalDataCase.Input["startVerse"] == canonicalDataCase.Input["endVerse"])
+                {
+                    canonicalDataCase.SetInputParameters("startVerse");
+                }
             }
         }
     }

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

@@ -15,13 +15,13 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
                 canonicalDataCase.TestedMethodType = TestedMethodType.Instance;
                 canonicalDataCase.UseFullDescriptionPath = true;
 
-                if (canonicalDataCase.Properties.ContainsKey("students"))
+                if (canonicalDataCase.Input.ContainsKey("students"))
                     canonicalDataCase.SetConstructorInputParameters("diagram", "students");
                 else
                     canonicalDataCase.SetConstructorInputParameters("diagram");
 
-                var plants = (IEnumerable<string>)canonicalDataCase.Properties["expected"];
-                canonicalDataCase.Properties["expected"] = plants
+                var plants = (IEnumerable<string>)canonicalDataCase.Expected;
+                canonicalDataCase.Expected = plants
                     .Select(x => new UnescapedValue($"Plant.{x.Humanize()}"))
                     .ToArray();
             }

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

@@ -0,0 +1,25 @@
+using Generators.Input;
+using Generators.Output;
+
+namespace Generators.Exercises
+{
+    public class Markdown : GeneratorExercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.UseVariablesForInput = true;
+                canonicalDataCase.UseVariableForExpected = true;
+            }
+        }
+
+        protected override TestMethod CreateTestMethod(CanonicalDataCase canonicalDataCase, int index)
+        {
+            var testMethod = base.CreateTestMethod(canonicalDataCase, index);
+            testMethod.Skip = false;
+
+            return testMethod;
+        }
+    }
+}

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

@@ -24,12 +24,12 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
                 canonicalDataCase.SetConstructorInputParameters(ParamMonth, ParamYear);
                 canonicalDataCase.SetInputParameters(ParamDayOfWeek, ParamWeek);
 
-                canonicalDataCase.Properties[ParamYear] = canonicalDataCase.Properties["input"][ParamYear];
-                canonicalDataCase.Properties[ParamMonth] = canonicalDataCase.Properties["input"][ParamMonth];
-                canonicalDataCase.Properties[ParamWeek] =
-                    new UnescapedValue($"Schedule.{((string)canonicalDataCase.Properties["input"][ParamWeek]).Transform(To.SentenceCase)}");
-                canonicalDataCase.Properties[ParamDayOfWeek] =
-                    new UnescapedValue($"DayOfWeek.{((string)canonicalDataCase.Properties["input"][ParamDayOfWeek]).Transform(To.SentenceCase)}");
+                canonicalDataCase.Input[ParamYear] = canonicalDataCase.Input[ParamYear];
+                canonicalDataCase.Input[ParamMonth] = canonicalDataCase.Input[ParamMonth];
+                canonicalDataCase.Input[ParamWeek] =
+                    new UnescapedValue($"Schedule.{((string)canonicalDataCase.Input[ParamWeek]).Transform(To.SentenceCase)}");
+                canonicalDataCase.Input[ParamDayOfWeek] =
+                    new UnescapedValue($"DayOfWeek.{((string)canonicalDataCase.Input[ParamDayOfWeek]).Transform(To.SentenceCase)}");
             }
         }
 

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

@@ -1,5 +1,8 @@
+using System;
+using System.Collections.Generic;
 using Generators.Input;
 using Generators.Output;
+using Newtonsoft.Json.Linq;
 
 namespace Generators.Exercises
 {
@@ -12,14 +15,19 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
                 canonicalDataCase.UseVariablesForInput = true;
                 canonicalDataCase.UseVariableForExpected = true;
 
-                canonicalDataCase.Properties["input"] = ToMultiLineString(canonicalDataCase.Properties["input"]);
-                canonicalDataCase.Properties["expected"] = ToMultiLineString(canonicalDataCase.Properties["expected"]);
+                canonicalDataCase.Input["minefield"] = ToMultiLineString(canonicalDataCase.Input["minefield"]);
+                canonicalDataCase.Expected = ToMultiLineString(canonicalDataCase.Expected);
             }
         }
 
-        private UnescapedValue ToMultiLineString(string[] input)
+        private UnescapedValue ToMultiLineString(JArray input)
         {
-            const string template = 
+            return new UnescapedValue("new string[0]");
+        }
+
+        private UnescapedValue ToMultiLineString(IEnumerable<string> input)
+        {
+            const string template =
 @"new string[] 
 { 
     {% if input.size > 0 %}{% for item in {{input}} %}{% if forloop.length == 1 %}""{{item}}""{% break %}{% endif %}""{{item}}""{% if forloop.last == false %},{% else %}{{string.Empty}}{% endif %}
@@ -28,5 +36,7 @@ private UnescapedValue ToMultiLineString(string[] input)
 
             return new UnescapedValue(TemplateRenderer.RenderInline(template, new { input }));
         }
+
+        protected override HashSet<string> AddAdditionalNamespaces() => new HashSet<string> { typeof(Array).Namespace };
     }
 }