trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/proverb/Proverb.cs

@@ -0,0 +1,14 @@
+using System;
+
+public static class Proverb
+{
+    public static string Line(int line)
+    {
+        throw new NotImplementedException();
+    }
+
+    public static string AllLines()
+    {
+        throw new NotImplementedException();
+    }
+}

data/tracks/csharp/exercises/proverb/Proverb.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/proverb/ProverbTest.cs

@@ -1,29 +1,26 @@
-using NUnit.Framework;
+using Xunit;
 
 public class ProverbTest
 {
-    [Test]
+    [Fact]
     public void Line_one()
     {
-        Assert.That(Proverb.Line(1), Is.EqualTo("For want of a nail the shoe was lost."));
+        Assert.Equal("For want of a nail the shoe was lost.", Proverb.Line(1));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Line_four()
     {
-        Assert.That(Proverb.Line(4), Is.EqualTo("For want of a rider the message was lost."));
+        Assert.Equal("For want of a rider the message was lost.", Proverb.Line(4));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Line_seven()
     {
-        Assert.That(Proverb.Line(7), Is.EqualTo("And all for the want of a horseshoe nail."));
+        Assert.Equal("And all for the want of a horseshoe nail.", Proverb.Line(7));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void All_lines()
     {
         const string expected = "For want of a nail the shoe was lost.\n" +
@@ -34,6 +31,6 @@ public class ProverbTest
                                 "For want of a battle the kingdom was lost.\n" +
                                 "And all for the want of a horseshoe nail.";
 
-        Assert.That(Proverb.AllLines(), Is.EqualTo(expected));
+        Assert.Equal(expected, Proverb.AllLines());
     }
 }

data/tracks/csharp/exercises/pythagorean-triplet/PythagoreanTriplet.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+
+public class Triplet
+{
+    public Triplet(int a, int b, int c)
+    {
+    }
+
+    public int Sum()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public int Product()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public bool IsPythagorean()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public static IEnumerable<Triplet> Where(int maxFactor, int minFactor = 1, int sum = 0)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/pythagorean-triplet/PythagoreanTriplet.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/pythagorean-triplet/PythagoreanTripletTest.cs

@@ -1,54 +1,49 @@
 using System.Linq;
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class PythagoreanTripletTest
 {
-    [Test]
+    [Fact]
     public void Calculates_the_sum()
     {
-        Assert.That(new Triplet(3, 4, 5).Sum(), Is.EqualTo(12));
+        Assert.Equal(12, new Triplet(3, 4, 5).Sum());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Calculates_the_product()
     {
-        Assert.That(new Triplet(3, 4, 5).Product(), Is.EqualTo(60));
+        Assert.Equal(60, new Triplet(3, 4, 5).Product());
     }
 
-    [Ignore("Remove to run test")]
-    [TestCase(3, 4, 5, ExpectedResult = true)]
-    [TestCase(5, 6, 7, ExpectedResult = false)]
-    public bool Can_recognize_a_valid_pythagorean(int a, int b, int c)
+    [Theory(Skip = "Remove to run test")]
+    [InlineData(3, 4, 5, true)]
+    [InlineData(5, 6, 7, false)]
+    public void Can_recognize_a_valid_pythagorean(int a, int b, int c, bool expected)
     {
-        return new Triplet(a, b, c).IsPythagorean();
+        Assert.Equal(expected, new Triplet(a, b, c).IsPythagorean());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_make_triplets_up_to_10()
     {
         var triplets = Triplet.Where(maxFactor: 10);
         var products = triplets.Select(x => x.Product()).OrderBy(x => x);
-        Assert.That(products, Is.EqualTo(new[] { 60, 480 }));
+        Assert.Equal(new[] { 60, 480 }, products);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_make_triplets_from_11_to_20()
     {
         var triplets = Triplet.Where(minFactor: 11, maxFactor: 20);
         var products = triplets.Select(x => x.Product());
-        Assert.That(products, Is.EqualTo(new[] { 3840 }));
+        Assert.Equal(new[] { 3840 }, products);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_make_triplets_filtered_on_sum()
     {
         var triplets = Triplet.Where(sum: 180, maxFactor: 100);
         var products = triplets.Select(x => x.Product()).OrderBy(x => x);
-        Assert.That(products, Is.EqualTo(new[] { 118080, 168480, 202500 }));
+        Assert.Equal(new[] { 118080, 168480, 202500 }, products);
     }
 }

data/tracks/csharp/exercises/queen-attack/Example.cs

@@ -12,26 +12,17 @@ public class Queen
     public int Column { get; }
 }
 
-public class Queens
+public static class Queens
 {
-    private readonly Queen _white;
-    private readonly Queen _black;
-
-    public Queens(Queen white, Queen black)
+    public static bool CanAttack(Queen white, Queen black)
     {
         if (white.Row == black.Row && white.Column == black.Column)
         {
             throw new ArgumentException("The queens cannot be positioned at the same place.");
         }
 
-        _black = black;
-        _white = white;
-    }
-
-    public bool CanAttack()
-    {
-        return _black.Row == _white.Row ||
-               _black.Column == _white.Column ||
-               Math.Abs(_black.Row - _white.Row) == Math.Abs(_black.Column - _white.Column);
+        return black.Row == white.Row ||
+               black.Column == white.Column ||
+               Math.Abs(black.Row - white.Row) == Math.Abs(black.Column - white.Column);
     }
 }

data/tracks/csharp/exercises/queen-attack/QueenAttack.cs

@@ -0,0 +1,21 @@
+using System;
+
+public class Queen
+{
+    public Queen(int row, int column)
+    {
+        Row = row;
+        Column = column;
+    }
+
+    public int Row { get; }
+    public int Column { get; }
+}
+
+public static class Queens
+{
+    public static bool CanAttack(Queen white, Queen black)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/queen-attack/QueenAttack.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/queen-attack/QueenAttackTest.cs

@@ -1,69 +1,55 @@
 using System;
-using NUnit.Framework;
+using Xunit;
 
 public class QueenAttackTest
 {
-    [Test]
+    [Fact]
     public void Cannot_occupy_same_space()
     {
         var white = new Queen(2, 4);
         var black = new Queen(2, 4);
-        Assert.Throws<ArgumentException>(() => new Queens(white, black));
+        Assert.Throws<ArgumentException>(() => Queens.CanAttack(white, black));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cannot_attack()
     {
-        var queens = new Queens(new Queen(2, 3), new Queen(4, 7));
-        Assert.False(queens.CanAttack());
+        Assert.False(Queens.CanAttack(new Queen(2, 3), new Queen(4, 7)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_attack_on_same_row()
     {
-        var queens = new Queens(new Queen(2, 4), new Queen(2, 7));
-        Assert.True(queens.CanAttack());
+        Assert.True(Queens.CanAttack(new Queen(2, 4), new Queen(2, 7)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_attack_on_same_column()
     {
-        var queens = new Queens(new Queen(5, 4), new Queen(2, 4));
-        Assert.True(queens.CanAttack());
+        Assert.True(Queens.CanAttack(new Queen(5, 4), new Queen(2, 4)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_attack_on_diagonal()
     {
-        var queens = new Queens(new Queen(1, 1), new Queen(6, 6));
-        Assert.True(queens.CanAttack());
+        Assert.True(Queens.CanAttack(new Queen(1, 1), new Queen(6, 6)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_attack_on_other_diagonal()
     {
-        var queens = new Queens(new Queen(0, 6), new Queen(1, 7));
-        Assert.True(queens.CanAttack());
+        Assert.True(Queens.CanAttack(new Queen(0, 6), new Queen(1, 7)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_attack_on_yet_another_diagonal()
     {
-        var queens = new Queens(new Queen(4, 1), new Queen(6, 3));
-        Assert.True(queens.CanAttack());
+        Assert.True(Queens.CanAttack(new Queen(4, 1), new Queen(6, 3)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_attack_on_a_diagonal_slanted_the_other_way()
     {
-        var queens = new Queens(new Queen(6, 1), new Queen(1, 6));
-        Assert.True(queens.CanAttack());
+        Assert.True(Queens.CanAttack(new Queen(6, 1), new Queen(1, 6)));
     }
 }

data/tracks/csharp/exercises/rail-fence-cipher/RailFenceCipher.cs

@@ -0,0 +1,18 @@
+using System;
+
+public class RailFenceCipher
+{
+    public RailFenceCipher(int rails)
+    {
+    }
+
+    public string Encode(string input)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public string Decode(string input)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/rail-fence-cipher/RailFenceCipher.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/rail-fence-cipher/RailFenceCipherTest.cs

@@ -1,63 +1,58 @@
-using NUnit.Framework;
+using Xunit;
 
 public class RailFenceCipherTest
 {
-    [Test]
+    [Fact]
     public void Encode_with_two_rails()
     {
         var railFenceCipher = new RailFenceCipher(2);
         var actual = railFenceCipher.Encode("XOXOXOXOXOXOXOXOXO");
         var expected = "XXXXXXXXXOOOOOOOOO";
-        Assert.That(actual, Is.EqualTo(expected));
+        Assert.Equal(expected, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Encode_with_three_rails()
     {
         var railFenceCipher = new RailFenceCipher(3);
         var actual = railFenceCipher.Encode("WEAREDISCOVEREDFLEEATONCE");
         var expected = "WECRLTEERDSOEEFEAOCAIVDEN";
-        Assert.That(actual, Is.EqualTo(expected));
+        Assert.Equal(expected, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Encode_with_ending_in_the_middle()
     {
         var railFenceCipher = new RailFenceCipher(4);
         var actual = railFenceCipher.Encode("EXERCISES");
         var expected = "ESXIEECSR";
-        Assert.That(actual, Is.EqualTo(expected));
+        Assert.Equal(expected, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Decode_with_three_rails()
     {
         var railFenceCipher = new RailFenceCipher(3);
         var actual = railFenceCipher.Decode("TEITELHDVLSNHDTISEIIEA");
         var expected = "THEDEVILISINTHEDETAILS";
-        Assert.That(actual, Is.EqualTo(expected));
+        Assert.Equal(expected, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Decode_with_five_rails()
     {
         var railFenceCipher = new RailFenceCipher(5);
         var actual = railFenceCipher.Decode("EIEXMSMESAORIWSCE");
         var expected = "EXERCISMISAWESOME";
-        Assert.That(actual, Is.EqualTo(expected));
+        Assert.Equal(expected, actual);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Decode_with_six_rails()
     {
         var railFenceCipher = new RailFenceCipher(6);
         var actual = railFenceCipher.Decode("133714114238148966225439541018335470986172518171757571896261");
         var expected = "112358132134558914423337761098715972584418167651094617711286";
-        Assert.That(actual, Is.EqualTo(expected));
+        Assert.Equal(expected, actual);
     }
 }