trackler 2.2.1.12 → 2.2.1.13

data/tracks/csharp/exercises/rotational-cipher/RotationalCipherTest.cs

@@ -1,25 +1,25 @@
-// 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;
 
 public class RotationalCipherTest
 {
     [Fact]
-    public void Rotate_a_by_1()
+    public void Rotate_a_by_0_same_output_as_input()
     {
-        Assert.Equal("b", RotationalCipher.Rotate("a", 1));
+        Assert.Equal("a", RotationalCipher.Rotate("a", 0));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Rotate_a_by_26_same_output_as_input()
+    public void Rotate_a_by_1()
     {
-        Assert.Equal("a", RotationalCipher.Rotate("a", 26));
+        Assert.Equal("b", RotationalCipher.Rotate("a", 1));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Rotate_a_by_0_same_output_as_input()
+    public void Rotate_a_by_26_same_output_as_input()
     {
-        Assert.Equal("a", RotationalCipher.Rotate("a", 0));
+        Assert.Equal("a", RotationalCipher.Rotate("a", 26));
     }
 
     [Fact(Skip = "Remove to run test")]

data/tracks/csharp/exercises/run-length-encoding/RunLengthEncodingTest.cs

@@ -1,60 +1,84 @@
-using Xunit;
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+using Xunit;
 
 public class RunLengthEncodingTest
 {
     [Fact]
-    public void Encode_simple()
+    public void Encode_empty_string()
+    {
+        Assert.Equal("", RunLengthEncoding.Encode(""));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Encode_single_characters_only_are_encoded_without_count()
+    {
+        Assert.Equal("XYZ", RunLengthEncoding.Encode("XYZ"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Encode_string_with_no_single_characters()
+    {
+        Assert.Equal("2A3B4C", RunLengthEncoding.Encode("AABBBCCCC"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Encode_single_characters_mixed_with_repeated_characters()
+    {
+        Assert.Equal("12WB12W3B24WB", RunLengthEncoding.Encode("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Encode_multiple_whitespace_mixed_in_string()
+    {
+        Assert.Equal("2 hs2q q2w2 ", RunLengthEncoding.Encode("  hsqq qww  "));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Encode_lowercase_characters()
+    {
+        Assert.Equal("2a3b4c", RunLengthEncoding.Encode("aabbbcccc"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Decode_empty_string()
     {
-        const string input = "AABBBCCCC";
-        const string expected = "2A3B4C";
-        Assert.Equal(expected, RunLengthEncoding.Encode(input));
+        Assert.Equal("", RunLengthEncoding.Decode(""));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Decode_simple()
+    public void Decode_single_characters_only()
     {
-        const string input = "2A3B4C";
-        const string expected = "AABBBCCCC";
-        Assert.Equal(expected, RunLengthEncoding.Decode(input));
+        Assert.Equal("XYZ", RunLengthEncoding.Decode("XYZ"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Encode_with_single_values()
+    public void Decode_string_with_no_single_characters()
     {
-        const string input = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB";
-        const string expected = "12WB12W3B24WB";
-        Assert.Equal(expected, RunLengthEncoding.Encode(input));
+        Assert.Equal("AABBBCCCC", RunLengthEncoding.Decode("2A3B4C"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Decode_with_single_values()
+    public void Decode_single_characters_with_repeated_characters()
     {
-        const string input = "12WB12W3B24WB";
-        const string expected = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB";
-        Assert.Equal(expected, RunLengthEncoding.Decode(input));
+        Assert.Equal("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB", RunLengthEncoding.Decode("12WB12W3B24WB"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Encode_and_then_decode()
+    public void Decode_multiple_whitespace_mixed_in_string()
     {
-        const string input = "zzz ZZ  zZ";
-        const string expected = "zzz ZZ  zZ";
-        Assert.Equal(expected, RunLengthEncoding.Decode(RunLengthEncoding.Encode(input)));
+        Assert.Equal("  hsqq qww  ", RunLengthEncoding.Decode("2 hs2q q2w2 "));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Encode_unicode()
+    public void Decode_lower_case_string()
     {
-        const string input = "⏰⚽⚽⚽⭐⭐⏰";
-        const string expected = "⏰3⚽2⭐⏰";
-        Assert.Equal(expected, RunLengthEncoding.Encode(input));
+        Assert.Equal("aabbbcccc", RunLengthEncoding.Decode("2a3b4c"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Decode_unicode()
+    public void Consistency_encode_followed_by_decode_gives_original_string()
     {
-        const string input = "⏰3⚽2⭐⏰";
-        const string expected = "⏰⚽⚽⚽⭐⭐⏰";
-        Assert.Equal(expected, RunLengthEncoding.Decode(input));
+        Assert.Equal("zzz ZZ  zZ", RunLengthEncoding.Decode(RunLengthEncoding.Encode("zzz ZZ  zZ")));
     }
 }

data/tracks/csharp/exercises/scrabble-score/Example.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 
-public class Scrabble
+public static class ScrabbleScore
 {
     private static readonly Dictionary<char, int> LetterScores = new Dictionary<char, int>
         {
@@ -21,4 +21,4 @@ public static int Score(string input)
 
         return input.ToLower().Sum(x => LetterScores[x]);
     }
-}
+}

data/tracks/csharp/exercises/scrabble-score/ScrabbleScore.cs

@@ -1,6 +1,6 @@
 using System;
 
-public static class Scrabble
+public static class ScrabbleScore
 {
     public static int Score(string input)
     {

data/tracks/csharp/exercises/scrabble-score/ScrabbleScoreTest.cs

@@ -1,58 +1,72 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 using Xunit;
 
 public class ScrabbleScoreTest
 {
     [Fact]
-    public void Empty_word_scores_zero()
+    public void Lowercase_letter()
+    {
+        Assert.Equal(1, ScrabbleScore.Score("a"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Uppercase_letter()
     {
-        Assert.Equal(0, Scrabble.Score(""));
+        Assert.Equal(1, ScrabbleScore.Score("A"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Whitespace_scores_zero()
+    public void Valuable_letter()
     {
-        Assert.Equal(0, Scrabble.Score(" \t\n"));
+        Assert.Equal(4, ScrabbleScore.Score("f"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Null_scores_zero()
+    public void Short_word()
     {
-        Assert.Equal(0, Scrabble.Score(null));
+        Assert.Equal(2, ScrabbleScore.Score("at"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Scores_very_short_word()
+    public void Short_valuable_word()
     {
-        Assert.Equal(1, Scrabble.Score("a"));
+        Assert.Equal(12, ScrabbleScore.Score("zoo"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Scores_other_very_short_word()
+    public void Medium_word()
     {
-        Assert.Equal(4, Scrabble.Score("f"));
+        Assert.Equal(6, ScrabbleScore.Score("street"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Simple_word_scores_the_number_of_letters()
+    public void Medium_valuable_word()
     {
-        Assert.Equal(6, Scrabble.Score("street"));
+        Assert.Equal(22, ScrabbleScore.Score("quirky"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Complicated_word_scores_more()
+    public void Long_mixed_case_word()
     {
-        Assert.Equal(22, Scrabble.Score("quirky"));
+        Assert.Equal(41, ScrabbleScore.Score("OxyphenButazone"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Scores_are_case_insensitive()
+    public void English_like_word()
     {
-        Assert.Equal(41, Scrabble.Score("OXYPHENBUTAZONE"));
+        Assert.Equal(8, ScrabbleScore.Score("pinata"));
     }
-    
+
+    [Fact(Skip = "Remove to run test")]
+    public void Empty_input()
+    {
+        Assert.Equal(0, ScrabbleScore.Score(""));
+    }
+
     [Fact(Skip = "Remove to run test")]
-    public void Entire_alphabet()
+    public void Entire_alphabet_available()
     {
-        Assert.Equal(87, Scrabble.Score("abcdefghijklmnopqrstuvwxyz"));
+        Assert.Equal(87, ScrabbleScore.Score("abcdefghijklmnopqrstuvwxyz"));
     }
 }

data/tracks/csharp/exercises/secret-handshake/SecretHandshake.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Linq;
 
 public static class SecretHandshake
 {

data/tracks/csharp/exercises/secret-handshake/SecretHandshakeTest.cs

@@ -1,46 +1,72 @@
-using Xunit;
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
-public class SecretHandshakeTests
+using Xunit;
+
+public class SecretHandshakeTest
 {
     [Fact]
-    public void Test_1_handshake_to_wink()
+    public void Wink_for_1()
     {
         Assert.Equal(new[] { "wink" }, SecretHandshake.Commands(1));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_10_handshake_to_double_blink()
+    public void Double_blink_for_10()
     {
         Assert.Equal(new[] { "double blink" }, SecretHandshake.Commands(2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_100_handshake_to_close_your_eyes()
+    public void Close_your_eyes_for_100()
     {
         Assert.Equal(new[] { "close your eyes" }, SecretHandshake.Commands(4));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_1000_handshake_to_close_your_eyes()
+    public void Jump_for_1000()
     {
         Assert.Equal(new[] { "jump" }, SecretHandshake.Commands(8));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_handshake_11_to_wink_and_double_blink()
+    public void Combine_two_actions()
     {
         Assert.Equal(new[] { "wink", "double blink" }, SecretHandshake.Commands(3));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_handshake_10011_to_double_blink_and_wink()
+    public void Reverse_two_actions()
     {
         Assert.Equal(new[] { "double blink", "wink" }, SecretHandshake.Commands(19));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_handshake_11111_to_all_commands_reversed()
+    public void Reversing_one_action_gives_the_same_action()
+    {
+        Assert.Equal(new[] { "jump" }, SecretHandshake.Commands(24));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Reversing_no_actions_still_gives_no_actions()
+    {
+        Assert.Empty(SecretHandshake.Commands(16));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void All_possible_actions()
+    {
+        Assert.Equal(new[] { "wink", "double blink", "close your eyes", "jump" }, SecretHandshake.Commands(15));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Reverse_all_possible_actions()
     {
         Assert.Equal(new[] { "jump", "close your eyes", "double blink", "wink" }, SecretHandshake.Commands(31));
     }
-}
+
+    [Fact(Skip = "Remove to run test")]
+    public void Do_nothing_for_zero()
+    {
+        Assert.Empty(SecretHandshake.Commands(0));
+    }
+}

data/tracks/csharp/exercises/two-fer/Example.cs

@@ -4,7 +4,7 @@
 
   public static class TwoFer
   {
-      public static string GetResponse(string input = null)
+      public static string Name(string input = null)
       {
           if(string.IsNullOrWhiteSpace(input))
           {

data/tracks/csharp/exercises/two-fer/TwoFer.cs

@@ -2,7 +2,7 @@
 
   public static class TwoFer
   {
-      public static string GetResponse(string input = null)
+      public static string Name(string input = null)
       {
           throw new NotImplementedException("You need to implement this function.");
       }

data/tracks/csharp/exercises/two-fer/TwoFerTest.cs

@@ -1,24 +1,24 @@
-// 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;
 
-  public class TwoFerTest
-  {
-      [Fact]
-      public void No_name_given()
-      {
-          Assert.Equal("One for you, one for me.", TwoFer.GetResponse());
-      }
+public class TwoFerTest
+{
+    [Fact]
+    public void No_name_given()
+    {
+        Assert.Equal("One for you, one for me.", TwoFer.Name());
+    }
 
-      [Fact(Skip = "Remove to run test")]
-      public void Name_is_given()
-      {
-          Assert.Equal("One for Alice, one for me.", TwoFer.GetResponse("Alice"));
-      }
+    [Fact(Skip = "Remove to run test")]
+    public void A_name_given()
+    {
+        Assert.Equal("One for Alice, one for me.", TwoFer.Name("Alice"));
+    }
 
-      [Fact(Skip = "Remove to run test")]
-      public void Another_name_is_given()
-      {
-          Assert.Equal("One for Bob, one for me.", TwoFer.GetResponse("Bob"));
-      }
-  }
+    [Fact(Skip = "Remove to run test")]
+    public void Another_name_given()
+    {
+        Assert.Equal("One for Bob, one for me.", TwoFer.Name("Bob"));
+    }
+}

data/tracks/csharp/generators/.gitignore

@@ -1,2 +1,2 @@
-.cache/
+.problem-specifications/
 Properties/launchSettings.json

data/tracks/csharp/generators/Exercise.cs

@@ -1,23 +1,98 @@
-using Generators.Input;
+using System.Collections.Generic;
+using System.Linq;
+using Generators.Input;
 using Generators.Output;
 
 namespace Generators
 {
     public abstract class Exercise
     {
-        protected Exercise()
+        private static readonly ExerciseWriter ExerciseWriter = new ExerciseWriter();
+        
+        public string Name => GetType().ToExerciseName();
+
+        protected CanonicalData CanonicalData { get; private set; }
+        
+        public void Regenerate(CanonicalData canonicalData)
+        {
+            CanonicalData = canonicalData;
+            UpdateCanonicalData(CanonicalData);
+
+            ExerciseWriter.WriteToFile(this);
+        }
+
+        protected virtual void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+        }
+
+        public virtual string Render() => CreateTestClass().Render();
+
+        protected virtual TestClass CreateTestClass() => new TestClass
+        {
+            ClassName = Name.ToTestClassName(),
+            Methods = RenderTestMethods(),
+            CanonicalDataVersion = CanonicalData.Version,
+            UsingNamespaces = GetUsingNamespaces()
+        };
+
+        protected virtual HashSet<string> GetUsingNamespaces()
+        {
+            var usingNamespaces = new HashSet<string> { "Xunit" };
+
+            foreach (var canonicalDataCase in CanonicalData.Cases.Where(canonicalDataCase => canonicalDataCase.ExceptionThrown != null))
+                usingNamespaces.Add(canonicalDataCase.ExceptionThrown.Namespace);
+
+            return usingNamespaces;
+        }
+
+        protected virtual string[] RenderTestMethods() => CanonicalData.Cases.Select(RenderTestMethod).ToArray();
+
+        protected virtual string RenderTestMethod(CanonicalDataCase canonicalDataCase, int index) => CreateTestMethod(canonicalDataCase, index).Render();
+
+        protected virtual TestMethod CreateTestMethod(CanonicalDataCase canonicalDataCase, int index) => new TestMethod
+        {
+            Skip = index > 0,
+            Name = canonicalDataCase.Description.ToTestMethodName(),
+            Body = RenderTestMethodBody(canonicalDataCase)
+        };
+
+        protected virtual string RenderTestMethodBody(CanonicalDataCase canonicalDataCase)
         {
-            Name = GetType().ToExerciseName();
-            CanonicalData = CanonicalDataParser.Parse(Name);
+            var testMethodBody = CreateTestMethodBody(canonicalDataCase);
+            testMethodBody.Arrange = RenderTestMethodBodyArrange(testMethodBody);
+            testMethodBody.Act = RenderTestMethodBodyAct(testMethodBody);
+            testMethodBody.Assert = RenderTestMethodBodyAssert(testMethodBody);
+
+            return testMethodBody.Render();
         }
 
-        public string Name { get; }
-        public CanonicalData CanonicalData { get; }
+        protected virtual TestMethodBody CreateTestMethodBody(CanonicalDataCase canonicalDataCase)
+        {
+            if (canonicalDataCase.ExceptionThrown != null)
+            {
+                return new TestMethodBodyWithExceptionCheck(canonicalDataCase, CanonicalData);
+            }
+
+            if (canonicalDataCase.Expected is bool)
+            {
+                return new TestMethodBodyWithBooleanCheck(canonicalDataCase, CanonicalData);
+            }
+
+            if (canonicalDataCase.Expected is null)
+            {
+                return new TestMethodBodyWithNullCheck(canonicalDataCase, CanonicalData);
+            }
+
+            return new TestMethodBodyWithEqualityCheck(canonicalDataCase, CanonicalData);
+        }
 
-        public void Generate() => TestClassFile.Write(this, Render());
+        protected virtual string RenderTestMethodBodyArrange(TestMethodBody testMethodBody)
+            => TemplateRenderer.RenderPartial(testMethodBody.ArrangeTemplateName, testMethodBody.ArrangeTemplateParameters);
 
-        protected virtual string Render() => TestClassRenderer.Render(CreateTestClass());
+        protected virtual string RenderTestMethodBodyAct(TestMethodBody testMethodBody)
+            => TemplateRenderer.RenderPartial(testMethodBody.ActTemplateName, testMethodBody.ActTemplateParameters);
 
-        protected virtual TestClass CreateTestClass() => TestClassGenerator.Create(this);
+        protected virtual string RenderTestMethodBodyAssert(TestMethodBody testMethodBody)
+            => TemplateRenderer.RenderPartial(testMethodBody.AssertTemplateName, testMethodBody.AssertTemplateParameters);
     }
-}
+}