trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/flatten-array/FlattenArray.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections;
+
+public static class Flattener
+{
+    public static IEnumerable Flatten(IEnumerable input)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/flatten-array/FlattenArray.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/flatten-array/FlattenArrayTest.cs

@@ -1,25 +1,25 @@
-using System.Collections.Generic;
-using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
 
 public class FlattenArrayTest
 {
-    [Test]
+    [Fact]
     public void Flattens_A_Nested_List()
     {
         var nestedList = new List<object> { new List<object>() };
-        Assert.That(Flattener.Flatten(nestedList), Is.Empty);
+        Assert.Empty(Flattener.Flatten(nestedList));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Flattens_2_Level_Nested_List()
     {
         var nestedList = new List<object> { 1, new List<object> { 2, 3, 4 }, 5 };
-        Assert.That(Flattener.Flatten(nestedList), Is.EquivalentTo(new List<object> { 1, 2, 3, 4, 5 }));
+        Assert.Equal(new List<int> { 1, 2, 3, 4, 5 }, Flattener.Flatten(nestedList).Cast<int>());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Flattens_3_Level_Nested_List()
     {
         var nestedList = new List<object>
@@ -29,11 +29,10 @@ public class FlattenArrayTest
             5,
             new List<object> { 6, new List<object> { 7, 8 } }
         };
-        Assert.That(Flattener.Flatten(nestedList), Is.EquivalentTo(new List<object> { 1, 2, 3, 4, 5, 6, 7, 8 }));
+        Assert.Equal(new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 }, Flattener.Flatten(nestedList).Cast<int>());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Flattens_5_Level_Nested_List()
     {
         var nestedList = new List<object>
@@ -50,11 +49,10 @@ public class FlattenArrayTest
                 -2
             }
         };
-        Assert.That(Flattener.Flatten(nestedList), Is.EquivalentTo(new List<object> { 0, 2, 2, 3, 8, 100, 4, 50, -2 }));
+        Assert.Equal(new List<int> { 0, 2, 2, 3, 8, 100, 4, 50, -2 }, Flattener.Flatten(nestedList).Cast<int>());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Flattens_6_Level_Nested_List()
     {
         var nestedList = new List<object>
@@ -70,11 +68,10 @@ public class FlattenArrayTest
             },
             8
         };
-        Assert.That(Flattener.Flatten(nestedList), Is.EquivalentTo(new List<object> { 1, 2, 3, 4, 5, 6, 7, 8 }));
+        Assert.Equal(new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 }, Flattener.Flatten(nestedList).Cast<int>());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Flattens_6_Level_Nested_List_With_Nulls()
     {
         var nestedList = new List<object>
@@ -93,11 +90,10 @@ public class FlattenArrayTest
             8,
             null
         };
-        Assert.That(Flattener.Flatten(nestedList), Is.EquivalentTo(new List<object> { 1, 2, 3, 4, 5, 6, 7, 8 }));
+        Assert.Equal(new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 }, Flattener.Flatten(nestedList).Cast<int>());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void All_Null_Nested_List_Returns_Empty_List()
     {
         var nestedList = new List<object>
@@ -111,6 +107,6 @@ public class FlattenArrayTest
             },
             null
         };
-        Assert.That(Flattener.Flatten(nestedList), Is.Empty);
+        Assert.Empty(Flattener.Flatten(nestedList));
     }
 }

data/tracks/csharp/exercises/food-chain/FoodChain.cs

@@ -0,0 +1,14 @@
+using System;
+
+public static class FoodChain
+{
+    public static string Song() 
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public static string Verse(int number) 
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/food-chain/FoodChain.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/food-chain/FoodChainTest.cs

@@ -1,18 +1,17 @@
-using NUnit.Framework;
+using Xunit;
 
 public class FoodChainTest
 {
-    [Test]
+    [Fact]
     public void Verse_one()
     {
         const string expected = "I know an old lady who swallowed a fly.\n" +
                                 "I don't know why she swallowed the fly. Perhaps she'll die.";
 
-        Assert.That(FoodChain.Verse(1), Is.EqualTo(expected));
+        Assert.Equal(expected, FoodChain.Verse(1));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Verse_two()
     {
         const string expected = "I know an old lady who swallowed a spider.\n" +
@@ -20,11 +19,10 @@ public class FoodChainTest
                                 "She swallowed the spider to catch the fly.\n" +
                                 "I don't know why she swallowed the fly. Perhaps she'll die.";
 
-        Assert.That(FoodChain.Verse(2), Is.EqualTo(expected));
+        Assert.Equal(expected, FoodChain.Verse(2));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Verse_four()
     {
         const string expected = "I know an old lady who swallowed a cat.\n" +
@@ -34,21 +32,19 @@ public class FoodChainTest
                                 "She swallowed the spider to catch the fly.\n" +
                                 "I don't know why she swallowed the fly. Perhaps she'll die.";
 
-        Assert.That(FoodChain.Verse(4), Is.EqualTo(expected));
+        Assert.Equal(expected, FoodChain.Verse(4));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Verse_eight()
     {
         const string expected = "I know an old lady who swallowed a horse.\n" +
                                 "She's dead, of course!";
 
-        Assert.That(FoodChain.Verse(8), Is.EqualTo(expected));
+        Assert.Equal(expected, FoodChain.Verse(8));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Complete_song()
     {
         const string expected = "I know an old lady who swallowed a fly.\n" +
@@ -102,6 +98,6 @@ public class FoodChainTest
                                 "I know an old lady who swallowed a horse.\n" +
                                 "She's dead, of course!";
 
-        Assert.That(FoodChain.Song(), Is.EqualTo(expected));
+        Assert.Equal(expected, FoodChain.Song());
     }
 }

data/tracks/csharp/exercises/forth/Forth.cs

@@ -0,0 +1,27 @@
+using System;
+
+public enum ForthError
+{
+    DivisionByZero,
+    StackUnderflow,
+    InvalidWord,
+    UnknownWord
+}
+
+public class ForthException : Exception
+{
+    public ForthException(ForthError error)
+    {
+        Error = error;
+    }
+
+    public ForthError Error { get; }
+}
+
+public static class Forth
+{
+    public static string Eval(string input)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/forth/Forth.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/forth/ForthTest.cs

@@ -1,134 +1,120 @@
-using NUnit.Framework;
+using Xunit;
 
 public class ForthTest
 {
-    [Test]
+    [Fact]
     public void No_input()
     {
-        Assert.That(Forth.Eval(""), Is.EqualTo(""));
+        Assert.Equal("", Forth.Eval(""));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Numbers_just_get_pushed_onto_the_stack()
     {
-        Assert.That(Forth.Eval("1 2 3 4 5"), Is.EqualTo("1 2 3 4 5"));
+        Assert.Equal("1 2 3 4 5", Forth.Eval("1 2 3 4 5"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Non_word_characters_are_separators()
     {
-        Assert.That(Forth.Eval("1\v2\t3\n4\r5 6\t7"), Is.EqualTo("1 2 3 4 5 6 7"));
+        Assert.Equal("1 2 3 4 5 6 7", Forth.Eval("1\v2\t3\n4\r5 6\t7"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Basic_arithmetic()
     {
-        Assert.That(Forth.Eval("1 2 + 4 -"), Is.EqualTo("-1"));
-        Assert.That(Forth.Eval("2 4 * 3 /"), Is.EqualTo("2"));
+        Assert.Equal("-1", Forth.Eval("1 2 + 4 -"));
+        Assert.Equal("2", Forth.Eval("2 4 * 3 /"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Division_by_zero()
     {
         var exception = Assert.Throws<ForthException>(() => Forth.Eval("4 2 2 - /"));
-        Assert.That(exception.Error, Is.EqualTo(ForthError.DivisionByZero));
+        Assert.Equal(ForthError.DivisionByZero, exception.Error);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void dup()
     {
-        Assert.That(Forth.Eval("1 DUP"), Is.EqualTo("1 1"));
-        Assert.That(Forth.Eval("1 2 Dup"), Is.EqualTo("1 2 2"));
+        Assert.Equal("1 1", Forth.Eval("1 DUP"));
+        Assert.Equal("1 2 2", Forth.Eval("1 2 Dup"));
 
         var exception = Assert.Throws<ForthException>(() => Forth.Eval("dup"));
-        Assert.That(exception.Error, Is.EqualTo(ForthError.StackUnderflow));
+        Assert.Equal(ForthError.StackUnderflow, exception.Error);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void drop()
     {
-        Assert.That(Forth.Eval("1 drop"), Is.EqualTo(""));
-        Assert.That(Forth.Eval("1 2 drop"), Is.EqualTo("1"));
+        Assert.Equal("", Forth.Eval("1 drop"));
+        Assert.Equal("1", Forth.Eval("1 2 drop"));
 
         var exception = Assert.Throws<ForthException>(() => Forth.Eval("drop"));
-        Assert.That(exception.Error, Is.EqualTo(ForthError.StackUnderflow));
+        Assert.Equal(ForthError.StackUnderflow, exception.Error);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void swap()
     {
-        Assert.That(Forth.Eval("1 2 swap"), Is.EqualTo("2 1"));
-        Assert.That(Forth.Eval("1 2 3 swap"), Is.EqualTo("1 3 2"));
+        Assert.Equal("2 1", Forth.Eval("1 2 swap"));
+        Assert.Equal("1 3 2", Forth.Eval("1 2 3 swap"));
 
         var exception1 = Assert.Throws<ForthException>(() => Forth.Eval("1 swap"));
-        Assert.That(exception1.Error, Is.EqualTo(ForthError.StackUnderflow));
+        Assert.Equal(ForthError.StackUnderflow, exception1.Error);
 
         var exception2 = Assert.Throws<ForthException>(() => Forth.Eval("swap"));
-        Assert.That(exception2.Error, Is.EqualTo(ForthError.StackUnderflow));
+        Assert.Equal(ForthError.StackUnderflow, exception2.Error);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void over()
     {
-        Assert.That(Forth.Eval("1 2 over"), Is.EqualTo("1 2 1"));
-        Assert.That(Forth.Eval("1 2 3 over"), Is.EqualTo("1 2 3 2"));
+        Assert.Equal("1 2 1", Forth.Eval("1 2 over"));
+        Assert.Equal("1 2 3 2", Forth.Eval("1 2 3 over"));
 
         var exception1 = Assert.Throws<ForthException>(() => Forth.Eval("1 over"));
-        Assert.That(exception1.Error, Is.EqualTo(ForthError.StackUnderflow));
+        Assert.Equal(ForthError.StackUnderflow, exception1.Error);
 
         var exception2 = Assert.Throws<ForthException>(() => Forth.Eval("over"));
-        Assert.That(exception2.Error, Is.EqualTo(ForthError.StackUnderflow));
+        Assert.Equal(ForthError.StackUnderflow, exception2.Error);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Defining_a_new_word()
     {
-        Assert.That(Forth.Eval(": dup-twice dup dup ; 1 dup-twice"), Is.EqualTo("1 1 1"));
+        Assert.Equal("1 1 1", Forth.Eval(": dup-twice dup dup ; 1 dup-twice"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Redefining_an_existing_word()
     {
-        Assert.That(Forth.Eval(": foo dup ; : foo dup dup ; 1 foo"), Is.EqualTo("1 1 1"));
+        Assert.Equal("1 1 1", Forth.Eval(": foo dup ; : foo dup dup ; 1 foo"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Redefining_an_existing_built_in_word()
     {
-        Assert.That(Forth.Eval(": swap dup ; 1 swap"), Is.EqualTo("1 1"));
+        Assert.Equal("1 1", Forth.Eval(": swap dup ; 1 swap"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Defining_words_with_odd_characters()
     {
-        Assert.That(Forth.Eval(": € 220371 ; €"), Is.EqualTo("220371"));
+        Assert.Equal("220371", Forth.Eval(": € 220371 ; €"));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Defining_a_number()
     {
         var exception = Assert.Throws<ForthException>(() => Forth.Eval(": 1 2 ;"));
-        Assert.That(exception.Error, Is.EqualTo(ForthError.InvalidWord));
+        Assert.Equal(ForthError.InvalidWord, exception.Error);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Calling_a_non_existing_word()
     {
         var exception = Assert.Throws<ForthException>(() => Forth.Eval("1 foo"));
-        Assert.That(exception.Error, Is.EqualTo(ForthError.UnknownWord));
+        Assert.Equal(ForthError.UnknownWord, exception.Error);
     }
 }