trackler 2.0.8.14 → 2.0.8.15

data/tracks/csharp/exercises/clock/Clock.cs

@@ -0,0 +1,24 @@
+using System;
+
+public class Clock
+{
+    public Clock(int hours)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public Clock(int hours, int minutes)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public Clock Add(int minutesToAdd)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public Clock Subtract(int minutesToSubtract)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/clock/Clock.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/clock/ClockTest.cs

@@ -1,127 +1,114 @@
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class ClockTest
 {
-    [TestCase(8, "08:00")]
-    [TestCase(9, "09:00")]
+    [Theory]
+    [InlineData(8, "08:00")]
+    [InlineData(9, "09:00")]
     public void Prints_the_hour(int hours, string expected)
     {
-        Assert.That(new Clock(hours).ToString(), Is.EqualTo(expected));
+        Assert.Equal(expected, new Clock(hours).ToString());
     }
 
-    [Ignore("Remove to run test")]
-    [TestCase(11, 9, "11:09")]
-    [TestCase(11, 19, "11:19")]
+    [Theory(Skip = "Remove to run test")]
+    [InlineData(11, 9, "11:09")]
+    [InlineData(11, 19, "11:19")]
     public void Prints_past_the_hour(int hours, int minutes, string expected)
     {
-        Assert.That(new Clock(hours, minutes).ToString(), Is.EqualTo(expected));
+        Assert.Equal(expected, new Clock(hours, minutes).ToString());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_add_minutes()
     {
         var clock = new Clock(10).Add(3);
-        Assert.That(clock.ToString(), Is.EqualTo("10:03"));
+        Assert.Equal("10:03", clock.ToString());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_add_over_an_hour()
     {
         var clock = new Clock(10).Add(63);
-        Assert.That(clock.ToString(), Is.EqualTo("11:03"));
+        Assert.Equal("11:03", clock.ToString());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_add_over_more_than_one_day()
     {
         var clock = new Clock(10).Add(7224);
-        Assert.That(clock.ToString(), Is.EqualTo("10:24"));
+        Assert.Equal("10:24", clock.ToString());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_subtract_minutes()
     {
         var clock = new Clock(10, 3).Subtract(3);
-        Assert.That(clock.ToString(), Is.EqualTo("10:00"));
+        Assert.Equal("10:00", clock.ToString());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_subtract_to_previous_hour()
     {
         var clock = new Clock(10, 3).Subtract(30);
-        Assert.That(clock.ToString(), Is.EqualTo("09:33"));
+        Assert.Equal("09:33", clock.ToString());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Can_subtract_over_an_hour()
     {
         var clock = new Clock(10, 3).Subtract(70);
-        Assert.That(clock.ToString(), Is.EqualTo("08:53"));
+        Assert.Equal("08:53", clock.ToString());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Wraps_around_midnight()
     {
         var clock = new Clock(23, 59).Add(2);
-        Assert.That(clock.ToString(), Is.EqualTo("00:01"));
+        Assert.Equal("00:01", clock.ToString());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Wraps_around_midnight_backwards()
     {
         var clock = new Clock(0, 1).Subtract(2);
-        Assert.That(clock.ToString(), Is.EqualTo("23:59"));
+        Assert.Equal("23:59", clock.ToString());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Midnight_is_zero_hundred_hours()
     {
         var clock = new Clock(24);
-        Assert.That(clock.ToString(), Is.EqualTo("00:00"));
+        Assert.Equal("00:00", clock.ToString());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Sixty_minutes_is_next_hour()
     {
         var clock = new Clock(1, 60);
-        Assert.That(clock.ToString(), Is.EqualTo("02:00"));
+        Assert.Equal("02:00", clock.ToString());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Clocks_with_same_time_are_equal()
     {
         var clock1 = new Clock(14, 30);
         var clock2 = new Clock(14, 30);
-        Assert.That(clock1, Is.EqualTo(clock2));
+        Assert.Equal(clock2, clock1);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Clocks_with_different_time_are_not_equal()
     {
         var clock1 = new Clock(15, 30);
         var clock2 = new Clock(14, 30);
-        Assert.That(clock1, Is.Not.EqualTo(clock2));
+        Assert.NotEqual(clock2, clock1);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Overflown_clocks_with_same_time_are_equal()
     {
         var clock1 = new Clock(14, 30);
         var clock2 = new Clock(38, 30);
-        Assert.That(clock1, Is.EqualTo(clock2));
+        Assert.Equal(clock2, clock1);
     }
 }

data/tracks/csharp/exercises/connect/Connect.cs

@@ -0,0 +1,21 @@
+using System;
+
+public enum ConnectWinner
+{
+    White,
+    Black,
+    None
+}
+
+public class Connect
+{
+    public Connect(string input)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+    
+    public ConnectWinner Result()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/connect/Connect.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/connect/ConnectTest.cs

@@ -1,4 +1,4 @@
-using NUnit.Framework;
+using Xunit;
 using System.Linq;
 
 public class ConnectTest
@@ -8,7 +8,7 @@ public class ConnectTest
         return string.Join("\n", board.Select(x => x.Replace(" ", "")));
     }
 
-    [Test]
+    [Fact]
     public void Empty_board_has_no_winner()
     {
         var lines = new[] 
@@ -20,29 +20,26 @@ public class ConnectTest
                 "    . . . . ."
             };
         var board = new Connect(MakeBoard(lines));
-        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.None));
+        Assert.Equal(ConnectWinner.None, board.Result());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_by_one_board_with_black_stone()
     {
         var lines = new[] { "X" };
         var board = new Connect(MakeBoard(lines));
-        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.Black));
+        Assert.Equal(ConnectWinner.Black, board.Result());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void One_by_one_board_with_white_stone()
     {
         var lines = new[] { "O" };
         var board = new Connect(MakeBoard(lines));
-        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.White));
+        Assert.Equal(ConnectWinner.White, board.Result());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Convoluted_path()
     {
         var lines = new[] 
@@ -54,11 +51,10 @@ public class ConnectTest
                 "    O O O O O"
             };
         var board = new Connect(MakeBoard(lines));
-        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.Black));
+        Assert.Equal(ConnectWinner.Black, board.Result());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Rectangle_black_wins()
     {
         var lines = new[] 
@@ -70,11 +66,10 @@ public class ConnectTest
                 "    . O X ."
             };
         var board = new Connect(MakeBoard(lines));
-        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.Black));
+        Assert.Equal(ConnectWinner.Black, board.Result());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Rectangle_white_wins()
     {
         var lines = new[] 
@@ -86,11 +81,10 @@ public class ConnectTest
                 "    . O X ."
             };
         var board = new Connect(MakeBoard(lines));
-        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.White));
+        Assert.Equal(ConnectWinner.White, board.Result());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Spiral_black_wins()
     {
         var lines = new[]
@@ -106,11 +100,10 @@ public class ConnectTest
             "XXXXXXXXO"
         };
         var board = new Connect(MakeBoard(lines));
-        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.Black));
+        Assert.Equal(ConnectWinner.Black, board.Result());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void Spiral_nobody_wins()
     {
         var lines = new[]
@@ -126,6 +119,6 @@ public class ConnectTest
             "XXXXXXXXO"
         };
         var board = new Connect(MakeBoard(lines));
-        Assert.That(board.Result(), Is.EqualTo(Connect.Winner.None));
+        Assert.Equal(ConnectWinner.None, board.Result());
     }
 }

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

@@ -1,18 +1,17 @@
 using System;
 using System.Collections.Generic;
-using System.Drawing;
 using System.Linq;
 
-public class Connect
+public enum ConnectWinner
 {
-    public enum Winner
-    {
-        White,
-        Black,
-        None
-    }
+    White,
+    Black,
+    None
+}
 
-    public enum Cell
+public class Connect
+{
+    private enum Cell
     {
         Empty,
         White,
@@ -48,31 +47,31 @@ public class Connect
     private int Cols => board[0].Length;
     private int Rows => board.Length;
 
-    private bool IsValidCoordinate(Point coordinate) =>
-        coordinate.Y >= 0 && coordinate.Y < Rows &&
-        coordinate.X >= 0 && coordinate.X < Cols;
+    private bool IsValidCoordinate(Tuple<int, int> coordinate) =>
+        coordinate.Item2 >= 0 && coordinate.Item2 < Rows &&
+        coordinate.Item1 >= 0 && coordinate.Item1 < Cols;
 
-    private bool CellAtCoordinateEquals(Cell cell, Point coordinate) => board[coordinate.Y][coordinate.X] == cell;
+    private bool CellAtCoordinateEquals(Cell cell, Tuple<int, int> coordinate) => board[coordinate.Item2][coordinate.Item1] == cell;
 
-    private HashSet<Point> Adjacent(Cell cell, Point coordinate)
+    private HashSet<Tuple<int, int>> Adjacent(Cell cell, Tuple<int, int> coordinate)
     {
-        var row = coordinate.Y;
-        var col = coordinate.X;
+        var row = coordinate.Item2;
+        var col = coordinate.Item1;
 
         var coords = new[]
         {
-            new Point(col + 1, row - 1),
-            new Point(col,     row - 1),
-            new Point(col - 1, row    ),
-            new Point(col + 1, row    ),
-            new Point(col - 1, row + 1),
-            new Point(col,     row + 1)
+            new Tuple<int, int>(col + 1, row - 1),
+            new Tuple<int, int>(col,     row - 1),
+            new Tuple<int, int>(col - 1, row    ),
+            new Tuple<int, int>(col + 1, row    ),
+            new Tuple<int, int>(col - 1, row + 1),
+            new Tuple<int, int>(col,     row + 1)
         };
 
-        return new HashSet<Point>(coords.Where(coord => IsValidCoordinate(coord) && CellAtCoordinateEquals(cell, coord)));
+        return new HashSet<Tuple<int, int>>(coords.Where(coord => IsValidCoordinate(coord) && CellAtCoordinateEquals(cell, coord)));
     }
     
-    private bool ValidPath(Cell cell, Func<Cell[][], Point, bool> stop, HashSet<Point> processed, Point coordinate)
+    private bool ValidPath(Cell cell, Func<Cell[][], Tuple<int, int>, bool> stop, HashSet<Tuple<int, int>> processed, Tuple<int, int> coordinate)
     {
         if (stop(board, coordinate))
             return true;
@@ -84,38 +83,38 @@ public class Connect
             return false;
 
         return next.Any(nextCoord => {
-            var updatedProcessed = new HashSet<Point>(processed);
+            var updatedProcessed = new HashSet<Tuple<int, int>>(processed);
             updatedProcessed.Add(nextCoord);
 
             return ValidPath(cell, stop, updatedProcessed, nextCoord);
         });
     }   
 
-    private bool IsWhiteStop(Cell[][] board, Point coordinate) => coordinate.Y == Rows - 1;
-    private bool IsBlackStop(Cell[][] board, Point coordinate) => coordinate.X == Cols - 1;
+    private bool IsWhiteStop(Cell[][] board, Tuple<int, int> coordinate) => coordinate.Item2 == Rows - 1;
+    private bool IsBlackStop(Cell[][] board, Tuple<int, int> coordinate) => coordinate.Item1 == Cols - 1;
 
-    private HashSet<Point> WhiteStart() =>
-        new HashSet<Point>(Enumerable.Range(0, Cols).Select(col => new Point(col, 0)).Where(coord => CellAtCoordinateEquals(Cell.White, coord)));
+    private HashSet<Tuple<int, int>> WhiteStart() =>
+        new HashSet<Tuple<int, int>>(Enumerable.Range(0, Cols).Select(col => new Tuple<int, int>(col, 0)).Where(coord => CellAtCoordinateEquals(Cell.White, coord)));
         
-    private HashSet<Point> BlackStart() =>
-        new HashSet<Point>(Enumerable.Range(0, Rows).Select(row => new Point(0, row)).Where(coord => CellAtCoordinateEquals(Cell.Black, coord)));
+    private HashSet<Tuple<int, int>> BlackStart() =>
+        new HashSet<Tuple<int, int>>(Enumerable.Range(0, Rows).Select(row => new Tuple<int, int>(0, row)).Where(coord => CellAtCoordinateEquals(Cell.Black, coord)));
 
-    private bool ColorWins(Cell cell, Func<Cell[][], Point, bool> stop, Func<HashSet<Point>> start)
+    private bool ColorWins(Cell cell, Func<Cell[][], Tuple<int, int>, bool> stop, Func<HashSet<Tuple<int, int>>> start)
     {
-        return start().Any(coordinate => ValidPath(cell, stop, new HashSet<Point>(), coordinate));
+        return start().Any(coordinate => ValidPath(cell, stop, new HashSet<Tuple<int, int>>(), coordinate));
     }
 
     private bool WhiteWins() => ColorWins(Cell.White, IsWhiteStop, WhiteStart);
     private bool BlackWins() => ColorWins(Cell.Black, IsBlackStop, BlackStart);        
     
-    public Winner Result()
+    public ConnectWinner Result()
     {
         if (WhiteWins())
-            return Winner.White;
+            return ConnectWinner.White;
 
         if (BlackWins())
-            return Winner.Black;
+            return ConnectWinner.Black;
 
-        return Winner.None;
+        return ConnectWinner.None;
     }
 }