trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/palindrome-products/PalindromeProducts.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/palindrome-products/PalindromeTest.cs

@@ -1,76 +1,69 @@
 using System;
-using NUnit.Framework;
+using Xunit;
 
 public class PalindromeTest
 {
-    [Test]
+    [Fact]
     public void Largest_palindrome_from_single_digit_factors()
     {
         var actual = Palindrome.Largest(9);
-        Assert.That(actual.Value, Is.EqualTo(9));
-        Assert.That(actual.Factors, Is.EqualTo(new [] { Tuple.Create(1, 9), Tuple.Create(3, 3) }));
+        Assert.Equal(9, actual.Value);
+        Assert.Equal(new [] { Tuple.Create(1, 9), Tuple.Create(3, 3) }, actual.Factors);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Smallest_palindrome_from_single_digit_factors()
     {
         var actual = Palindrome.Smallest(9);
-        Assert.That(actual.Value, Is.EqualTo(1));
-        Assert.That(actual.Factors, Is.EqualTo(new[] { Tuple.Create(1, 1) }));
+        Assert.Equal(1, actual.Value);
+        Assert.Equal(new[] { Tuple.Create(1, 1) }, actual.Factors);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Largest_palindrome_from_double_digit_actors()
     {
         var actual = Palindrome.Largest(10, 99);
-        Assert.That(actual.Value, Is.EqualTo(9009));
-        Assert.That(actual.Factors, Is.EqualTo(new[] { Tuple.Create(91, 99) }));
+        Assert.Equal(9009, actual.Value);
+        Assert.Equal(new[] { Tuple.Create(91, 99) }, actual.Factors);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Smallest_palindrome_from_double_digit_factors()
     {
         var actual = Palindrome.Smallest(10, 99);
-        Assert.That(actual.Value, Is.EqualTo(121));
-        Assert.That(actual.Factors, Is.EqualTo(new[] { Tuple.Create(11, 11) }));
+        Assert.Equal(121, actual.Value);
+        Assert.Equal(new[] { Tuple.Create(11, 11) }, actual.Factors);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Largest_palindrome_from_triple_digit_factors()
     {
         var actual = Palindrome.Largest(100, 999);
-        Assert.That(actual.Value, Is.EqualTo(906609));
-        Assert.That(actual.Factors, Is.EqualTo(new[] { Tuple.Create(913, 993) }));
+        Assert.Equal(906609, actual.Value);
+        Assert.Equal(new[] { Tuple.Create(913, 993) }, actual.Factors);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Smallest_palindrome_from_triple_digit_factors()
     {
         var actual = Palindrome.Smallest(100, 999);
-        Assert.That(actual.Value, Is.EqualTo(10201));
-        Assert.That(actual.Factors, Is.EqualTo(new[] { Tuple.Create(101, 101) }));
+        Assert.Equal(10201, actual.Value);
+        Assert.Equal(new[] { Tuple.Create(101, 101) }, actual.Factors);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Largest_palindrome_from_four_digit_factors()
     {
         var actual = Palindrome.Largest(1000, 9999);
-        Assert.That(actual.Value, Is.EqualTo(99000099));
-        Assert.That(actual.Factors, Is.EqualTo(new[] { Tuple.Create(9901, 9999) }));
+        Assert.Equal(99000099, actual.Value);
+        Assert.Equal(new[] { Tuple.Create(9901, 9999) }, actual.Factors);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Smallest_palindrome_from_four_digit_factors()
     {
         var actual = Palindrome.Smallest(1000, 9999);
-        Assert.That(actual.Value, Is.EqualTo(1002001));
-        Assert.That(actual.Factors, Is.EqualTo(new[] { Tuple.Create(1001, 1001) }));
+        Assert.Equal(1002001, actual.Value);
+        Assert.Equal(new[] { Tuple.Create(1001, 1001) }, actual.Factors);
     }
 }

data/tracks/csharp/exercises/pangram/Pangram.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class Pangram
+{
+    public static bool IsPangram(string input)
+    {
+        throw new NotImplementedException();
+    }
+}

data/tracks/csharp/exercises/pangram/Pangram.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/pangram/PangramTest.cs

@@ -1,84 +1,74 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class PangramTest
 {
-    [Test]
+    [Fact]
     public void Empty_sentence()
     {
         var input = "";
-        Assert.That(Pangram.IsPangram(input), Is.EqualTo(false));
+        Assert.Equal(false, Pangram.IsPangram(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Pangram_with_only_lower_case()
     {
         var input = "the quick brown fox jumps over the lazy dog";
-        Assert.That(Pangram.IsPangram(input), Is.EqualTo(true));
+        Assert.Equal(true, Pangram.IsPangram(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Missing_character_x()
     {
         var input = "a quick movement of the enemy will jeopardize five gunboats";
-        Assert.That(Pangram.IsPangram(input), Is.EqualTo(false));
+        Assert.Equal(false, Pangram.IsPangram(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Another_missing_character_x()
     {
         var input = "the quick brown fish jumps over the lazy dog";
-        Assert.That(Pangram.IsPangram(input), Is.EqualTo(false));
+        Assert.Equal(false, Pangram.IsPangram(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Pangram_with_underscores()
     {
         var input = "the_quick_brown_fox_jumps_over_the_lazy_dog";
-        Assert.That(Pangram.IsPangram(input), Is.EqualTo(true));
+        Assert.Equal(true, Pangram.IsPangram(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Pangram_with_numbers()
     {
         var input = "the 1 quick brown fox jumps over the 2 lazy dogs";
-        Assert.That(Pangram.IsPangram(input), Is.EqualTo(true));
+        Assert.Equal(true, Pangram.IsPangram(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Missing_letters_replaced_by_numbers()
     {
         var input = "7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog";
-        Assert.That(Pangram.IsPangram(input), Is.EqualTo(false));
+        Assert.Equal(false, Pangram.IsPangram(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Pangram_with_mixed_case_and_punctuation()
     {
         var input = "\"Five quacking Zephyrs jolt my wax bed.\"";
-        Assert.That(Pangram.IsPangram(input), Is.EqualTo(true));
+        Assert.Equal(true, Pangram.IsPangram(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Pangram_with_non_ascii_characters()
     {
         var input = "Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich.";
-        Assert.That(Pangram.IsPangram(input), Is.EqualTo(true));
+        Assert.Equal(true, Pangram.IsPangram(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Pangram_in_alphabet_other_than_ascii()
     {
         var input = "Широкая электрификация южных губерний даст мощный толчок подъёму сельского хозяйства.";
-        Assert.That(Pangram.IsPangram(input), Is.EqualTo(false));
+        Assert.Equal(false, Pangram.IsPangram(input));
     }
 }

data/tracks/csharp/exercises/parallel-letter-frequency/ParallelLetterFrequency.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+public static class ParallelLetterFrequency
+{
+    public static Dictionary<char, int> Calculate(IEnumerable<string> texts)
+    {
+        throw new NotImplementedException();
+    }
+}

data/tracks/csharp/exercises/parallel-letter-frequency/ParallelLetterFrequency.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/parallel-letter-frequency/ParallelLetterFrequencyTest.cs

@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
-using NUnit.Framework;
+using Xunit;
 
 public class ParallelLetterParallelLetterFrequency
 {
@@ -37,17 +37,16 @@ public class ParallelLetterParallelLetterFrequency
         "O say does that star-spangled banner yet wave,\n" +
         "O'er the land of the free and the home of the brave?\n";
 
-    [Test]
+    [Fact]
     public void No_texts_mean_no_letters()
     {
         var input = Enumerable.Empty<string>();
         var actual = ParallelLetterFrequency.Calculate(input);
         var expected = new Dictionary<char, int>();
-        Assert.That(actual, Is.EquivalentTo(expected));
+        Assert.Equal(expected, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_letter()
     {
         var input = new[] { "a" };
@@ -56,11 +55,10 @@ public class ParallelLetterParallelLetterFrequency
         {
             { 'a', 1 }
         };
-        Assert.That(actual, Is.EquivalentTo(expected));
+        Assert.Equal(expected, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Case_insensitivity()
     {
         var input = new[] { "aA" };
@@ -69,21 +67,19 @@ public class ParallelLetterParallelLetterFrequency
         {
             { 'a', 2 }
         };
-        Assert.That(actual, Is.EquivalentTo(expected));
+        Assert.Equal(expected, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Many_empty_texts_still_mean_no_letters()
     {
         var input = Enumerable.Repeat("  ", 10000);
         var actual = ParallelLetterFrequency.Calculate(input);
         var expected = new Dictionary<char, int>();
-        Assert.That(actual, Is.EquivalentTo(expected));
+        Assert.Equal(expected, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Many_times_the_same_text_gives_a_predictable_result()
     {
         var input = Enumerable.Repeat("abc", 1000);
@@ -94,11 +90,10 @@ public class ParallelLetterParallelLetterFrequency
             { 'b', 1000 },
             { 'c', 1000 }
         };
-        Assert.That(actual, Is.EquivalentTo(expected));
+        Assert.Equal(expected, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Punctuation_doesnt_count()
     {
         var input = new[] { OdeAnDieFreude };
@@ -106,8 +101,7 @@ public class ParallelLetterParallelLetterFrequency
         Assert.False(actual.ContainsKey(','));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Numbers_dont_count()
     {
         var input = new[] { "Testing, 1, 2, 3" };
@@ -115,14 +109,13 @@ public class ParallelLetterParallelLetterFrequency
         Assert.False(actual.ContainsKey('1'));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void All_three_anthems_together()
     {
         var input = new[] { OdeAnDieFreude, Wilhelmus, StarSpangledBanner };
         var actual = ParallelLetterFrequency.Calculate(input);
-        Assert.That(actual['a'], Is.EqualTo(49));
-        Assert.That(actual['t'], Is.EqualTo(56));
-        Assert.That(actual['ü'], Is.EqualTo(2));
+        Assert.Equal(49, actual['a']);
+        Assert.Equal(56, actual['t']);
+        Assert.Equal(2, actual['ü']);
     }
 }

data/tracks/csharp/exercises/pascals-triangle/PascalsTriangle.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+public static class PascalsTriangle
+{
+    public static IEnumerable<IEnumerable<int>> Calculate(int rows)
+    {
+        throw new NotImplementedException();
+    }
+}

data/tracks/csharp/exercises/pascals-triangle/PascalsTriangle.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/pascals-triangle/PascalsTriangleTest.cs

@@ -1,52 +1,80 @@
-using System.Linq;
-using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
 
 public class PascalsTriangleTest
 {
-    [Test]
+    [Fact]
     public void One_row()
     {
         var actual = PascalsTriangle.Calculate(1);
-        Assert.That(actual, Is.EqualTo(new[] { new[] { 1 } }));
+        var expected = new[] { new[] { 1 } };
+        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
     }
     
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_rows()
     {
-        var actual = PascalsTriangle.Calculate(2);
-        Assert.That(actual, Is.EqualTo(new[] { new[] { 1 }, new[] { 1, 1 } }));
+        var actual = PascalsTriangle.Calculate(2).ToArray();
+        var expected = new[] { new[] { 1 }, new[] { 1, 1 } };
+        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Three_rows()
     {
         var actual = PascalsTriangle.Calculate(3);
-        Assert.That(actual, Is.EqualTo(new[] { new[] { 1 }, new[] { 1, 1 }, new[] { 1, 2, 1 } }));
+        var expected = new[] { new[] { 1 }, new[] { 1, 1 }, new[] { 1, 2, 1 } };
+        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Four_rows()
     {
         var actual = PascalsTriangle.Calculate(4);
-        Assert.That(actual, Is.EqualTo(new[] { new[] { 1 }, new[] { 1, 1 }, new[] { 1, 2, 1 }, new[] { 1, 3, 3, 1 } }));
+        var expected = new[] { new[] { 1 }, new[] { 1, 1 }, new[] { 1, 2, 1 }, new[] { 1, 3, 3, 1 } };
+        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Five_rows()
     {
         var actual = PascalsTriangle.Calculate(5);
-        Assert.That(actual, Is.EqualTo(new[] { new[] { 1 }, new[] { 1, 1 }, new[] { 1, 2, 1 }, new[] { 1, 3, 3, 1 }, new [] { 1, 4, 6, 4, 1 } }));
+        var expected = new[] { new[] { 1 }, new[] { 1, 1 }, new[] { 1, 2, 1 }, new[] { 1, 3, 3, 1 }, new[] { 1, 4, 6, 4, 1 } };
+        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Twenty_rows()
     {
         var actual = PascalsTriangle.Calculate(20).Last();
-        Assert.That(actual, Is.EqualTo(new[] { 1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1 }));
+        var expected = new[] { 1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1 };
+        Assert.Equal(expected, actual);
+    }
+
+    private class EnumerableEqualityComparer<T> : IEqualityComparer<IEnumerable<T>>
+    {
+        public static readonly EnumerableEqualityComparer<T> Instance = new EnumerableEqualityComparer<T>();
+
+        public bool Equals(IEnumerable<T> x, IEnumerable<T> y) => x.SequenceEqual(y);
+
+        public int GetHashCode(IEnumerable<T> obj)
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+    private class NestedEnumerableEqualityComparer<T> : IEqualityComparer<IEnumerable<IEnumerable<T>>>
+    {
+        public static readonly NestedEnumerableEqualityComparer<T> Instance = new NestedEnumerableEqualityComparer<T>();
+
+        public bool Equals(IEnumerable<IEnumerable<T>> x, IEnumerable<IEnumerable<T>> y)
+            => x.SequenceEqual(y, EnumerableEqualityComparer<T>.Instance);
+
+        public int GetHashCode(IEnumerable<IEnumerable<T>> obj)
+        {
+            throw new NotImplementedException();
+        }
     }
 }