trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/custom-set/Example.cs

@@ -1,8 +1,9 @@
-using System.Collections;
+using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
-public class CustomSet<T> : IEnumerable<T>
+public class CustomSet<T> : IEnumerable<T>, IEquatable<IEnumerable<T>>
 {
     private readonly Dictionary<int, T> items = new Dictionary<int, T>();
 
@@ -69,4 +70,21 @@ public class CustomSet<T> : IEnumerable<T>
     }
 
     private IEnumerable<T> GetValuesFromKeys(IEnumerable<int> keys) => keys.Select(key => items[key]);
+    
+    public override bool Equals(object obj) => Equals(obj as IEnumerable<T>);
+
+    public override int GetHashCode() 
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool Equals(IEnumerable<T> other)
+    {
+        return items.Keys.OrderBy(x => x).SequenceEqual(other.Select(o => o.GetHashCode()).OrderBy(x => x));
+    }
+
+    public int GetHashCode(IEnumerable<T> obj)
+    {
+        throw new NotImplementedException();
+    }
 }

data/tracks/csharp/exercises/diamond/Diamond.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class Diamond
+{
+    public static string Make(char target)
+    {
+        throw new NotImplementedException("Please implement this function");
+    }
+}

data/tracks/csharp/exercises/diamond/Diamond.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/diamond/DiamondTest.cs

@@ -1,38 +1,44 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
-using NUnit.Framework;
+using Xunit;
 
 public class DiamondTest
 {
-    private static readonly char[] Letters = GetLetterRange('A', 'Z');
+    public static readonly char[] AllLetters = GetLetterRange('A', 'Z');
+    public static readonly IEnumerable<object[]> Letters = AllLetters.Select(letter => new[] { (object)letter });
     private static char[] GetLetterRange(char min, char max) => Enumerable.Range(min, max - min + 1).Select(i => (char) i).ToArray();
     private static string[] Rows(string x) => x.Split(new[] { '\n' }, StringSplitOptions.None);
 
-    private static string LeadingSpaces(string x) => x.Substring(0, x.IndexOfAny(Letters));
-    private static string TrailingSpaces(string x) => x.Substring(x.LastIndexOfAny(Letters) + 1);
+    private static string LeadingSpaces(string x) => x.Substring(0, x.IndexOfAny(AllLetters));
+    private static string TrailingSpaces(string x) => x.Substring(x.LastIndexOfAny(AllLetters) + 1);
 
-    [TestCaseSource(nameof(Letters))]
+    [Theory]
+    [MemberData(nameof(Letters))]
     public void First_row_contains_A(char letter)
     {
         var actual = Diamond.Make(letter);
         var rows = Rows(actual);
         var firstRowCharacters = rows.First().Trim();
 
-        Assert.That(firstRowCharacters, Is.EqualTo("A"));
+        Assert.Equal("A", firstRowCharacters);
     }
 
-    [Ignore("Remove to run test")]
-    [TestCaseSource(nameof(Letters))]
+    [Theory(Skip = "Remove to run test")]
+    [MemberData(nameof(Letters))]
     public void All_rows_must_have_symmetric_contour(char letter)
     {
         var actual = Diamond.Make(letter);
         var rows = Rows(actual);
 
-        Assert.That(rows, Is.All.Matches<string>(row => LeadingSpaces(row) == TrailingSpaces(row)));
+        Assert.All(rows, row => 
+        {
+            Assert.Equal(LeadingSpaces(row), TrailingSpaces(row));
+        });
     }
 
-    [Ignore("Remove to run test")]
-    [TestCaseSource(nameof(Letters))]
+    [Theory(Skip = "Remove to run test")]
+    [MemberData(nameof(Letters))]
     public void Top_of_figure_has_letters_in_correct_order(char letter)
     {
         var actual = Diamond.Make(letter);
@@ -40,11 +46,11 @@ public class DiamondTest
 
         var expected = GetLetterRange('A', letter);
         var firstNonSpaceLetters = rows.Take(expected.Length).Select(row => row.Trim()[0]);
-        Assert.That(expected, Is.EqualTo(firstNonSpaceLetters));
+        Assert.Equal(firstNonSpaceLetters, expected);
     }
 
-    [Ignore("Remove to run test")]
-    [TestCaseSource(nameof(Letters))]
+    [Theory(Skip = "Remove to run test")]
+    [MemberData(nameof(Letters))]
     public void Figure_is_symmetric_around_the_horizontal_axis(char letter)
     {
         var actual = Diamond.Make(letter);
@@ -53,11 +59,11 @@ public class DiamondTest
         var top = rows.TakeWhile(row => !row.Contains(letter));
         var bottom = rows.Reverse().TakeWhile(row => !row.Contains(letter));
 
-        Assert.That(top, Is.EqualTo(bottom));
+        Assert.Equal(bottom, top);
     }
 
-    [Ignore("Remove to run test")]
-    [TestCaseSource(nameof(Letters))]
+    [Theory(Skip = "Remove to run test")]
+    [MemberData(nameof(Letters))]
     public void Diamond_has_square_shape(char letter)
     {
         var actual = Diamond.Make(letter);
@@ -65,27 +71,30 @@ public class DiamondTest
         var rows = Rows(actual);
         var expected = rows.Length;
 
-        Assert.That(rows, Is.All.Matches<string>(row => row.Length == expected));
+        Assert.All(rows, row =>
+        {
+            Assert.Equal(expected, row.Length);
+        });
     }
 
-    [Ignore("Remove to run test")]
-    [TestCaseSource(nameof(Letters))]
+    [Theory(Skip = "Remove to run test")]
+    [MemberData(nameof(Letters))]
     public void All_rows_except_top_and_bottom_have_two_identical_letters(char letter)
     {
         var actual = Diamond.Make(letter);
 
         var rows = Rows(actual).Where(row => !row.Contains('A'));
 
-        Assert.That(rows, Is.All.Matches<string>(row =>
+        Assert.All(rows, row =>
         {
             var twoCharacters = row.Replace(" ", "").Length == 2;
             var identicalCharacters = row.Replace(" ", "").Distinct().Count() == 1;
-            return twoCharacters && identicalCharacters;
-        }));
+            Assert.True(twoCharacters && identicalCharacters, "Does not have two identical letters");
+        });
     }
 
-    [Ignore("Remove to run test")]
-    [TestCaseSource(nameof(Letters))]
+    [Theory(Skip = "Remove to run test")]
+    [MemberData(nameof(Letters))]
     public void Bottom_left_corner_spaces_are_triangle(char letter)
     {
         var actual = Diamond.Make(letter);
@@ -96,6 +105,6 @@ public class DiamondTest
         var spaceCounts = cornerSpaces.Select(row => row.Length).ToList();
         var expected = Enumerable.Range(0, spaceCounts.Count).Select(i => i).ToList();
 
-        Assert.That(spaceCounts, Is.EqualTo(expected));
+        Assert.Equal(expected, spaceCounts);
     }
 }

data/tracks/csharp/exercises/difference-of-squares/DifferenceOfSquares.cs

@@ -0,0 +1,19 @@
+using System;
+
+public static class Squares
+{
+    public static int SquareOfSums(int max)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public static int SumOfSquares(int max)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public static int DifferenceOfSquares(int max)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/difference-of-squares/DifferenceOfSquares.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/difference-of-squares/DifferenceOfSquaresTest.cs

@@ -1,82 +1,65 @@
 using System;
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class DifferenceOfSquaresTests
 {
-    [Test]
+    [Fact]
     public void Test_square_of_sums_to_5()
     {
-        Assert.That(new Squares(5).SquareOfSums(), Is.EqualTo(225));
+        Assert.Equal(225, Squares.SquareOfSums(5));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_sum_of_squares_to_5()
     {
-        Assert.That(new Squares(5).SumOfSquares(), Is.EqualTo(55));
+        Assert.Equal(55, Squares.SumOfSquares(5));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_difference_of_sums_to_5()
     {
-        Assert.That(new Squares(5).DifferenceOfSquares(), Is.EqualTo(170));
+        Assert.Equal(170, Squares.DifferenceOfSquares(5));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_square_of_sums_to_10()
     {
-        Assert.That(new Squares(10).SquareOfSums(), Is.EqualTo(3025));
+        Assert.Equal(3025, Squares.SquareOfSums(10));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_sum_of_squares_to_10()
     {
-        Assert.That(new Squares(10).SumOfSquares(), Is.EqualTo(385));
+        Assert.Equal(385, Squares.SumOfSquares(10));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_difference_of_sums_to_10()
     {
-        Assert.That(new Squares(10).DifferenceOfSquares(), Is.EqualTo(2640));
+        Assert.Equal(2640, Squares.DifferenceOfSquares(10));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_square_of_sums_to_100()
     {
-        Assert.That(new Squares(100).SquareOfSums(), Is.EqualTo(25502500));
+        Assert.Equal(25502500, Squares.SquareOfSums(100));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_sum_of_squares_to_100()
     {
-        Assert.That(new Squares(100).SumOfSquares(), Is.EqualTo(338350));
+        Assert.Equal(338350, Squares.SumOfSquares(100));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_difference_of_sums_to_100()
     {
-        Assert.That(new Squares(100).DifferenceOfSquares(), Is.EqualTo(25164150));
+        Assert.Equal(25164150, Squares.DifferenceOfSquares(100));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_difference_of_sums_0()
     {
-        Assert.That(new Squares(0).DifferenceOfSquares(), Is.EqualTo(0));
-    }
-
-    [Ignore("Remove to run test")]
-    [Test]
-    public void Test_negative_numbers_throw_argument_out_of_range_exception()
-    {
-        Assert.That(() => new Squares(-5), Throws.TypeOf<ArgumentOutOfRangeException>());
+        Assert.Equal(0, Squares.DifferenceOfSquares(0));
     }
 }

data/tracks/csharp/exercises/difference-of-squares/Example.cs

@@ -1,35 +1,23 @@
 using System;
 using System.Linq;
 
-public class Squares
+public static class Squares
 {
-    private readonly int max;
-
-    public Squares(int max)
-    {
-        if (max < 0)
-        {
-            throw new ArgumentOutOfRangeException("Max must be positive", "max");
-        }
-
-        this.max = max;
-    }
-
-    public int SquareOfSums()
+    public static int SquareOfSums(int max)
     {
         var numbers = Enumerable.Range(1, max);
         int sum = numbers.Sum();
         return sum * sum;
     }
 
-    public int SumOfSquares()
+    public static int SumOfSquares(int max)
     {
         var numbers = Enumerable.Range(1, max);
         return numbers.Select(x => x * x).Sum();
     }
 
-    public int DifferenceOfSquares()
+    public static int DifferenceOfSquares(int max)
     {
-        return SquareOfSums() - SumOfSquares();
+        return SquareOfSums(max) - SumOfSquares(max);
     }
 }

data/tracks/csharp/exercises/diffie-hellman/DiffieHellman.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Numerics;
+
+public static class DiffieHellman
+{
+    public static BigInteger PrivateKey(BigInteger primeP) 
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public static BigInteger PublicKey(BigInteger primeP, BigInteger primeG, BigInteger privateKey) 
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public static BigInteger Secret(BigInteger primeP, BigInteger publicKey, BigInteger privateKey) 
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/diffie-hellman/DiffieHellman.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/diffie-hellman/DiffieHellmanTest.cs

@@ -1,30 +1,31 @@
 using System.Linq;
 using System.Numerics;
-using NUnit.Framework;
+using Xunit;
 
 public class DiffieHellmanTest
 {
-    [Test]
+    [Fact]
     public void Private_key_in_range()
     {
         var primeP = new BigInteger(23);
         var privateKeys = Enumerable.Range(0, 10).Select(_ => DiffieHellman.PrivateKey(primeP)).ToList();
-        Assert.That(privateKeys, Is.All.InRange(new BigInteger(1), primeP - new BigInteger(1)));
+        Assert.All(privateKeys, privateKey => 
+        {
+            Assert.InRange(privateKey, new BigInteger(1), primeP - new BigInteger(1));
+        });
     }
 
     // Note: due to the nature of randomness, there is always a chance that this test fails
     // Be sure to check the actual generated values
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Private_key_randomly_generated()
     {
         var primeP = new BigInteger(7919);
         var privateKeys = Enumerable.Range(0, 5).Select(_ => DiffieHellman.PrivateKey(primeP)).ToList();
-        Assert.That(privateKeys.Count, Is.EqualTo(privateKeys.Distinct().Count()));
+        Assert.Equal(privateKeys.Distinct().Count(), privateKeys.Count);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Public_key_correctly_calculated()
     {
         var primeP = new BigInteger(23);
@@ -32,11 +33,10 @@ public class DiffieHellmanTest
         var privateKey = new BigInteger(6);
 
         var actual = DiffieHellman.PublicKey(primeP, primeG, privateKey);
-        Assert.That(actual, Is.EqualTo(new BigInteger(8)));
+        Assert.Equal(new BigInteger(8), actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Secret_key_correctly_calculated()
     {
         var primeP = new BigInteger(23);
@@ -44,11 +44,10 @@ public class DiffieHellmanTest
         var privateKey = new BigInteger(6);
 
         var actual = DiffieHellman.Secret(primeP, publicKey, privateKey);
-        Assert.That(actual, Is.EqualTo(new BigInteger(2)));
+        Assert.Equal(new BigInteger(2), actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Secret_key_correctly_calculated_when_using_large_primes()
     {
         var primeP = BigInteger.Parse("120227323036150778550155526710966921740030662694578947298423549235265759593711587341037426347114541533006628856300552706996143592240453345642869233562886752930249953227657883929905072620233073626594386072962776144691433658814261874113232461749035425712805067202910389407991986070558964461330091797026762932543");
@@ -56,11 +55,10 @@ public class DiffieHellmanTest
         var privateKey = BigInteger.Parse("2483479393625932939911081304356888505153797135447327501792696199190469015215177630758617902200417377685436170904594686456961202706692908603181062371925882");
         var expected = BigInteger.Parse("70900735223964890815905879227737819348808518698920446491346508980461201746567735331455825644429877946556431095820785835497384849778344216981228226252639932672153547963980483673419756271345828771971984887453014488572245819864454136618980914729839523581263886740821363010486083940557620831348661126601106717071");
         var actual = DiffieHellman.Secret(primeP, publicKey, privateKey);
-        Assert.That(actual, Is.EqualTo(expected));
+        Assert.Equal(expected, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_exchange()
     {
         var primeP = new BigInteger(23);
@@ -75,6 +73,6 @@ public class DiffieHellmanTest
         var secretA = DiffieHellman.Secret(primeP, publicKeyB, privateKeyA);
         var secretB = DiffieHellman.Secret(primeP, publicKeyA, privateKeyB);
 
-        Assert.That(secretA, Is.EqualTo(secretB));
+        Assert.Equal(secretB, secretA);
     }
 }