trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/house/HouseTest.cs

@@ -1,8 +1,8 @@
-using NUnit.Framework;
+using Xunit;
 
 public class HouseTest
 {
-    [Test]
+    [Fact]
     public void Rhyme_is_correct()
     {
         const string expected =
@@ -96,6 +96,6 @@ public class HouseTest
             "that ate the malt\n" +
             "that lay in the house that Jack built.";
 
-        Assert.That(House.Rhyme(), Is.EqualTo(expected));
+        Assert.Equal(expected, House.Rhyme());
     }
 }

data/tracks/csharp/exercises/isogram/Isogram.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class Isogram
+{
+    public static bool IsIsogram(string word)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/isogram/Isogram.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp1.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Example.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="xunit" Version="2.2.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/csharp/exercises/isogram/IsogramTest.cs

@@ -1,20 +1,20 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class IsogramTest
 {
-    [TestCase("duplicates", ExpectedResult = true)]
-    [TestCase("eleven", ExpectedResult = false, Ignore = "Remove to run test case")]
-    [TestCase("subdermatoglyphic", ExpectedResult = true, Ignore = "Remove to run test case")]
-    [TestCase("Alphabet", ExpectedResult = false, Ignore = "Remove to run test case")]
-    [TestCase("thumbscrew-japingly", ExpectedResult = true, Ignore = "Remove to run test case")]
-    [TestCase("Hjelmqvist-Gryb-Zock-Pfund-Wax", ExpectedResult = true, Ignore = "Remove to run test case")]
-    [TestCase("Heizölrückstoßabdämpfung", ExpectedResult = true, Ignore = "Remove to run test case")]
-    [TestCase("the quick brown fox", ExpectedResult = false, Ignore = "Remove to run test case")]
-    [TestCase("Emily Jung Schwartzkopf", ExpectedResult = true, Ignore = "Remove to run test case")]
-    [TestCase("éléphant", ExpectedResult = false, Ignore = "Remove to run test case")]
-    public bool Isogram_correctly_detects_isograms(string input)
+    [Theory]
+    [InlineData("duplicates", true)]
+    [InlineData("eleven", false)]
+    [InlineData("subdermatoglyphic", true)]
+    [InlineData("Alphabet", false)]
+    [InlineData("thumbscrew-japingly", true)]
+    [InlineData("Hjelmqvist-Gryb-Zock-Pfund-Wax", true)]
+    [InlineData("Heizölrückstoßabdämpfung", true)]
+    [InlineData("the quick brown fox", false)]
+    [InlineData("Emily Jung Schwartzkopf", true)]
+    [InlineData("éléphant", false)]
+    public void Isogram_correctly_detects_isograms(string input, bool expected)
     {
-        return Isogram.IsIsogram(input);
+        Assert.Equal(expected, Isogram.IsIsogram(input));
     }
 }

data/tracks/csharp/exercises/kindergarten-garden/KinderGartenGardenTest.cs

@@ -1,65 +1,60 @@
-using NUnit.Framework;
+using Xunit;
 
 public class KinderGartenGardenTest
 {
-    [Test]
+    [Fact]
     public void Missing_child()
     {
         var actual = Garden.DefaultGarden("RC\nGG").GetPlants("Potter");
-        Assert.That(actual, Is.Empty);
+        Assert.Empty(actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Alice()
     {
-        Assert.That(Garden.DefaultGarden("RC\nGG").GetPlants("Alice"), Is.EqualTo(new [] { Plant.Radishes, Plant.Clover, Plant.Grass, Plant.Grass }));
-        Assert.That(Garden.DefaultGarden("VC\nRC").GetPlants("Alice"), Is.EqualTo(new[] { Plant.Violets, Plant.Clover, Plant.Radishes, Plant.Clover }));
+        Assert.Equal(new [] { Plant.Radishes, Plant.Clover, Plant.Grass, Plant.Grass }, Garden.DefaultGarden("RC\nGG").GetPlants("Alice"));
+        Assert.Equal(new[] { Plant.Violets, Plant.Clover, Plant.Radishes, Plant.Clover }, Garden.DefaultGarden("VC\nRC").GetPlants("Alice"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Small_garden()
     {
         var actual = Garden.DefaultGarden("VVCG\nVVRC").GetPlants("Bob");
-        Assert.That(actual, Is.EqualTo(new[] { Plant.Clover, Plant.Grass, Plant.Radishes, Plant.Clover }));
+        Assert.Equal(new[] { Plant.Clover, Plant.Grass, Plant.Radishes, Plant.Clover }, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Medium_garden()
     {
         var garden = Garden.DefaultGarden("VVCCGG\nVVCCGG");
-        Assert.That(garden.GetPlants("Bob"), Is.EqualTo(new[] { Plant.Clover, Plant.Clover, Plant.Clover, Plant.Clover }));
-        Assert.That(garden.GetPlants("Charlie"), Is.EqualTo(new[] { Plant.Grass, Plant.Grass, Plant.Grass, Plant.Grass }));
+        Assert.Equal(new[] { Plant.Clover, Plant.Clover, Plant.Clover, Plant.Clover }, garden.GetPlants("Bob"));
+        Assert.Equal(new[] { Plant.Grass, Plant.Grass, Plant.Grass, Plant.Grass }, garden.GetPlants("Charlie"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Full_garden()
     {
         var garden = Garden.DefaultGarden("VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV");
-        Assert.That(garden.GetPlants("Alice"), Is.EqualTo(new[] { Plant.Violets, Plant.Radishes, Plant.Violets, Plant.Radishes }));
-        Assert.That(garden.GetPlants("Bob"), Is.EqualTo(new[] { Plant.Clover, Plant.Grass, Plant.Clover, Plant.Clover }));
-        Assert.That(garden.GetPlants("David"), Is.EqualTo(new[] { Plant.Radishes, Plant.Violets, Plant.Clover, Plant.Radishes }));
-        Assert.That(garden.GetPlants("Eve"), Is.EqualTo(new[] { Plant.Clover, Plant.Grass, Plant.Radishes, Plant.Grass }));
-        Assert.That(garden.GetPlants("Fred"), Is.EqualTo(new[] { Plant.Grass, Plant.Clover, Plant.Violets, Plant.Clover }));
-        Assert.That(garden.GetPlants("Ginny"), Is.EqualTo(new[] { Plant.Clover, Plant.Grass, Plant.Grass, Plant.Clover }));
-        Assert.That(garden.GetPlants("Harriet"), Is.EqualTo(new[] { Plant.Violets, Plant.Radishes, Plant.Radishes, Plant.Violets }));
-        Assert.That(garden.GetPlants("Ileana"), Is.EqualTo(new[] { Plant.Grass, Plant.Clover, Plant.Violets, Plant.Clover }));
-        Assert.That(garden.GetPlants("Joseph"), Is.EqualTo(new[] { Plant.Violets, Plant.Clover, Plant.Violets, Plant.Grass }));
-        Assert.That(garden.GetPlants("Kincaid"), Is.EqualTo(new[] { Plant.Grass, Plant.Clover, Plant.Clover, Plant.Grass }));
-        Assert.That(garden.GetPlants("Larry"), Is.EqualTo(new[] { Plant.Grass, Plant.Violets, Plant.Clover, Plant.Violets }));
+        Assert.Equal(new[] { Plant.Violets, Plant.Radishes, Plant.Violets, Plant.Radishes }, garden.GetPlants("Alice"));
+        Assert.Equal(new[] { Plant.Clover, Plant.Grass, Plant.Clover, Plant.Clover }, garden.GetPlants("Bob"));
+        Assert.Equal(new[] { Plant.Radishes, Plant.Violets, Plant.Clover, Plant.Radishes }, garden.GetPlants("David"));
+        Assert.Equal(new[] { Plant.Clover, Plant.Grass, Plant.Radishes, Plant.Grass }, garden.GetPlants("Eve"));
+        Assert.Equal(new[] { Plant.Grass, Plant.Clover, Plant.Violets, Plant.Clover }, garden.GetPlants("Fred"));
+        Assert.Equal(new[] { Plant.Clover, Plant.Grass, Plant.Grass, Plant.Clover }, garden.GetPlants("Ginny"));
+        Assert.Equal(new[] { Plant.Violets, Plant.Radishes, Plant.Radishes, Plant.Violets }, garden.GetPlants("Harriet"));
+        Assert.Equal(new[] { Plant.Grass, Plant.Clover, Plant.Violets, Plant.Clover }, garden.GetPlants("Ileana"));
+        Assert.Equal(new[] { Plant.Violets, Plant.Clover, Plant.Violets, Plant.Grass }, garden.GetPlants("Joseph"));
+        Assert.Equal(new[] { Plant.Grass, Plant.Clover, Plant.Clover, Plant.Grass }, garden.GetPlants("Kincaid"));
+        Assert.Equal(new[] { Plant.Grass, Plant.Violets, Plant.Clover, Plant.Violets }, garden.GetPlants("Larry"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Surprise_garden()
     {
         var garden = new Garden(new [] { "Samantha", "Patricia", "Xander", "Roger" }, "VCRRGVRG\nRVGCCGCV");
-        Assert.That(garden.GetPlants("Patricia"), Is.EqualTo(new[] { Plant.Violets, Plant.Clover, Plant.Radishes, Plant.Violets }));
-        Assert.That(garden.GetPlants("Roger"), Is.EqualTo(new[] { Plant.Radishes, Plant.Radishes, Plant.Grass, Plant.Clover }));
-        Assert.That(garden.GetPlants("Samantha"), Is.EqualTo(new[] { Plant.Grass, Plant.Violets, Plant.Clover, Plant.Grass }));
-        Assert.That(garden.GetPlants("Xander"), Is.EqualTo(new[] { Plant.Radishes, Plant.Grass, Plant.Clover, Plant.Violets }));
+        Assert.Equal(new[] { Plant.Violets, Plant.Clover, Plant.Radishes, Plant.Violets }, garden.GetPlants("Patricia"));
+        Assert.Equal(new[] { Plant.Radishes, Plant.Radishes, Plant.Grass, Plant.Clover }, garden.GetPlants("Roger"));
+        Assert.Equal(new[] { Plant.Grass, Plant.Violets, Plant.Clover, Plant.Grass }, garden.GetPlants("Samantha"));
+        Assert.Equal(new[] { Plant.Radishes, Plant.Grass, Plant.Clover, Plant.Violets }, garden.GetPlants("Xander"));
     }
 }

data/tracks/csharp/exercises/kindergarten-garden/KindergartenGarden.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+
+public enum Plant
+{
+    Violets,
+    Radishes,
+    Clover,
+    Grass
+}
+
+public class Garden
+{
+    public Garden(IEnumerable<string> children, string windowSills)
+    {
+    }
+
+    public IEnumerable<Plant> GetPlants(string child)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public static Garden DefaultGarden(string windowSills)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/kindergarten-garden/KindergartenGarden.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp1.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Example.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="xunit" Version="2.2.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/csharp/exercises/largest-series-product/LargestSeriesProduct.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class LargestSeriesProduct
+{
+    public static long GetLargestProduct(string digits, int span) 
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/largest-series-product/LargestSeriesProduct.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp1.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Example.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="xunit" Version="2.2.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/csharp/exercises/largest-series-product/LargestSeriesProductTest.cs

@@ -1,153 +1,139 @@
 using System;
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class LargestSeriesProductTest
 {
-    [Test]
+    [Fact]
     public void Can_find_the_largest_product_of_2_with_numbers_in_order()
     {
         const string digits = "0123456789";
         const int span = 2;
         const int expected = 72;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_find_the_largest_product_of_2()
     {
         const string digits = "576802143";
         const int span = 2;
         const int expected = 48;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Finds_the_largest_product_if_span_equals_length()
     {
         const string digits = "29";
         const int span = 2;
         const int expected = 18;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_find_the_largest_product_of_3_with_numbers_in_order()
     {
         const string digits = "0123456789";
         const int span = 3;
         const int expected = 504;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_find_the_largest_product_of_3()
     {
         const string digits = "1027839564";
         const int span = 3;
         const int expected = 270;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_find_the_largest_product_of_5_with_numbers_in_order()
     {
         const string digits = "0123456789";
         const int span = 5;
         const int expected = 15120;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_get_the_largest_product_of_a_big_number()
     {
         const string digits = "73167176531330624919225119674426574742355349194934";
         const int span = 6;
         const int expected = 23520;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_get_the_largest_product_of_a_big_number_II()
     {
         const string digits = "52677741234314237566414902593461595376319419139427";
         const int span = 6;
         const int expected = 28350;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_get_the_largest_product_of_a_big_number_III()
     {
         const string digits = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450";
         const int span = 13;
         const long expected = 23514624000;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Reports_zero_if_the_only_digits_are_zero()
     {
         const string digits = "0000";
         const int span = 2;
         const int expected = 0;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Reports_zero_if_all_spans_include_zero()
     {
         const string digits = "99099";
         const int span = 3;
         const int expected = 0;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Reports_1_for_empty_string_and_empty_product_0_span()
     {
         const string digits = "";
         const int span = 0;
         const int expected = 1;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Reports_1_for_nonempty_string_and_empty_product_0_span()
     {
         const string digits = "123";
         const int span = 0;
         const int expected = 1;
 
-        Assert.That(LargestSeriesProduct.GetLargestProduct(digits, span), Is.EqualTo(expected));
+        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Rejects_span_longer_than_string_length()
     {
         const string digits = "123";
@@ -156,8 +142,7 @@ public class LargestSeriesProductTest
         Assert.Throws<ArgumentException>(() => LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Rejects_empty_string_and_nonzero_span()
     {
         const string digits = "";
@@ -166,8 +151,7 @@ public class LargestSeriesProductTest
         Assert.Throws<ArgumentException>(() => LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Rejects_invalid_character_in_digits()
     {
         const string digits = "1234a5";
@@ -176,8 +160,7 @@ public class LargestSeriesProductTest
         Assert.Throws<ArgumentException>(() => LargestSeriesProduct.GetLargestProduct(digits, span));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Rejects_negative_span()
     {
         const string digits = "12345";