trackler 2.0.8.24 → 2.0.8.26

data/tracks/csharp/exercises/pig-latin/PigLatinTest.cs

@@ -2,77 +2,122 @@ using Xunit;
 
 public class PigLatinTest
 {
-    [Theory]
-    [InlineData("apple", "appleay")]
-    [InlineData("ear", "earay")]
-    [InlineData("igloo", "iglooay")]
-    [InlineData("object", "objectay")]
-    [InlineData("under", "underay")]
-    public void Ay_is_added_to_words_that_start_with_vowels(string word, string expected)
+    [Fact]
+    public void Word_beginning_with_a()
     {
-        Assert.Equal(expected, PigLatin.Translate(word));
+        Assert.Equal("appleay", PigLatin.Translate("apple"));
     }
 
-    [Theory(Skip = "Remove to run test")]
-    [InlineData("pig", "igpay")]
-    [InlineData("koala", "oalakay")]
-    [InlineData("yellow", "ellowyay")]
-    [InlineData("xenon", "enonxay")]
-    public void First_letter_and_ay_are_moved_to_the_end_of_words_that_start_with_consonants(string word, string expected)
+    [Fact(Skip = "Remove to run test")]
+    public void Word_beginning_with_e()
+    {
+        Assert.Equal("earay", PigLatin.Translate("ear"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Word_beginning_with_i()
+    {
+        Assert.Equal("iglooay", PigLatin.Translate("igloo"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Word_beginning_with_o()
+    {
+        Assert.Equal("objectay", PigLatin.Translate("object"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Word_beginning_with_u()
+    {
+        Assert.Equal("underay", PigLatin.Translate("under"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Word_beginning_with_a_vowel_and_followed_by_a_qu()
+    {
+        Assert.Equal("equalay", PigLatin.Translate("equal"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Word_beginning_with_p()
+    {
+        Assert.Equal("igpay", PigLatin.Translate("pig"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Word_beginning_with_k()
+    {
+        Assert.Equal("oalakay", PigLatin.Translate("koala"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Word_beginning_with_y()
+    {
+        Assert.Equal("ellowyay", PigLatin.Translate("yellow"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Word_beginning_with_x()
+    {
+        Assert.Equal("enonxay", PigLatin.Translate("xenon"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Word_beginning_with_q_without_a_following_u()
     {
-        Assert.Equal(expected, PigLatin.Translate(word));
+        Assert.Equal("atqay", PigLatin.Translate("qat"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Ch_is_treated_like_a_single_consonant()
+    public void Word_beginning_with_ch()
     {
         Assert.Equal("airchay", PigLatin.Translate("chair"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Qu_is_treated_like_a_single_consonant()
+    public void Word_beginning_with_qu()
     {
         Assert.Equal("eenquay", PigLatin.Translate("queen"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Qu_and_a_single_preceding_consonant_are_treated_like_a_single_consonant()
+    public void Word_beginning_with_qu_and_a_preceding_consonant()
     {
         Assert.Equal("aresquay", PigLatin.Translate("square"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Th_is_treated_like_a_single_consonant()
+    public void Word_beginning_with_th()
     {
         Assert.Equal("erapythay", PigLatin.Translate("therapy"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Thr_is_treated_like_a_single_consonant()
+    public void Word_beginning_with_thr()
     {
         Assert.Equal("ushthray", PigLatin.Translate("thrush"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Sch_is_treated_like_a_single_consonant()
+    public void Word_beginning_with_sch()
     {
         Assert.Equal("oolschay", PigLatin.Translate("school"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Yt_is_treated_like_a_single_vowel()
+    public void Word_beginning_with_yt()
     {
         Assert.Equal("yttriaay", PigLatin.Translate("yttria"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Xr_is_treated_like_a_single_vowel()
+    public void Word_beginning_with_xr()
     {
         Assert.Equal("xrayay", PigLatin.Translate("xray"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Phrases_are_translated()
+    public void A_whole_phrase()
     {
         Assert.Equal("ickquay astfay unray", PigLatin.Translate("quick fast run"));
     }

data/tracks/csharp/exercises/raindrops/Example.cs

@@ -1,4 +1,4 @@
-public class Raindrops
+public static class Raindrops
 {
     public static string Convert(int number)
     {

data/tracks/csharp/exercises/raindrops/RaindropsTest.cs

@@ -2,49 +2,111 @@ using Xunit;
 
 public class RaindropsTest
 {
-    [Theory]
-    [InlineData(1, "1")]
-    [InlineData(52, "52")]
-    [InlineData(12121, "12121")]
-    public void Non_primes_pass_through(int number, string expected)
+    [Fact]
+    public void The_sound_for_1_is_1()
     {
-        Assert.Equal(expected, Raindrops.Convert(number));
+        Assert.Equal("1", Raindrops.Convert(1));
     }
 
-    [Theory(Skip = "Remove to run test")]
-    [InlineData(3)]
-    [InlineData(6)]
-    [InlineData(9)]
-    public void Numbers_containing_3_as_a_prime_factor_give_pling(int number)
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_3_is_pling()
     {
-        Assert.Equal("Pling", Raindrops.Convert(number));
+        Assert.Equal("Pling", Raindrops.Convert(3));
     }
 
-    [Theory(Skip = "Remove to run test")]
-    [InlineData(5)]
-    [InlineData(10)]
-    [InlineData(25)]
-    public void Numbers_containing_5_as_a_prime_factor_give_plang(int number)
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_5_is_plang()
     {
-        Assert.Equal("Plang", Raindrops.Convert(number));
+        Assert.Equal("Plang", Raindrops.Convert(5));
     }
 
-    [Theory(Skip = "Remove to run test")]
-    [InlineData(7)]
-    [InlineData(14)]
-    [InlineData(49)]
-    public void Numbers_containing_7_as_a_prime_factor_give_plong(int number)
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_7_is_plong()
     {
-        Assert.Equal("Plong", Raindrops.Convert(number));
+        Assert.Equal("Plong", Raindrops.Convert(7));
     }
 
-    [Theory(Skip = "Remove to run test")]
-    [InlineData(15, "PlingPlang")]
-    [InlineData(21, "PlingPlong")]
-    [InlineData(35, "PlangPlong")]
-    [InlineData(105, "PlingPlangPlong")]
-    public void Numbers_containing_multiple_prime_factors_give_all_results_concatenated(int number, string expected)
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_6_is_pling_as_it_has_a_factor_3()
     {
-        Assert.Equal(expected, Raindrops.Convert(number));
+        Assert.Equal("Pling", Raindrops.Convert(6));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_2_to_the_power_3_does_not_make_a_raindrop_sound_as_3_is_the_exponent_not_the_base()
+    {
+        Assert.Equal("8", Raindrops.Convert(8));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_9_is_pling_as_it_has_a_factor_3()
+    {
+        Assert.Equal("Pling", Raindrops.Convert(9));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_10_is_plang_as_it_has_a_factor_5()
+    {
+        Assert.Equal("Plang", Raindrops.Convert(10));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_14_is_plong_as_it_has_a_factor_of_7()
+    {
+        Assert.Equal("Plong", Raindrops.Convert(14));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_15_is_pling_plang_as_it_has_factors_3_and_5()
+    {
+        Assert.Equal("PlingPlang", Raindrops.Convert(15));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_21_is_pling_plong_as_it_has_factors_3_and_7()
+    {
+        Assert.Equal("PlingPlong", Raindrops.Convert(21));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_25_is_plang_as_it_has_a_factor_5()
+    {
+        Assert.Equal("Plang", Raindrops.Convert(25));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_27_is_pling_as_it_has_a_factor_3()
+    {
+        Assert.Equal("Pling", Raindrops.Convert(27));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_35_is_plang_plong_as_it_has_factors_5_and_7()
+    {
+        Assert.Equal("PlangPlong", Raindrops.Convert(35));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_49_is_plong_as_it_has_a_factor_7()
+    {
+        Assert.Equal("Plong", Raindrops.Convert(49));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_52_is_52()
+    {
+        Assert.Equal("52", Raindrops.Convert(52));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_105_is_pling_plang_plong_as_it_has_factors_3_5_and_7()
+    {
+        Assert.Equal("PlingPlangPlong", Raindrops.Convert(105));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void The_sound_for_3125_is_plang_as_it_has_a_factor_5()
+    {
+        Assert.Equal("Plang", Raindrops.Convert(3125));
     }
 }

data/tracks/csharp/exercises/roman-numerals/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+This exercise requires you to write an extension method. For more information, see [this page](https://msdn.microsoft.com/en-us//library/bb383977.aspx).

data/tracks/csharp/exercises/roman-numerals/RomanNumeralsTest.cs

@@ -2,28 +2,111 @@ using Xunit;
 
 public class RomanNumeralsTest
 {
-    [Theory]
-    [InlineData(0, "")]
-    [InlineData(1, "I")]
-    [InlineData(2, "II")]
-    [InlineData(3, "III")]
-    [InlineData(4, "IV")]
-    [InlineData(5, "V")]
-    [InlineData(6, "VI")]
-    [InlineData(9, "IX")]
-    [InlineData(27, "XXVII")]
-    [InlineData(48, "XLVIII")]
-    [InlineData(59, "LIX")]
-    [InlineData(93, "XCIII")]
-    [InlineData(141, "CXLI")]
-    [InlineData(163, "CLXIII")]
-    [InlineData(402, "CDII")]
-    [InlineData(575, "DLXXV")]
-    [InlineData(911, "CMXI")]
-    [InlineData(1024, "MXXIV")]
-    [InlineData(3000, "MMM")]
-    public void Convert_roman_to_arabic_numerals(int arabicNumeral, string expected)
-    {
-        Assert.Equal(expected, arabicNumeral.ToRoman());
+    [Fact]
+    public void Number_1_is_a_single_i()
+    {
+        Assert.Equal("I", 1.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_2_is_two_i_s()
+    {
+        Assert.Equal("II", 2.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_3_is_three_i_s()
+    {
+        Assert.Equal("III", 3.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_4_being_5_1_is_iv()
+    {
+        Assert.Equal("IV", 4.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_5_is_a_single_v()
+    {
+        Assert.Equal("V", 5.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_6_being_5_1_is_vi()
+    {
+        Assert.Equal("VI", 6.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_9_being_10_1_is_ix()
+    {
+        Assert.Equal("IX", 9.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_20_is_two_x_s()
+    {
+        Assert.Equal("XXVII", 27.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_48_is_not_50_2_but_rather_40_8()
+    {
+        Assert.Equal("XLVIII", 48.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_50_is_a_single_l()
+    {
+        Assert.Equal("LIX", 59.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_90_being_100_10_is_xc()
+    {
+        Assert.Equal("XCIII", 93.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_100_is_a_single_c()
+    {
+        Assert.Equal("CXLI", 141.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_60_being_50_10_is_lx()
+    {
+        Assert.Equal("CLXIII", 163.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_400_being_500_100_is_cd()
+    {
+        Assert.Equal("CDII", 402.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_500_is_a_single_d()
+    {
+        Assert.Equal("DLXXV", 575.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_900_being_1000_100_is_cm()
+    {
+        Assert.Equal("CMXI", 911.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_1000_is_a_single_m()
+    {
+        Assert.Equal("MXXIV", 1024.ToRoman());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Number_3000_is_three_m_s()
+    {
+        Assert.Equal("MMM", 3000.ToRoman());
     }
 }

data/tracks/csharp/exercises/word-search/HINTS.md

@@ -0,0 +1,6 @@
+## HINTS
+
+One of the uses of Tuples is returning multiple values from a function.   In this exercise, write
+a function that returns a Tuple (the x- and y- part of a coordinate).
+
+For more information on Tuples, see [this link](https://msdn.microsoft.com/en-us/library/system.tuple(v=vs.110).aspx).

data/tracks/csharp/generators/{TestClass.cs → Classes/TestClass.cs}

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
+using Generators.Methods;
 
-namespace Generators
+namespace Generators.Classes
 {
     public class TestClass
     {

data/tracks/csharp/generators/{TestClassNameTransformer.cs → Classes/TestClassNameTransformer.cs}

@@ -1,6 +1,6 @@
 using Humanizer;
 
-namespace Generators
+namespace Generators.Classes
 {
     public class TestClassNameTransformer : IStringTransformer
     {

data/tracks/csharp/generators/{TestClassRenderer.cs → Classes/TestClassRenderer.cs}

@@ -1,7 +1,8 @@
 using System.Collections.Generic;
 using System.Linq;
+using Generators.Methods;
 
-namespace Generators
+namespace Generators.Classes
 {
     public static class TestClassRenderer
     {

data/tracks/csharp/generators/Classes/TestedClassNameTransformer.cs

@@ -0,0 +1,9 @@
+using Humanizer;
+
+namespace Generators.Classes
+{
+    public class TestedClassNameTransformer : IStringTransformer
+    {
+        public string Transform(string input) => input.Dehumanize();
+    }
+}

data/tracks/csharp/generators/{CanonicalData.cs → Data/CanonicalData.cs}

@@ -1,7 +1,7 @@
 using System.ComponentModel.DataAnnotations;
 using Newtonsoft.Json;
 
-namespace Generators
+namespace Generators.Data
 {
     public class CanonicalData
     {

data/tracks/csharp/generators/{CanonicalDataCase.cs → Data/CanonicalDataCase.cs}

@@ -1,8 +1,8 @@
-using Newtonsoft.Json;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
+using Newtonsoft.Json;
 
-namespace Generators
+namespace Generators.Data
 {
     [JsonConverter(typeof(CanonicalDataCaseJsonConverter))]
     public class CanonicalDataCase

data/tracks/csharp/generators/{CanonicalDataCaseJsonConverter.cs → Data/CanonicalDataCaseJsonConverter.cs}

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
-namespace Generators
+namespace Generators.Data
 {
     public class CanonicalDataCaseJsonConverter : JsonConverter
     {

data/tracks/csharp/generators/{CanonicalDataCasesJsonConverter.cs → Data/CanonicalDataCasesJsonConverter.cs}

@@ -1,11 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
-using System.Linq;
 
-namespace Generators
+namespace Generators.Data
 {
     public class CanonicalDataCasesJsonConverter : JsonConverter
     {

data/tracks/csharp/generators/{CanonicalDataParser.cs → Data/CanonicalDataParser.cs}

@@ -1,13 +1,13 @@
-using Newtonsoft.Json;
-using System;
+using System;
 using System.ComponentModel.DataAnnotations;
 using System.Net.Http;
+using Newtonsoft.Json;
 
-namespace Generators
+namespace Generators.Data
 {
     public static class CanonicalDataParser
     {
-        private static readonly HttpClient httpClient = new HttpClient();
+        private static readonly HttpClient HttpClient = new HttpClient();
 
         public static CanonicalData Parse(string exercise)
         {
@@ -20,7 +20,7 @@ namespace Generators
         }
 
         private static string DownloadCanonicalDataJson(string exercise)
-            => httpClient.GetStringAsync(GetCanonicalDataUrl(exercise)).GetAwaiter().GetResult();
+            => HttpClient.GetStringAsync(GetCanonicalDataUrl(exercise)).GetAwaiter().GetResult();
 
         private static Uri GetCanonicalDataUrl(string exercise)
             => new Uri($"https://raw.githubusercontent.com/exercism/x-common/master/exercises/{exercise}/canonical-data.json");

data/tracks/csharp/generators/{ExerciseCollection.cs → Data/ExerciseCollection.cs}

@@ -1,11 +1,11 @@
-using Generators.Exercises;
-using System;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using Generators.Exercises;
 
-namespace Generators
+namespace Generators.Data
 {
     public class ExerciseCollection : IEnumerable<Exercise>
     {

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

@@ -0,0 +1,20 @@
+using Generators.Data;
+using Generators.Methods;
+
+namespace Generators.Exercises
+{
+    public class AcronymExercise : EqualityExercise
+    {
+        public AcronymExercise() : base("acronym")
+        {
+        }
+
+        protected override TestMethodData CreateTestMethodData(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index)
+        {
+            var testMethodData = base.CreateTestMethodData(canonicalData, canonicalDataCase, index);
+            testMethodData.Options.InputProperty = "phrase";
+
+            return testMethodData;
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+using Generators.Data;
+using Generators.Methods;
+
+namespace Generators.Exercises
+{
+    public class AtbashCipherExercise : EqualityExercise
+    {
+        public AtbashCipherExercise() : base("atbash-cipher")
+        {
+        }
+
+        protected override TestMethodOptions CreateTestMethodOptions(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index)
+        {
+            var testMethodOptions = base.CreateTestMethodOptions(canonicalData, canonicalDataCase, index);
+            testMethodOptions.InputProperty = "phrase";
+
+            return testMethodOptions;
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+using Generators.Methods;
+
+namespace Generators.Exercises
+{
+    public abstract class BooleanExercise : Exercise
+    {
+        protected BooleanExercise(string name) : base(name)
+        {
+        }
+
+        protected override TestMethod CreateTestMethod(TestMethodData testMethodData)
+            => CreateBooleanTestMethod(testMethodData);
+    }
+}

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

@@ -0,0 +1,14 @@
+using Generators.Methods;
+
+namespace Generators.Exercises
+{
+    public abstract class EqualityExercise : Exercise
+    {
+        protected EqualityExercise(string name) : base(name)
+        {
+        }
+
+        protected override TestMethod CreateTestMethod(TestMethodData testMethodData)
+            => CreateEqualityTestMethod(testMethodData);
+    }
+}