trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/scrabble-score/ScrabbleScore.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class Scrabble
+{
+    public static int Score(string input)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/scrabble-score/ScrabbleScore.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/scrabble-score/ScrabbleScoreTest.cs

@@ -1,67 +1,58 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class ScrabbleScoreTest
 {
-    [Test]
+    [Fact]
     public void Empty_word_scores_zero()
     {
-        Assert.That(Scrabble.Score(""), Is.EqualTo(0));
+        Assert.Equal(0, Scrabble.Score(""));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Whitespace_scores_zero()
     {
-        Assert.That(Scrabble.Score(" \t\n"), Is.EqualTo(0));
+        Assert.Equal(0, Scrabble.Score(" \t\n"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Null_scores_zero()
     {
-        Assert.That(Scrabble.Score(null), Is.EqualTo(0));
+        Assert.Equal(0, Scrabble.Score(null));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Scores_very_short_word()
     {
-        Assert.That(Scrabble.Score("a"), Is.EqualTo(1));
+        Assert.Equal(1, Scrabble.Score("a"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Scores_other_very_short_word()
     {
-        Assert.That(Scrabble.Score("f"), Is.EqualTo(4));
+        Assert.Equal(4, Scrabble.Score("f"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Simple_word_scores_the_number_of_letters()
     {
-        Assert.That(Scrabble.Score("street"), Is.EqualTo(6));
+        Assert.Equal(6, Scrabble.Score("street"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Complicated_word_scores_more()
     {
-        Assert.That(Scrabble.Score("quirky"), Is.EqualTo(22));
+        Assert.Equal(22, Scrabble.Score("quirky"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Scores_are_case_insensitive()
     {
-        Assert.That(Scrabble.Score("OXYPHENBUTAZONE"), Is.EqualTo(41));
+        Assert.Equal(41, Scrabble.Score("OXYPHENBUTAZONE"));
     }
     
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Entire_alphabet()
     {
-        Assert.That(Scrabble.Score("abcdefghijklmnopqrstuvwxyz"), Is.EqualTo(87));
+        Assert.Equal(87, Scrabble.Score("abcdefghijklmnopqrstuvwxyz"));
     }
 }

data/tracks/csharp/exercises/secret-handshake/SecretHandshake.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Linq;
+
+public static class SecretHandshake
+{
+    public static string[] Commands(int commandValue)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/secret-handshake/SecretHandshake.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/secret-handshake/SecretHandshakeTest.cs

@@ -1,53 +1,46 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class SecretHandshakeTests
 {
-    [Test]
+    [Fact]
     public void Test_1_handshake_to_wink()
     {
-        Assert.That(SecretHandshake.Commands(1), Is.EqualTo(new[] { "wink" }));
+        Assert.Equal(new[] { "wink" }, SecretHandshake.Commands(1));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_10_handshake_to_double_blink()
     {
-        Assert.That(SecretHandshake.Commands(2), Is.EqualTo(new[] { "double blink" }));
+        Assert.Equal(new[] { "double blink" }, SecretHandshake.Commands(2));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_100_handshake_to_close_your_eyes()
     {
-        Assert.That(SecretHandshake.Commands(4), Is.EqualTo(new[] { "close your eyes" }));
+        Assert.Equal(new[] { "close your eyes" }, SecretHandshake.Commands(4));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_1000_handshake_to_close_your_eyes()
     {
-        Assert.That(SecretHandshake.Commands(8), Is.EqualTo(new[] { "jump" }));
+        Assert.Equal(new[] { "jump" }, SecretHandshake.Commands(8));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_handshake_11_to_wink_and_double_blink()
     {
-        Assert.That(SecretHandshake.Commands(3), Is.EqualTo(new[] { "wink", "double blink" }));
+        Assert.Equal(new[] { "wink", "double blink" }, SecretHandshake.Commands(3));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_handshake_10011_to_double_blink_and_wink()
     {
-        Assert.That(SecretHandshake.Commands(19), Is.EqualTo(new[] { "double blink", "wink" }));
+        Assert.Equal(new[] { "double blink", "wink" }, SecretHandshake.Commands(19));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Test_handshake_11111_to_all_commands_reversed()
     {
-        Assert.That(SecretHandshake.Commands(31), Is.EqualTo(new[] { "jump", "close your eyes", "double blink", "wink" }));
+        Assert.Equal(new[] { "jump", "close your eyes", "double blink", "wink" }, SecretHandshake.Commands(31));
     }
 }

data/tracks/csharp/exercises/series/Series.cs

@@ -0,0 +1,13 @@
+using System;
+
+public class Series
+{
+    public Series(string numbers)
+    {
+    }
+
+    public int[][] Slices(int sliceLength)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/series/Series.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/series/SeriesTest.cs

@@ -1,79 +1,80 @@
-using NUnit.Framework;
+using System;
+using Xunit;
 
-[TestFixture]
 public class SeriesTest
 {
-    private static readonly object[] SliceOneTestData =
+    public static readonly object[] SliceOneTestData =
         {
             new object[] { "01234", new[] { new[] { 0 }, new[] { 1 }, new[] { 2 }, new[] { 3 }, new[] { 4 } } },
             new object[] { "92834", new[] { new[] { 9 }, new[] { 2 }, new[] { 8 }, new[] { 3 }, new[] { 4 } } }
         };
 
-    [TestCaseSource("SliceOneTestData")]
+    [Theory]
+    [MemberData(nameof(SliceOneTestData))]
     public void Series_of_one_splits_to_one_digit(string input, int[][] result)
     {
-        Assert.That(new Series(input).Slices(1), Is.EqualTo(result));
+        Assert.Equal(result, new Series(input).Slices(1));
     }
 
-    private static readonly object[] SliceTwoTestData =
+    public static readonly object[] SliceTwoTestData =
         {
             new object[] { "01234", new[] { new[] { 0, 1 }, new[] { 1, 2 }, new[] { 2, 3 }, new[] { 3, 4 } } },
             new object[] { "98273463", new[] { new[] { 9, 8 }, new[] { 8, 2 }, new[] { 2, 7 }, new[] { 7, 3 }, new[] { 3, 4 }, new[] { 4, 6 }, new[] { 6, 3 } } },
             new object[] { "37103", new[] { new[] { 3, 7 }, new[] { 7, 1 }, new[] { 1, 0 }, new[] { 0, 3 } } }
         };
 
-    [Ignore("Remove to run test")]
-    [TestCaseSource("SliceTwoTestData")]
+    [Theory(Skip = "Remove to run test")]
+    [MemberData(nameof(SliceTwoTestData))]
     public void Series_of_two_splits_to_two_digits(string input, int[][] result)
     {
-        Assert.That(new Series(input).Slices(2), Is.EqualTo(result));
+        Assert.Equal(result, new Series(input).Slices(2));
     }
 
-    private static readonly object[] SliceThreeTestData =
+    public static readonly object[] SliceThreeTestData =
         {
             new object[] { "01234", new[] { new[] { 0, 1, 2 }, new[] { 1, 2, 3 }, new[] { 2, 3, 4 } } },
             new object[] { "31001", new[] { new[] { 3, 1, 0 }, new[] { 1, 0, 0 }, new[] { 0, 0, 1 } } },
             new object[] { "982347", new[] { new[] { 9, 8, 2 }, new[] { 8, 2, 3 }, new[] { 2, 3, 4 }, new[] { 3, 4, 7 } } }
         };
 
-    [Ignore("Remove to run test")]
-    [TestCaseSource("SliceThreeTestData")]
+    [Theory(Skip = "Remove to run test")]
+    [MemberData(nameof(SliceThreeTestData))]
     public void Series_of_three_splits_to_three_digits(string input, int[][] result)
     {
-        Assert.That(new Series(input).Slices(3), Is.EqualTo(result));
+        Assert.Equal(result, new Series(input).Slices(3));
     }
 
-    private static readonly object[] SliceFourTestData =
+    public static readonly object[] SliceFourTestData =
         {
             new object[] { "01234", new[] { new[] { 0, 1, 2, 3 }, new[] { 1, 2, 3, 4 } } },
             new object[] { "91274", new[] { new[] { 9, 1, 2, 7 }, new[] { 1, 2, 7, 4 } } }
         };
 
-    [Ignore("Remove to run test")]
-    [TestCaseSource("SliceFourTestData")]
+    [Theory(Skip = "Remove to run test")]
+    [MemberData(nameof(SliceFourTestData))]
     public void Series_of_four_splits_to_four_digits(string input, int[][] result)
     {
-        Assert.That(new Series(input).Slices(4), Is.EqualTo(result));
+        Assert.Equal(result, new Series(input).Slices(4));
     }
 
-    private static readonly object[] SliceFiveTestData =
+    public static readonly object[] SliceFiveTestData =
         {
             new object[] { "01234", new[] { new[] { 0, 1, 2, 3, 4 } } },
             new object[] { "81228", new[] { new[] { 8, 1, 2, 2, 8 } } }
         };
 
-    [Ignore("Remove to run test")]
-    [TestCaseSource("SliceFiveTestData")]
+    [Theory(Skip = "Remove to run test")]
+    [MemberData(nameof(SliceFiveTestData))]
     public void Series_of_five_splits_to_five_digits(string input, int[][] result)
     {
-        Assert.That(new Series(input).Slices(5), Is.EqualTo(result));
+        Assert.Equal(result, new Series(input).Slices(5));
     }
 
-    [Ignore("Remove to run test")]
-    [TestCase("01234", 6)]
-    [TestCase("01032987583", 19)]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData("01234", 6)]
+    [InlineData("01032987583", 19)]
     public void Slice_longer_than_input_is_not_allowed(string input, int slice)
     {
-        Assert.That(() => new Series(input).Slices(slice), Throws.ArgumentException);
+        Assert.Throws<ArgumentException>(() => new Series(input).Slices(slice));
     }
 }

data/tracks/csharp/exercises/sgf-parsing/Example.cs

@@ -34,7 +34,17 @@ public static class SgfParser
                 GameTree().Many().Then(trees => Parse.Char(')')
                     .Select(___ => NodesToTree(nodes, trees)))));
 
-    public static SgfTree ParseTree(string input) => GameTree().Parse(input);
+    public static SgfTree ParseTree(string input)
+    {
+        try
+        {
+            return GameTree().Parse(input);
+        }
+        catch (Exception e)
+        {
+            throw new ArgumentException(nameof(input), e);
+        }        
+    }
     
     private static SgfTree NodesToTree(IEnumerable<IDictionary<string, string[]>> properties, IEnumerable<SgfTree> trees)
     {

data/tracks/csharp/exercises/sgf-parsing/SgfParsing.cs

@@ -1,13 +1,22 @@
+using System;
 using System.Collections.Generic;
 
 public class SgfTree
 {
-    public IDictionary<string, string[]> Data { get; }
-    public SgfTree[] Children { get; }
-
     public SgfTree(IDictionary<string, string[]> data, params SgfTree[] children)
     {
         Data = data;
         Children = children;
     }
+
+    public IDictionary<string, string[]> Data { get; }
+    public SgfTree[] Children { get; }
+}
+
+public class SgfParser
+{
+    public static SgfTree ParseTree(string input)
+    {
+        throw new NotImplementedException();
+    }
 }

data/tracks/csharp/exercises/sgf-parsing/SgfParsing.csproj

@@ -0,0 +1,19 @@
+<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" />
+    <PackageReference Include="Sprache" Version="2.1.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/csharp/exercises/sgf-parsing/SgfParsingTest.cs

@@ -1,6 +1,7 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
-using NUnit.Framework;
+using Xunit;
 
 public class SgfParsingTest
 {
@@ -20,82 +21,73 @@ public class SgfParsingTest
 
     private static IDictionary<string, string[]> CreateData(string key, params string[] values) => new Dictionary<string, string[]> { [key] = values };
     
-    [Test]
+    [Fact]
     public void Empty_value()
     {
         const string input = "";
-        Assert.That(() => SgfParser.ParseTree(input), Throws.Exception);
+        Assert.Throws<ArgumentException>(() => SgfParser.ParseTree(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Tree_without_nodes()
     {
         const string input = "()";
-        Assert.That(() => SgfParser.ParseTree(input), Throws.Exception);
+        Assert.Throws<ArgumentException>(() => SgfParser.ParseTree(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Node_without_tree()
     {
         const string input = ";";
-        Assert.That(() => SgfParser.ParseTree(input), Throws.Exception);
+        Assert.Throws<ArgumentException>(() => SgfParser.ParseTree(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Node_without_properties()
     {
         const string input = "(;)";
         var expected = TreeWithNoChildren(new Dictionary<string, string[]>());
-        Assert.That(SgfParser.ParseTree(input), Is.EqualTo(expected).Using(SgfTreeEqualityComparer.Instance));
+        Assert.Equal(expected, SgfParser.ParseTree(input), SgfTreeEqualityComparer.Instance);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Single_node_tree()
     {
         const string input = "(;A[B])";
         var expected = TreeWithNoChildren(CreateData("A", "B"));
-        Assert.That(SgfParser.ParseTree(input), Is.EqualTo(expected).Using(SgfTreeEqualityComparer.Instance));
+        Assert.Equal(expected, SgfParser.ParseTree(input), SgfTreeEqualityComparer.Instance);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Properties_without_delimiter()
     {
         const string input = "(;a)";
-        Assert.That(() => SgfParser.ParseTree(input), Throws.Exception);
+        Assert.Throws<ArgumentException>(() => SgfParser.ParseTree(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void All_lowercase_property()
     {
         const string input = "(;a[b])";
-        Assert.That(() => SgfParser.ParseTree(input), Throws.Exception);
+        Assert.Throws<ArgumentException>(() => SgfParser.ParseTree(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Upper_and_lowercase_property()
     {
         const string input = "(;Aa[b])";
-        Assert.That(() => SgfParser.ParseTree(input), Throws.Exception);
+        Assert.Throws<ArgumentException>(() => SgfParser.ParseTree(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_nodes()
     {
         const string input = "(;A[B];B[C])";
         var expected = TreeWithSingleChild(CreateData("A", "B"), TreeWithNoChildren(CreateData("B", "C")));
-        Assert.That(SgfParser.ParseTree(input), Is.EqualTo(expected).Using(SgfTreeEqualityComparer.Instance));
+        Assert.Equal(expected, SgfParser.ParseTree(input), SgfTreeEqualityComparer.Instance);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_child_trees()
     {
         const string input = "(;A[B](;B[C])(;C[D]))";
@@ -105,25 +97,23 @@ public class SgfParsingTest
                                 TreeWithNoChildren(CreateData("B", "C")),
                                 TreeWithNoChildren(CreateData("C", "D"))
                             });
-        Assert.That(SgfParser.ParseTree(input), Is.EqualTo(expected).Using(SgfTreeEqualityComparer.Instance));
+        Assert.Equal(expected, SgfParser.ParseTree(input), SgfTreeEqualityComparer.Instance);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Multiple_properties()
     {
         const string input = "(;A[b][c][d])";
         var expected = TreeWithNoChildren(CreateData("A", "b", "c", "d"));
-        Assert.That(SgfParser.ParseTree(input), Is.EqualTo(expected).Using(SgfTreeEqualityComparer.Instance));
+        Assert.Equal(expected, SgfParser.ParseTree(input), SgfTreeEqualityComparer.Instance);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Escaped_property()
     {
         const string input = @"(;A[\]b\nc\nd\t\te \n\]])";
         var expected = TreeWithNoChildren(CreateData("A", @"]b c d  e  ]"));
-        Assert.That(SgfParser.ParseTree(input), Is.EqualTo(expected).Using(SgfTreeEqualityComparer.Instance));
+        Assert.Equal(expected, SgfParser.ParseTree(input), SgfTreeEqualityComparer.Instance);
     }
 
     private class SgfTreeEqualityComparer : IEqualityComparer<SgfTree>