trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/bracket-push/BracketPush.cs

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

data/tracks/csharp/exercises/bracket-push/BracketPush.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/bracket-push/BracketPushTest.cs

@@ -1,99 +1,88 @@
-using NUnit.Framework;
+using Xunit;
 
 public class BracketPushTest
 {
-    [Test]
+    [Fact]
     public void Paired_square_brackets()
     {
         const string actual = "[]";
-        Assert.That(BracketPush.Matched(actual), Is.True);
+        Assert.True(BracketPush.Matched(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Empty_string()
     {
         const string actual = "";
-        Assert.That(BracketPush.Matched(actual), Is.True);
+        Assert.True(BracketPush.Matched(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Unpaired_brackets()
     {
         const string actual = "[[";
-        Assert.That(BracketPush.Matched(actual), Is.False);
+        Assert.False(BracketPush.Matched(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Wrong_ordered_brackets()
     {
         const string actual = "}{";
-        Assert.That(BracketPush.Matched(actual), Is.False);
+        Assert.False(BracketPush.Matched(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Paired_with_whitespace()
     {
         const string actual = "{ }";
-        Assert.That(BracketPush.Matched(actual), Is.True);
+        Assert.True(BracketPush.Matched(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Simple_nested_brackets()
     {
         const string actual = "{[]}";
-        Assert.That(BracketPush.Matched(actual), Is.True);
+        Assert.True(BracketPush.Matched(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Several_paired_brackets()
     {
         const string actual = "{}[]";
-        Assert.That(BracketPush.Matched(actual), Is.True);
+        Assert.True(BracketPush.Matched(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Paired_and_nested_brackets()
     {
         const string actual = "([{}({}[])])";
-        Assert.That(BracketPush.Matched(actual), Is.True);
+        Assert.True(BracketPush.Matched(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Unpaired_and_nested_brackets()
     {
         const string actual = "([{])";
-        Assert.That(BracketPush.Matched(actual), Is.False);
+        Assert.False(BracketPush.Matched(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Paired_and_wrong_nested_brackets()
     {
         const string actual = "[({]})";
-        Assert.That(BracketPush.Matched(actual), Is.False);
+        Assert.False(BracketPush.Matched(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Math_expression()
     {
         const string actual = "(((185 + 223.85) * 15) - 543)/2";
-        Assert.That(BracketPush.Matched(actual), Is.True);
+        Assert.True(BracketPush.Matched(actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Complex_latex_expression()
     {
         const string actual = "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)";
-        Assert.That(BracketPush.Matched(actual), Is.True);
+        Assert.True(BracketPush.Matched(actual));
     }
 }

data/tracks/csharp/exercises/change/Change.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class Change
+{
+    public static int[] Calculate(int target, int[] coins)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/change/Change.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/change/ChangeTest.cs

@@ -1,69 +1,63 @@
 using System;
-using NUnit.Framework;
+using Xunit;
 
 public class ChangeTest
 {
-    [Test]
+    [Fact]
     public void Single_coin_change()
     {
         var actual = new[] { 1, 5, 10, 25, 100 };
         var target = 25;
         var expected = new[] { 25 };
-        Assert.That(Change.Calculate(target, actual), Is.EqualTo(expected));
+        Assert.Equal(expected, Change.Calculate(target, actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Multiple_coin_change()
     {
         var actual = new[] { 1, 5, 10, 25, 100 };
         var target = 15;
         var expected = new[] { 5, 10 };
-        Assert.That(Change.Calculate(target, actual), Is.EqualTo(expected));
+        Assert.Equal(expected, Change.Calculate(target, actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Change_with_Lilliputian_Coins()
     {
         var actual = new[] { 1, 4, 15, 20, 50 };
         var target = 23;
         var expected = new[] { 4, 4, 15 };
-        Assert.That(Change.Calculate(target, actual), Is.EqualTo(expected));
+        Assert.Equal(expected, Change.Calculate(target, actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Change_with_Lower_Elbonia_Coins()
     {
         var actual = new[] { 1, 5, 10, 21, 25 };
         var target = 63;
         var expected = new[] { 21, 21, 21 };
-        Assert.That(Change.Calculate(target, actual), Is.EqualTo(expected));
+        Assert.Equal(expected, Change.Calculate(target, actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Large_target_values()
     {
         var actual = new[] { 1, 2, 5, 10, 20, 50, 100 };
         var target = 999;
         var expected = new[] { 2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100 };
-        Assert.That(Change.Calculate(target, actual), Is.EqualTo(expected));
+        Assert.Equal(expected, Change.Calculate(target, actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void No_coins_make_0_change()
     {
         var actual = new[] { 1, 5, 10, 21, 25 };
         var target = 0;
         var expected = new int[0];
-        Assert.That(Change.Calculate(target, actual), Is.EqualTo(expected));
+        Assert.Equal(expected, Change.Calculate(target, actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Error_testing_for_change_smaller_than_the_smallest_of_coins()
     {
         var actual = new[] { 5, 10 };
@@ -71,8 +65,7 @@ public class ChangeTest
         Assert.Throws<ArgumentException>(() => Change.Calculate(target, actual));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Cannot_find_negative_change_values()
     {
         var actual = new[] { 1, 2, 5 };

data/tracks/csharp/exercises/circular-buffer/CircularBuffer.cs

@@ -0,0 +1,29 @@
+using System;
+
+public class CircularBuffer<T>
+{
+    public CircularBuffer(int size)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public T Read()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public void Write(T value)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public void ForceWrite(T value)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public void Clear()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/circular-buffer/CircularBuffer.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/circular-buffer/CircularBufferTest.cs

@@ -1,20 +1,20 @@
-using NUnit.Framework;
+using System;
+using Xunit;
 
 public class CircularBufferTest
 {
-    [Test]
+    [Fact]
     public void Write_and_read_back_one_item()
     {
         var buffer = new CircularBuffer<char>(1);
         buffer.Write('1');
         var val = buffer.Read();
 
-        Assert.That(val, Is.EqualTo('1'));
-        Assert.That(() => buffer.Read(), Throws.Exception);
+        Assert.Equal('1', val);
+        Assert.Throws<InvalidOperationException>(() => buffer.Read());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Write_and_read_back_multiple_items()
     {
         var buffer = new CircularBuffer<char>(2);
@@ -24,13 +24,12 @@ public class CircularBufferTest
         var val1 = buffer.Read();
         var val2 = buffer.Read();
 
-        Assert.That(val1, Is.EqualTo('1'));
-        Assert.That(val2, Is.EqualTo('2'));
-        Assert.That(() => buffer.Read(), Throws.Exception);
+        Assert.Equal('1', val1);
+        Assert.Equal('2', val2);
+        Assert.Throws<InvalidOperationException>(() => buffer.Read());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Clearing_buffer()
     {
         var buffer = new CircularBuffer<char>(3);
@@ -40,7 +39,7 @@ public class CircularBufferTest
 
         buffer.Clear();
 
-        Assert.That(() => buffer.Read(), Throws.Exception);
+        Assert.Throws<InvalidOperationException>(() => buffer.Read());
 
         buffer.Write('1');
         buffer.Write('2');
@@ -49,12 +48,11 @@ public class CircularBufferTest
         buffer.Write('3');
         var val2 = buffer.Read();
 
-        Assert.That(val1, Is.EqualTo('1'));
-        Assert.That(val2, Is.EqualTo('2'));
+        Assert.Equal('1', val1);
+        Assert.Equal('2', val2);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Alternate_write_and_read()
     {
         var buffer = new CircularBuffer<char>(2);
@@ -63,12 +61,11 @@ public class CircularBufferTest
         buffer.Write('2');
         var val2 = buffer.Read();
 
-        Assert.That(val1, Is.EqualTo('1'));
-        Assert.That(val2, Is.EqualTo('2'));
+        Assert.Equal('1', val1);
+        Assert.Equal('2', val2);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Reads_back_oldest_item()
     {
         var buffer1 = new CircularBuffer<char>(3);
@@ -79,23 +76,21 @@ public class CircularBufferTest
         buffer1.Write('3');
         var val2 = buffer1.Read();
         var val3 = buffer1.Read();
-        Assert.That(val2, Is.EqualTo('2'));
-        Assert.That(val3, Is.EqualTo('3'));
+        Assert.Equal('2', val2);
+        Assert.Equal('3', val3);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Writing_to_a_full_buffer_throws_an_exception()
     {
         var buffer = new CircularBuffer<char>(2);
         buffer.Write('1');
         buffer.Write('2');
 
-        Assert.That(() => buffer.Write('A'), Throws.Exception);
+        Assert.Throws<InvalidOperationException>(() => buffer.Write('A'));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Overwriting_oldest_item_in_a_full_buffer()
     {
         var buffer = new CircularBuffer<char>(2);
@@ -106,13 +101,12 @@ public class CircularBufferTest
         var val1 = buffer.Read();
         var val2 = buffer.Read();
 
-        Assert.That(val1, Is.EqualTo('2'));
-        Assert.That(val2, Is.EqualTo('A'));
-        Assert.That(() => buffer.Read(), Throws.Exception);
+        Assert.Equal('2', val1);
+        Assert.Equal('A', val2);
+        Assert.Throws<InvalidOperationException>(() => buffer.Read());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Forced_writes_to_non_full_buffer_should_behave_like_writes()
     {
         var buffer = new CircularBuffer<char>(2);
@@ -122,13 +116,12 @@ public class CircularBufferTest
         var val1 = buffer.Read();
         var val2 = buffer.Read();
 
-        Assert.That(val1, Is.EqualTo('1'));
-        Assert.That(val2, Is.EqualTo('2'));
-        Assert.That(() => buffer.Read(), Throws.Exception);
+        Assert.Equal('1', val1);
+        Assert.Equal('2', val2);
+        Assert.Throws<InvalidOperationException>(() => buffer.Read());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Alternate_read_and_write_into_buffer_overflow()
     {
         var buffer = new CircularBuffer<char>(5);
@@ -155,11 +148,11 @@ public class CircularBufferTest
         var val7 = buffer.Read();
         var val8 = buffer.Read();
 
-        Assert.That(val4, Is.EqualTo('6'));
-        Assert.That(val5, Is.EqualTo('7'));
-        Assert.That(val6, Is.EqualTo('8'));
-        Assert.That(val7, Is.EqualTo('A'));
-        Assert.That(val8, Is.EqualTo('B'));
-        Assert.That(() => buffer.Read(), Throws.Exception);
+        Assert.Equal('6', val4);
+        Assert.Equal('7', val5);
+        Assert.Equal('8', val6);
+        Assert.Equal('A', val7);
+        Assert.Equal('B', val8);
+        Assert.Throws<InvalidOperationException>(() => buffer.Read());
     }
 }