trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/raindrops/Raindrops.cs

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

data/tracks/csharp/exercises/raindrops/Raindrops.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/raindrops/RaindropsTest.cs

@@ -1,50 +1,50 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class RaindropsTest
 {
-    [TestCase(1, ExpectedResult = "1")]
-    [TestCase(52, ExpectedResult = "52")]
-    [TestCase(12121, ExpectedResult = "12121")]
-    public string Non_primes_pass_through(int number)
+    [Theory]
+    [InlineData(1, "1")]
+    [InlineData(52, "52")]
+    [InlineData(12121, "12121")]
+    public void Non_primes_pass_through(int number, string expected)
     {
-        return Raindrops.Convert(number);
+        Assert.Equal(expected, Raindrops.Convert(number));
     }
 
-    [Ignore("Remove to run test")]
-    [TestCase(3)]
-    [TestCase(6)]
-    [TestCase(9)]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData(3)]
+    [InlineData(6)]
+    [InlineData(9)]
     public void Numbers_containing_3_as_a_prime_factor_give_pling(int number)
     {
-        Assert.That(Raindrops.Convert(number), Is.EqualTo("Pling"));
+        Assert.Equal("Pling", Raindrops.Convert(number));
     }
 
-    [Ignore("Remove to run test")]
-    [TestCase(5)]
-    [TestCase(10)]
-    [TestCase(25)]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData(5)]
+    [InlineData(10)]
+    [InlineData(25)]
     public void Numbers_containing_5_as_a_prime_factor_give_plang(int number)
     {
-        Assert.That(Raindrops.Convert(number), Is.EqualTo("Plang"));
+        Assert.Equal("Plang", Raindrops.Convert(number));
     }
 
-    [Ignore("Remove to run test")]
-    [TestCase(7)]
-    [TestCase(14)]
-    [TestCase(49)]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData(7)]
+    [InlineData(14)]
+    [InlineData(49)]
     public void Numbers_containing_7_as_a_prime_factor_give_plong(int number)
     {
-        Assert.That(Raindrops.Convert(number), Is.EqualTo("Plong"));
+        Assert.Equal("Plong", Raindrops.Convert(number));
     }
 
-    [Ignore("Remove to run test")]
-    [TestCase(15, ExpectedResult = "PlingPlang")]
-    [TestCase(21, ExpectedResult = "PlingPlong")]
-    [TestCase(35, ExpectedResult = "PlangPlong")]
-    [TestCase(105, ExpectedResult = "PlingPlangPlong")]
-    public string Numbers_containing_multiple_prime_factors_give_all_results_concatenated(int number)
+    [Theory(Skip = "Remove to run test")]
+    [InlineData(15, "PlingPlang")]
+    [InlineData(21, "PlingPlong")]
+    [InlineData(35, "PlangPlong")]
+    [InlineData(105, "PlingPlangPlong")]
+    public void Numbers_containing_multiple_prime_factors_give_all_results_concatenated(int number, string expected)
     {
-        return Raindrops.Convert(number);
+        Assert.Equal(expected, Raindrops.Convert(number));
     }
 }

data/tracks/csharp/exercises/react/React.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+
+public class Reactor
+{
+    public InputCell CreateInputCell(int value)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public ComputeCell CreateComputeCell(IEnumerable<Cell> producers, Func<int[], int> compute)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}
+
+public abstract class Cell
+{
+}
+
+public class InputCell : Cell
+{
+}
+
+public class ComputeCell : Cell
+{
+
+}

data/tracks/csharp/exercises/react/React.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/react/ReactTest.cs

@@ -1,34 +1,32 @@
-using NUnit.Framework;
+using Xunit;
 using System.Collections.Generic;
 
 public class ReactTest
 {
-    [Test]
+    [Fact]
     public void Setting_the_value_of_an_input_cell_changes_the_observable_value()
     {
         var reactor = new Reactor();
         var inputCell1 = reactor.CreateInputCell(1);
 
-        Assert.That(inputCell1.Value, Is.EqualTo(1));
+        Assert.Equal(1, inputCell1.Value);
         inputCell1.Value = 2;
-        Assert.That(inputCell1.Value, Is.EqualTo(2));
+        Assert.Equal(2, inputCell1.Value);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void The_value_of_a_compute_is_determined_by_the_value_of_the_dependencies()
     {
         var reactor = new Reactor();
         var inputCell1 = reactor.CreateInputCell(1);
         var computeCell1 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] + 1);
 
-        Assert.That(computeCell1.Value, Is.EqualTo(2));
+        Assert.Equal(2, computeCell1.Value);
         inputCell1.Value = 2;
-        Assert.That(computeCell1.Value, Is.EqualTo(3));
+        Assert.Equal(3, computeCell1.Value);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Compute_cells_can_depend_on_other_compute_cells()
     {
         var reactor = new Reactor();
@@ -37,13 +35,12 @@ public class ReactTest
         var computeCell2 = reactor.CreateComputeCell(new[] { inputCell1 }, (values) => values[0] - 1);
         var computeCell3 = reactor.CreateComputeCell(new[] { computeCell1, computeCell2 }, (values) => values[0] * values[1]);
 
-        Assert.That(computeCell3.Value, Is.EqualTo(0));
+        Assert.Equal(0, computeCell3.Value);
         inputCell1.Value = 3;
-        Assert.That(computeCell3.Value, Is.EqualTo(8));
+        Assert.Equal(8, computeCell3.Value);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Compute_cells_can_have_callbacks()
     {
         var reactor = new Reactor();
@@ -52,13 +49,12 @@ public class ReactTest
         var observed = new List<int>();
         computeCell1.Changed += (sender, value) => observed.Add(value);
 
-        Assert.That(observed, Is.Empty);
+        Assert.Empty(observed);
         inputCell1.Value = 2;
-        Assert.That(observed, Is.EquivalentTo(new[] { 3 }));
+        Assert.Equal(new[] { 3 }, observed);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Callbacks_only_trigger_on_change()
     {
         var reactor = new Reactor();
@@ -68,15 +64,14 @@ public class ReactTest
         computecell1.Changed += (sender, value) => observerCalled++;
 
         inputCell1.Value = 1;
-        Assert.That(observerCalled, Is.EqualTo(0));
+        Assert.Equal(0, observerCalled);
         inputCell1.Value = 2;
-        Assert.That(observerCalled, Is.EqualTo(0));
+        Assert.Equal(0, observerCalled);
         inputCell1.Value = 3;
-        Assert.That(observerCalled, Is.EqualTo(1));
+        Assert.Equal(1, observerCalled);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Callbacks_can_be_removed()
     {
         var reactor = new Reactor();
@@ -92,17 +87,16 @@ public class ReactTest
         computeCell1.Changed += changedHandler2;
 
         inputCell1.Value = 2;
-        Assert.That(observed1, Is.EquivalentTo(new[] { 3 }));
-        Assert.That(observed2, Is.EquivalentTo(new[] { 3 }));
+        Assert.Equal(new[] { 3 }, observed1);
+        Assert.Equal(new[] { 3 }, observed2);
 
         computeCell1.Changed -= changedHandler1;
         inputCell1.Value = 3;
-        Assert.That(observed1, Is.EquivalentTo(new[] { 3 }));
-        Assert.That(observed2, Is.EquivalentTo(new[] { 3, 4 }));
+        Assert.Equal(new[] { 3 }, observed1);
+        Assert.Equal(new[] { 3, 4 }, observed2);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Callbacks_should_only_be_called_once_even_if_multiple_dependencies_have_changed()
     {
         var reactor = new Reactor();
@@ -116,6 +110,6 @@ public class ReactTest
         computeCell4.Changed += (sender, value) => changed4++;
 
         inputCell1.Value = 3;
-        Assert.That(changed4, Is.EqualTo(1));
+        Assert.Equal(1, changed4);
     }
 }

data/tracks/csharp/exercises/rectangles/Example.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Drawing;
 using System.Linq;
 
 public static class Rectangles
@@ -35,43 +34,43 @@ public static class Rectangles
 
     private static int Cols(CellType[][] grid) => grid[0].Length;
 
-    private static CellType Cell(Point point, CellType[][] grid) => grid[point.Y][point.X];
+    private static CellType Cell(Tuple<int, int> point, CellType[][] grid) => grid[point.Item2][point.Item1];
 
-    private static Point[] FindCorners(CellType[][] grid) =>
+    private static Tuple<int, int>[] FindCorners(CellType[][] grid) =>
         Enumerable.Range(0, Rows(grid)).SelectMany(y =>
-                    Enumerable.Range(0, Cols(grid)).Select(x => new Point(x, y)))
+                    Enumerable.Range(0, Cols(grid)).Select(x => new Tuple<int, int>(x, y)))
             .Where(point => Cell(point, grid) == CellType.Corner)
             .ToArray();
 
-    private static bool ConnectsVertically(Point point, CellType[][] grid) =>
+    private static bool ConnectsVertically(Tuple<int, int> point, CellType[][] grid) =>
         (Cell(point, grid) == CellType.VerticalLine) ||
         (Cell(point, grid) == CellType.Corner);
 
-    private static bool ConnectedVertically(Point top, Point bottom, CellType[][] grid) =>
-        Enumerable.Range(top.Y + 1, bottom.Y - top.Y - 1).All(y => ConnectsVertically(new Point(top.X, y), grid));
+    private static bool ConnectedVertically(Tuple<int, int> top, Tuple<int, int> bottom, CellType[][] grid) =>
+        Enumerable.Range(top.Item2 + 1, bottom.Item2 - top.Item2 - 1).All(y => ConnectsVertically(new Tuple<int, int>(top.Item1, y), grid));
 
-    private static bool ConnectsHorizontally(Point point, CellType[][] grid) =>
+    private static bool ConnectsHorizontally(Tuple<int, int> point, CellType[][] grid) =>
         (Cell(point, grid) == CellType.HorizontalLine) ||
         (Cell(point, grid) == CellType.Corner);
 
-    private static bool ConnectedHorizontally(Point left, Point right, CellType[][] grid) =>
-        Enumerable.Range(left.X + 1, right.X - left.X - 1).All(x => ConnectsHorizontally(new Point(x, left.Y), grid));
+    private static bool ConnectedHorizontally(Tuple<int, int> left, Tuple<int, int> right, CellType[][] grid) =>
+        Enumerable.Range(left.Item1 + 1, right.Item1 - left.Item1 - 1).All(x => ConnectsHorizontally(new Tuple<int, int>(x, left.Item2), grid));
 
-    private static bool IsTopLineOfRectangle(Point topLeft, Point topRight, CellType[][] grid) =>
-        (topRight.X > topLeft.X) && (topRight.Y == topLeft.Y) && ConnectedHorizontally(topLeft, topRight, grid);
+    private static bool IsTopLineOfRectangle(Tuple<int, int> topLeft, Tuple<int, int> topRight, CellType[][] grid) =>
+        (topRight.Item1 > topLeft.Item1) && (topRight.Item2 == topLeft.Item2) && ConnectedHorizontally(topLeft, topRight, grid);
 
-    private static bool IsRightLineOfRectangle(Point topRight, Point bottomRight, CellType[][] grid) =>
-        (bottomRight.X == topRight.X) && (bottomRight.Y > topRight.Y) &&
+    private static bool IsRightLineOfRectangle(Tuple<int, int> topRight, Tuple<int, int> bottomRight, CellType[][] grid) =>
+        (bottomRight.Item1 == topRight.Item1) && (bottomRight.Item2 > topRight.Item2) &&
         ConnectedVertically(topRight, bottomRight, grid);
 
-    private static bool IsBottomLineOfRectangle(Point bottomLeft, Point bottomRight, CellType[][] grid) =>
-        (bottomRight.X > bottomLeft.X) && (bottomRight.Y == bottomLeft.Y) &&
+    private static bool IsBottomLineOfRectangle(Tuple<int, int> bottomLeft, Tuple<int, int> bottomRight, CellType[][] grid) =>
+        (bottomRight.Item1 > bottomLeft.Item1) && (bottomRight.Item2 == bottomLeft.Item2) &&
         ConnectedHorizontally(bottomLeft, bottomRight, grid);
 
-    private static bool IsLeftLineOfRectangle(Point topLeft, Point bottomLeft, CellType[][] grid) =>
-        (bottomLeft.X == topLeft.X) && (bottomLeft.Y > topLeft.Y) && ConnectedVertically(topLeft, bottomLeft, grid);
+    private static bool IsLeftLineOfRectangle(Tuple<int, int> topLeft, Tuple<int, int> bottomLeft, CellType[][] grid) =>
+        (bottomLeft.Item1 == topLeft.Item1) && (bottomLeft.Item2 > topLeft.Item2) && ConnectedVertically(topLeft, bottomLeft, grid);
 
-    private static int RectangleForCorner(Point topLeft, Point[] corners, CellType[][] grid)
+    private static int RectangleForCorner(Tuple<int, int> topLeft, Tuple<int, int>[] corners, CellType[][] grid)
     {
         return (from topRight in corners.Where(corner => IsTopLineOfRectangle(topLeft, corner, grid))
                 from bottomLeft in corners.Where(corner => IsLeftLineOfRectangle(topLeft, corner, grid))

data/tracks/csharp/exercises/rectangles/Rectangles.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class Rectangles
+{
+    public static int Count(string[] rows)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/rectangles/Rectangles.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/rectangles/RectanglesTest.cs

@@ -1,32 +1,29 @@
-using NUnit.Framework;
+using Xunit;
 
 public class RectanglesTest
 {
-    [Test]
+    [Fact]
     public void No_rows()
     {
         var input = new string[0];
-        Assert.That(Rectangles.Count(input), Is.EqualTo(0));
+        Assert.Equal(0, Rectangles.Count(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void No_columns()
     {
         var input = new[] { "" };
-        Assert.That(Rectangles.Count(input), Is.EqualTo(0));
+        Assert.Equal(0, Rectangles.Count(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void No_rectangles()
     {
         var input = new[] { " " };
-        Assert.That(Rectangles.Count(input), Is.EqualTo(0));
+        Assert.Equal(0, Rectangles.Count(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_rectangle()
     {
         var input = new[]
@@ -35,11 +32,10 @@ public class RectanglesTest
             "| |",
             "+-+"
         };
-        Assert.That(Rectangles.Count(input), Is.EqualTo(1));
+        Assert.Equal(1, Rectangles.Count(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Two_rectangles_without_shared_parts()
     {
         var input = new[]
@@ -50,11 +46,10 @@ public class RectanglesTest
             "| |  ",
             "+-+  "
         };
-        Assert.That(Rectangles.Count(input), Is.EqualTo(2));
+        Assert.Equal(2, Rectangles.Count(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Five_rectangles_with_shared_parts()
     {
         var input = new[]
@@ -65,11 +60,10 @@ public class RectanglesTest
             "| | |",
             "+-+-+"
         };
-        Assert.That(Rectangles.Count(input), Is.EqualTo(5));
+        Assert.Equal(5, Rectangles.Count(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Only_complete_rectangles_are_counted()
     {
         var input = new[]
@@ -80,11 +74,10 @@ public class RectanglesTest
             "| | -",
             "+-+-+"
         };
-        Assert.That(Rectangles.Count(input), Is.EqualTo(1));
+        Assert.Equal(1, Rectangles.Count(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Rectangles_can_be_of_different_sizes()
     {
         var input = new[]
@@ -95,11 +88,10 @@ public class RectanglesTest
             "|   |       |",
             "+---+-------+"
         };
-        Assert.That(Rectangles.Count(input), Is.EqualTo(3));
+        Assert.Equal(3, Rectangles.Count(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Corner_is_required_for_a_rectangle_to_be_complete()
     {
         var input = new[]
@@ -110,11 +102,10 @@ public class RectanglesTest
             "|   |       |",
             "+---+-------+"
         };
-        Assert.That(Rectangles.Count(input), Is.EqualTo(2));
+        Assert.Equal(2, Rectangles.Count(input));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Large_input_with_many_rectangles()
     {
         var input = new[]
@@ -128,6 +119,6 @@ public class RectanglesTest
             "+------+  | |",
             "          +-+"
         };
-        Assert.That(Rectangles.Count(input), Is.EqualTo(60));
+        Assert.Equal(60, Rectangles.Count(input));
     }
 }