trackler 2.2.1.40 → 2.2.1.41

data/tracks/csharp/exercises/triangle/TriangleTest.cs

@@ -1,94 +1,108 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 using Xunit;
 
 public class TriangleTest
 {
     [Fact]
-    public void Equilateral_triangles_have_equal_sides()
+    public void Returns_true_if_the_triangle_is_equilateral_true_if_all_sides_are_equal()
+    {
+        Assert.True(Triangle.IsEquilateral(2,2,2));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Returns_true_if_the_triangle_is_equilateral_false_if_any_side_is_unequal()
+    {
+        Assert.False(Triangle.IsEquilateral(2,3,2));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Returns_true_if_the_triangle_is_equilateral_false_if_no_sides_are_equal()
     {
-        Assert.Equal(TriangleKind.Equilateral, Triangle.Kind(2, 2, 2));
+        Assert.False(Triangle.IsEquilateral(5,4,6));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Larger_equilateral_triangles_also_have_equal_sides()
+    public void Returns_true_if_the_triangle_is_equilateral_all_zero_sides_are_illegal_so_the_triangle_is_not_equilateral()
     {
-        Assert.Equal(TriangleKind.Equilateral, Triangle.Kind(10, 10, 10));
+        Assert.False(Triangle.IsEquilateral(0,0,0));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Isosceles_triangles_have_last_two_sides_equal()
+    public void Returns_true_if_the_triangle_is_equilateral_sides_may_be_floats()
     {
-        Assert.Equal(TriangleKind.Isosceles, Triangle.Kind(3, 4, 4));
+        Assert.True(Triangle.IsEquilateral(0.5,0.5,0.5));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Isosceles_triangles_have_first_and_last_sides_equal()
+    public void Returns_true_if_the_triangle_is_isosceles_true_if_last_two_sides_are_equal()
     {
-        Assert.Equal(TriangleKind.Isosceles, Triangle.Kind(4, 3, 4));
+        Assert.True(Triangle.IsIsosceles(3,4,4));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Isosceles_triangles_have_two_first_sides_equal()
+    public void Returns_true_if_the_triangle_is_isosceles_true_if_first_two_sides_are_equal()
     {
-        Assert.Equal(TriangleKind.Isosceles, Triangle.Kind(4, 4, 3));
+        Assert.True(Triangle.IsIsosceles(4,4,3));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Isosceles_triangles_have_in_fact_exactly_two_sides_equal()
+    public void Returns_true_if_the_triangle_is_isosceles_true_if_first_and_last_sides_are_equal()
     {
-        Assert.Equal(TriangleKind.Isosceles, Triangle.Kind(10, 10, 2));
+        Assert.True(Triangle.IsIsosceles(4,3,4));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Scalene_triangles_have_no_equal_sides()
+    public void Returns_true_if_the_triangle_is_isosceles_equilateral_triangles_are_also_isosceles()
     {
-        Assert.Equal(TriangleKind.Scalene, Triangle.Kind(3, 4, 5));
+        Assert.True(Triangle.IsIsosceles(4,4,4));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Scalene_triangles_have_no_equal_sides_at_a_larger_scale_too()
+    public void Returns_true_if_the_triangle_is_isosceles_false_if_no_sides_are_equal()
     {
-        Assert.Equal(TriangleKind.Scalene, Triangle.Kind(10, 11, 12));
+        Assert.False(Triangle.IsIsosceles(2,3,4));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Scalene_triangles_have_no_equal_sides_in_descending_order_either()
+    public void Returns_true_if_the_triangle_is_isosceles_sides_that_violate_triangle_inequality_are_not_isosceles_even_if_two_are_equal()
     {
-        Assert.Equal(TriangleKind.Scalene, Triangle.Kind(5, 4, 2));
+        Assert.False(Triangle.IsIsosceles(1,1,3));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Very_small_triangles_are_legal()
+    public void Returns_true_if_the_triangle_is_isosceles_sides_may_be_floats()
     {
-        Assert.Equal(TriangleKind.Scalene, Triangle.Kind(0.4m, 0.6m, 0.3m));
+        Assert.True(Triangle.IsIsosceles(0.5,0.4,0.5));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Triangles_with_no_size_are_illegal()
+    public void Returns_true_if_the_triangle_is_scalene_true_if_no_sides_are_equal()
     {
-        Assert.Throws<TriangleException>(() => Triangle.Kind(0, 0, 0));
+        Assert.True(Triangle.IsScalene(5,4,6));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Triangles_with_negative_sides_are_illegal()
+    public void Returns_true_if_the_triangle_is_scalene_false_if_all_sides_are_equal()
     {
-        Assert.Throws<TriangleException>(() => Triangle.Kind(3, 4, -5));
+        Assert.False(Triangle.IsScalene(4,4,4));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Triangles_violating_triangle_inequality_are_illegal()
+    public void Returns_true_if_the_triangle_is_scalene_false_if_two_sides_are_equal()
     {
-        Assert.Throws<TriangleException>(() => Triangle.Kind(1, 1, 3));
+        Assert.False(Triangle.IsScalene(4,4,3));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Triangles_violating_triangle_inequality_are_illegal_2()
+    public void Returns_true_if_the_triangle_is_scalene_sides_that_violate_triangle_inequality_are_not_scalene_even_if_they_are_all_different()
     {
-        Assert.Throws<TriangleException>(() => Triangle.Kind(2, 4, 2));
+        Assert.False(Triangle.IsScalene(7,3,2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Triangles_violating_triangle_inequality_are_illegal_3()
+    public void Returns_true_if_the_triangle_is_scalene_sides_may_be_floats()
     {
-        Assert.Throws<TriangleException>(() => Triangle.Kind(7, 3, 2));
+        Assert.True(Triangle.IsScalene(0.5,0.4,0.6));
     }
 }

data/tracks/csharp/generators/Exercise.cs

@@ -40,6 +40,11 @@ namespace Generators
         protected virtual string RenderTestMethodBodyAssert(TestMethodBody testMethodBody)
             => TemplateRenderer.RenderPartial(testMethodBody.AssertTemplateName, testMethodBody.AssertTemplateParameters);
 
+        protected virtual string[] RenderAdditionalMethods()
+        {
+            return new string[] { };
+        }
+
         private HashSet<string> GetUsingNamespaces()
         {
             var usingNamespaces = new HashSet<string> { "Xunit" };
@@ -52,7 +57,7 @@ namespace Generators
             return usingNamespaces;
         }
 
-        private string[] RenderTestMethods() => _canonicalData.Cases.Select(RenderTestMethod).ToArray();
+        private string[] RenderTestMethods() => _canonicalData.Cases.Select(RenderTestMethod).Concat(RenderAdditionalMethods()).ToArray();
 
         private TestClass CreateTestClass() => new TestClass
         {

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

@@ -15,6 +15,7 @@ namespace Generators.Exercises
         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)
         {
@@ -47,7 +48,7 @@ namespace Generators.Exercises
         {
             if (testMethodBody.CanonicalDataCase.Property == PropertyEquals)
             {
-                return base.RenderTestMethodBodyAssert(testMethodBody);
+                return RenderEqualToAssert(testMethodBody);
             }
             else if (testMethodBody.CanonicalDataCase.Property != PropertyToString)
             {
@@ -65,5 +66,20 @@ namespace Generators.Exercises
 
             return TemplateRenderer.RenderInline(template, testMethodBody.AssertTemplateParameters);
         }
+
+        private static string RenderEqualToAssert(TestMethodBody testMethodBody)
+        {
+            var ExpectedParameter = testMethodBody.CanonicalDataCase.Input[ParamClock2];
+            var TestedValue = "sut";
+            var expectedEqual = testMethodBody.CanonicalDataCase.Properties[PropertyEqualityExpectance];
+
+            testMethodBody.AssertTemplateParameters = new { ExpectedParameter, TestedValue};
+
+            var template = expectedEqual
+                ? $"Assert.Equal({{{{ ExpectedParameter }}}}, {{{{ TestedValue }}}}); "
+                : $"Assert.NotEqual({{{{ ExpectedParameter }}}}, {{{{ TestedValue }}}});";
+
+            return TemplateRenderer.RenderInline(template, testMethodBody.AssertTemplateParameters);
+        }
     }
 }

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

@@ -0,0 +1,61 @@
+using Generators.Input;
+using Generators.Output;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Generators.Exercises
+{
+    public class NucleotideCount : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                if (!((Dictionary<string, object>)canonicalDataCase.Expected).ContainsKey("error"))
+                {
+                    canonicalDataCase.UseVariableForExpected = true;
+                    canonicalDataCase.SetConstructorInputParameters("strand");
+                    canonicalDataCase.Expected = ConvertExpected(canonicalDataCase.Expected);
+                }
+            }
+        }
+
+        private static dynamic ConvertExpected(dynamic expected)
+            => ((Dictionary<string, object>)expected).ToDictionary(kv => kv.Key[0], kv => int.Parse($"{kv.Value}"));
+
+        protected override HashSet<string> AddAdditionalNamespaces() => new HashSet<string>() { typeof(Dictionary<char, int>).Namespace };
+
+        protected override string RenderTestMethodBodyAssert(TestMethodBody testMethodBody)
+        {
+            if (testMethodBody.UseVariableForExpected)
+            {
+                return RenderEqualBodyAssert(testMethodBody);
+            }
+            return RenderThrowsBodyAssert(testMethodBody);
+        }
+
+        private string RenderEqualBodyAssert(TestMethodBody testMethodBody)
+        {
+            const string template = @"Assert.Equal(expected, sut.{{ TestedMethodName }});";
+
+            var templateParameters = new
+            {
+                TestedMethodName = testMethodBody.CanonicalDataCase.Property.ToTestedMethodName()
+            };
+
+            return TemplateRenderer.RenderInline(template, templateParameters);
+        }
+
+        private string RenderThrowsBodyAssert(TestMethodBody testMethodBody)
+        {
+            const string template = @"Assert.Throws<InvalidNucleotideException>(() => new NucleotideCount(""{{ Input }}""));";
+
+            var templateParameters = new
+            {
+                Input = testMethodBody.CanonicalDataCase.Input["strand"]
+            };
+
+            return TemplateRenderer.RenderInline(template, templateParameters);
+        }
+    }
+}

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

@@ -0,0 +1,66 @@
+using System.Collections.Generic;
+using Generators.Input;
+using Generators.Output;
+
+namespace Generators.Exercises
+{
+    public class Tournament : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.TestedMethodType = TestedMethodType.Static;
+                canonicalDataCase.UseVariablesForInput = true;
+                canonicalDataCase.UseVariableForExpected = true;
+                canonicalDataCase.Properties["input"] = ToMultiLineString(canonicalDataCase.Properties["input"]);
+                canonicalDataCase.Expected = ToMultiLineString(canonicalDataCase.Expected);
+            }
+        }
+
+        protected override HashSet<string> AddAdditionalNamespaces()
+        {
+            return new HashSet<string>
+            {
+                typeof(System.String).Namespace,
+                typeof(System.IO.Stream).Namespace,
+                typeof(System.Text.UTF8Encoding).Namespace
+            };
+        }
+
+        protected override string RenderTestMethodBodyAssert(TestMethodBody testMethodBody)
+        {
+            string template = @"Assert.Equal(expected, RunTally(input).Trim());";
+            return TemplateRenderer.RenderInline(template, new { });
+        }
+
+        private UnescapedValue ToMultiLineString(string[] input)
+        {
+            const string template = @"{% if input.size == 0 %}string.Empty{% else %}{% for item in {{input}} %}{% if forloop.length == 1 %}""{{item}}""{% break %}{% endif %}""{{item}}""{% if forloop.last == false %} + Environment.NewLine +{% endif %}
+               {% endfor %}.Trim(){% endif %}";
+        
+            return new UnescapedValue(TemplateRenderer.RenderInline(template, new { input }));
+        }
+
+        protected override string[] RenderAdditionalMethods()
+        {
+            var methods = @"
+private string RunTally(string input)
+{
+    var encoding = new UTF8Encoding();
+
+    using (var inStream = new MemoryStream(encoding.GetBytes(input)))
+    {
+        using (var outStream = new MemoryStream())
+        {
+            Tournament.Tally(inStream, outStream);
+            return encoding.GetString(outStream.ToArray());
+        }
+    }
+}";
+            return methods.Split("", System.StringSplitOptions.None);
+        }
+
+
+    }
+}

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

@@ -0,0 +1,36 @@
+using System.Collections;
+using System.Collections.Generic;
+using Generators.Input;
+using Generators.Output;
+namespace Generators.Exercises
+{
+    public class Triangle : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var data in canonicalData.Cases)
+            {
+                if (data.Property == "equilateral")
+                    data.Property = "IsEquilateral";
+                else if (data.Property == "isosceles")
+                    data.Property = "IsIsosceles";
+                else if (data.Property == "scalene")
+                    data.Property = "IsScalene";
+
+                data.Properties["sides"] = SplitArrayToValues(data.Properties["sides"]);
+                data.SetInputParameters("sides");
+                data.UseFullDescriptionPath = true;
+
+            }
+        }
+
+        private UnescapedValue SplitArrayToValues(IEnumerable input)
+        {
+            const string template = "{% for item in {{input}} %}{{item}}{% if forloop.last == false %},{% endif %}{% endfor %}";
+
+            return new UnescapedValue(TemplateRenderer.RenderInline(template, new { input }));
+        }
+
+
+    }
+}

data/tracks/dart/config.json

@@ -76,6 +76,19 @@
       "unlocked_by": "hamming",
       "uuid": "0c0511fd-59aa-4480-a7cd-4de0e9303b86"
     },
+    {
+      "core": true,
+      "difficulty": 2,
+      "slug": "raindrops",
+      "topics": [
+        "control_flow_conditionals",
+        "equality",
+        "mathematics",
+        "strings"
+      ],
+      "unlocked_by": "gigasecond",
+      "uuid": "d6657d4a-0257-0c80-6667-fddd127a571f0ad1fd4"
+    },
     {
       "core": true,
       "difficulty": 3,
@@ -84,7 +97,7 @@
         "strings",
         "transforming"
       ],
-      "unlocked_by": "gigasecond",
+      "unlocked_by": "raindrops",
       "uuid": "99147c39-e8d3-4166-9215-c47fb4832781"
     },
     {
@@ -97,7 +110,7 @@
         "equality",
         "strings"
       ],
-      "unlocked_by": null,
+      "unlocked_by": "rna-transcription",
       "uuid": "6e811b53-4eb1-40f9-a811-b5113d68ae8a"
     }
   ],

data/tracks/dart/exercises/raindrops/lib/example.dart

@@ -0,0 +1,23 @@
+class Raindrops {
+  String convert(int i) {
+    bool isDiv(int divisor) {
+      return i % divisor == 0;
+    }
+
+    String out = "";
+    if (isDiv(3)) {
+      out += "Pling";
+    }
+    if (isDiv(5)) {
+      out += "Plang";
+    }
+    if (isDiv(7)) {
+      out += "Plong";
+    }
+
+    if (out == "") {
+      out = i.toString();
+    }
+    return out;
+  }
+}

data/tracks/dart/exercises/raindrops/lib/raindrops.dart

@@ -0,0 +1,3 @@
+class Raindrops {
+  // Enter your code here
+}