trackler 2.0.8.14 → 2.0.8.15

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

@@ -1,6 +1,6 @@
 using System;
 
-public class Gigasecond
+public static class Gigasecond
 {
     public static DateTime Date(DateTime birthDate)
     {

data/tracks/csharp/exercises/gigasecond/Gigasecond.cs

@@ -0,0 +1,9 @@
+using System;
+
+public static class Gigasecond
+{
+    public static DateTime Date(DateTime birthDate)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/gigasecond/Gigasecond.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/gigasecond/GigasecondTest.cs

@@ -1,29 +1,26 @@
 using System;
-using NUnit.Framework;
+using Xunit;
 
-[TestFixture]
 public class GigasecondTest
 {
-    [Test]
+    [Fact]
     public void First_date()
     {
         var date = Gigasecond.Date(new DateTime(2011, 4, 25, 0, 0, 0, DateTimeKind.Utc));
-        Assert.That(date, Is.EqualTo(new DateTime(2043, 1, 1, 1, 46, 40, DateTimeKind.Utc)));
+        Assert.Equal(new DateTime(2043, 1, 1, 1, 46, 40, DateTimeKind.Utc), date);
     }
 
-    [Test]
-    [Ignore("Remove to run test")]
+    [Fact(Skip = "Remove to run test")]
     public void Another_date()
     {
         var date = Gigasecond.Date(new DateTime(1977, 6, 13, 0, 0, 0, DateTimeKind.Utc));
-        Assert.That(date, Is.EqualTo(new DateTime(2009, 2, 19, 1, 46, 40, DateTimeKind.Utc)));
+        Assert.Equal(new DateTime(2009, 2, 19, 1, 46, 40, DateTimeKind.Utc), date);
     }
 
-    [Test]
-    [Ignore("Remove to run test")]
+    [Fact(Skip = "Remove to run test")]
     public void Yet_another_date()
     {
         var date = Gigasecond.Date(new DateTime(1959, 7, 19, 0, 0, 0, DateTimeKind.Utc));
-        Assert.That(date, Is.EqualTo(new DateTime(1991, 3, 27, 1, 46, 40, DateTimeKind.Utc)));
+        Assert.Equal(new DateTime(1991, 3, 27, 1, 46, 40, DateTimeKind.Utc), date);
     }
 }

data/tracks/csharp/exercises/go-counting/Example.cs

@@ -1,35 +1,34 @@
 using System;
-using System.Drawing;
 using System.Collections.Generic;
 using System.Linq;
 
-public class GoCounting
+public enum GoPlayer
 {
-    public enum Player
-    {
-        None,
-        Black,
-        White
-    }
+    None,
+    Black,
+    White
+}
 
-    private readonly Player[][] board;
+public class GoCounting
+{
+    private readonly GoPlayer[][] board;
 
     public GoCounting(string input)
     {
         board = ParseBoard(input);
     }
 
-    private static Player CharToPlayer(char c)
+    private static GoPlayer CharToPlayer(char c)
     {
         switch (c)
         {
-            case 'B': return Player.Black;
-            case 'W': return Player.White;
-            default: return Player.None;
+            case 'B': return GoPlayer.Black;
+            case 'W': return GoPlayer.White;
+            default: return GoPlayer.None;
         }
     }
 
-    private static Player[][] ParseBoard(string input)
+    private static GoPlayer[][] ParseBoard(string input)
     {
         var split = input.Split('\n');
         var rows = split.Length;
@@ -41,45 +40,45 @@ public class GoCounting
     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 Player GetPlayer(Point coordinate) => board[coordinate.Y][coordinate.X];
+    private GoPlayer GetPlayer(Tuple<int, int> coordinate) => board[coordinate.Item2][coordinate.Item1];
 
-    private bool IsEmpty(Point coordinate) => GetPlayer(coordinate) == Player.None;
-    private bool IsTaken(Point coordinate) => !IsEmpty(coordinate);
+    private bool IsEmpty(Tuple<int, int> coordinate) => GetPlayer(coordinate) == GoPlayer.None;
+    private bool IsTaken(Tuple<int, int> coordinate) => !IsEmpty(coordinate);
 
-    private IEnumerable<Point> EmptyCoordinates()
+    private IEnumerable<Tuple<int, int>> EmptyCoordinates()
     {
         return Enumerable.Range(0, Cols).SelectMany(col =>
-               Enumerable.Range(0, Rows).Select(row => new Point(col, row)))
+               Enumerable.Range(0, Rows).Select(row => new Tuple<int, int>(col, row)))
                 .Where(IsEmpty);
     }
 
-    private IEnumerable<Point> NeighborCoordinates(Point coordinate)
+    private IEnumerable<Tuple<int, int>> NeighborCoordinates(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, row - 1),
-            new Point(col-1, row),
-            new Point(col+1, row),
-            new Point(col, 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,   row+1)
         };
 
         return coords.Where(IsValidCoordinate);
     }
 
-    private IEnumerable<Point> TakenNeighborCoordinates(Point coordinate) =>
+    private IEnumerable<Tuple<int, int>> TakenNeighborCoordinates(Tuple<int, int> coordinate) =>
         NeighborCoordinates(coordinate).Where(IsTaken);
 
-    private IEnumerable<Point> EmptyNeighborCoordinates(Point coordinate) =>
+    private IEnumerable<Tuple<int, int>> EmptyNeighborCoordinates(Tuple<int, int> coordinate) =>
         NeighborCoordinates(coordinate).Where(IsEmpty);
 
-    private Player TerritoryOwner(HashSet<Point> coords)
+    private GoPlayer TerritoryOwner(HashSet<Tuple<int, int>> coords)
     {
         var neighborColors = coords.SelectMany(TakenNeighborCoordinates).Select(GetPlayer);
         var uniqueNeighborColors = ToSet(neighborColors);
@@ -87,15 +86,15 @@ public class GoCounting
         if (uniqueNeighborColors.Count == 1)
             return uniqueNeighborColors.First();
 
-        return Player.None;
+        return GoPlayer.None;
     }
 
-    private HashSet<Point> TerritoryHelper(HashSet<Point> remainder, HashSet<Point> acc)
+    private HashSet<Tuple<int, int>> TerritoryHelper(HashSet<Tuple<int, int>> remainder, HashSet<Tuple<int, int>> acc)
     {
         if (!remainder.Any())
             return acc;
 
-        var emptyNeighbors = new HashSet<Point>(remainder.SelectMany(EmptyNeighborCoordinates));
+        var emptyNeighbors = new HashSet<Tuple<int, int>>(remainder.SelectMany(EmptyNeighborCoordinates));
         emptyNeighbors.ExceptWith(acc);
 
         var newAcc = ToSet(acc);
@@ -103,12 +102,12 @@ public class GoCounting
         return TerritoryHelper(emptyNeighbors, newAcc);
     }
 
-    private HashSet<Point> Territory(Point coordinate) =>
+    private HashSet<Tuple<int, int>> Territory(Tuple<int, int> coordinate) =>
         IsValidCoordinate(coordinate) && IsEmpty(coordinate)
             ? TerritoryHelper(ToSingletonSet(coordinate), ToSingletonSet(coordinate))
-            : new HashSet<Point>();
+            : new HashSet<Tuple<int, int>>();
 
-    public Tuple<Player, IEnumerable<Point>> TerritoryFor(Point coord)
+    public Tuple<GoPlayer, IEnumerable<Tuple<int, int>>> TerritoryFor(Tuple<int, int> coord)
     {
         var coords = Territory(coord);
         if (!coords.Any())
@@ -118,7 +117,7 @@ public class GoCounting
         return Tuple.Create(owner, coords.AsEnumerable());
     }
 
-    private Dictionary<Player, IEnumerable<Point>> TerritoriesHelper(HashSet<Point> remainder, Dictionary<Player, IEnumerable<Point>> acc)
+    private Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>> TerritoriesHelper(HashSet<Tuple<int, int>> remainder, Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>> acc)
     {
         if (!remainder.Any())
             return acc;
@@ -130,16 +129,17 @@ public class GoCounting
         var newRemainder = ToSet(remainder);
         newRemainder.ExceptWith(coords);
 
-        var newAcc = new Dictionary<Player, IEnumerable<Point>>(acc);
-        newAcc[owner] = coords;
-
+        var newAcc = new Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>>(acc)
+        {
+            [owner] = coords
+        };
         return TerritoriesHelper(newRemainder, newAcc);
     }
 
-    public Dictionary<Player, IEnumerable<Point>> Territories()
+    public Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>> Territories()
     {
         var emptyCoords = EmptyCoordinates();
-        return TerritoriesHelper(ToSet(emptyCoords), new Dictionary<Player, IEnumerable<Point>>());
+        return TerritoriesHelper(ToSet(emptyCoords), new Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>>());
     }
 
     private static HashSet<T> ToSet<T>(IEnumerable<T> value) => new HashSet<T>(value);

data/tracks/csharp/exercises/go-counting/GoCounting.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+
+public enum GoPlayer
+{
+    None,
+    Black,
+    White
+}
+
+public class GoCounting
+{
+    public GoCounting(string input)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public Tuple<GoPlayer, IEnumerable<Tuple<int, int>>> TerritoryFor(Tuple<int, int> coord)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>> Territories()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/go-counting/GoCounting.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/go-counting/GoCountingTest.cs

@@ -1,7 +1,7 @@
-using NUnit.Framework;
+using Xunit;
 using System;
 using System.Collections.Generic;
-using System.Drawing;
+using System.Linq;
 
 public class GoCountingTest
 {
@@ -29,99 +29,111 @@ public class GoCountingTest
                 "   B B   "
             });
 
-    [Test]
+    [Fact]
     public void FiveByFiveTerritoryForBlack()
     {
         var board = new GoCounting(boardFiveByFive);
-        var result = board.TerritoryFor(new Point(0, 1));
-        Assert.That(result.Item1, Is.EqualTo(GoCounting.Player.Black));
-        Assert.That(result.Item2, Is.EquivalentTo(new[] { new Point(0, 0), new Point(0, 1), new Point(1, 0) }));
+        var result = board.TerritoryFor(new Tuple<int, int>(0, 1));
+        var expected = new HashSet<Tuple<int, int>> { new Tuple<int, int>(0, 0), new Tuple<int, int>(0, 1), new Tuple<int, int>(1, 0) };
+        Assert.Equal(GoPlayer.Black, result.Item1);        
+        Assert.True(expected.SetEquals(result.Item2));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void FiveByFiveTerritoryForWhite()
     {
         var board = new GoCounting(boardFiveByFive);
-        var result = board.TerritoryFor(new Point(2, 3));
-        Assert.That(result.Item1, Is.EqualTo(GoCounting.Player.White));
-        Assert.That(result.Item2, Is.EquivalentTo(new[] { new Point(2, 3) }));
+        var result = board.TerritoryFor(new Tuple<int, int>(2, 3));
+        var expected = new HashSet<Tuple<int, int>> { new Tuple<int, int>(2, 3) };
+        Assert.Equal(GoPlayer.White, result.Item1);
+        Assert.True(expected.SetEquals(result.Item2));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void FiveByFiveOpenTerritory()
     {
         var board = new GoCounting(boardFiveByFive);
-        var result = board.TerritoryFor(new Point(1, 4));
-        Assert.That(result.Item1, Is.EqualTo(GoCounting.Player.None));
-        Assert.That(result.Item2, Is.EquivalentTo(new[] { new Point(0, 3), new Point(0, 4), new Point(1, 4) }));
+        var result = board.TerritoryFor(new Tuple<int, int>(1, 4));
+        var expected = new HashSet<Tuple<int, int>> { new Tuple<int, int>(0, 3), new Tuple<int, int>(0, 4), new Tuple<int, int>(1, 4) };
+        Assert.Equal(GoPlayer.None, result.Item1);
+        Assert.True(expected.SetEquals(result.Item2));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void FiveByFiveNonTerritoryStone()
     {
         var board = new GoCounting(boardFiveByFive);
-        Assert.That(board.TerritoryFor(new Point(1, 1)), Is.Null);
+        Assert.Null(board.TerritoryFor(new Tuple<int, int>(1, 1)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void FiveByFiveNonTerritoryDueToTooLowCoordinate()
     {
         var board = new GoCounting(boardFiveByFive);
-        Assert.That(board.TerritoryFor(new Point(-1, 1)), Is.Null);
+        Assert.Null(board.TerritoryFor(new Tuple<int, int>(-1, 1)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void FiveByFiveNonTerritoryDueToTooHighCoordinate()
     {
         var board = new GoCounting(boardFiveByFive);
-        Assert.That(board.TerritoryFor(new Point(1, 5)), Is.Null);
+        Assert.Null(board.TerritoryFor(new Tuple<int, int>(1, 5)));
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void MinimalBoardWithNoTerritories()
     {
         var input = "B";
         var board = new GoCounting(input);
 
-        var expected = new Dictionary<GoCounting.Player, IEnumerable<Point>>();
+        var expected = new Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>>();
 
-        Assert.That(board.Territories(), Is.EquivalentTo(expected));
+        Assert.Equal(expected, board.Territories());
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void OneTerritoryCoveringTheWholeBoard()
     {
         var input = " ";
         var board = new GoCounting(input);
+        var actual = board.Territories();
 
-        var expected = new Dictionary<GoCounting.Player, IEnumerable<Point>>
+        var expected = new Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>>
         {
-            [GoCounting.Player.None] = new[] { new Point(0, 0) }
+            [GoPlayer.None] = new[] { new Tuple<int, int>(0, 0) }
         };
-
-        Assert.That(board.Territories(), Is.EquivalentTo(expected));
+        
+        Assert.Equal(expected.Keys, actual.Keys);
+        Assert.Equal(expected[GoPlayer.None], actual[GoPlayer.None]);
     }
 
-    [Ignore("Remove to run test")]
-    [Test]
+    [Fact(Skip = "Remove to run test")]
     public void TwoTerritoriesOnRectangularBoard()
     {
         var input = string.Join("\n", new[] { " BW ", " BW " });
         var board = new GoCounting(input);
+        var actual = board.Territories();
 
-        var expected = new Dictionary<GoCounting.Player, IEnumerable<Point>>
+        var expected = new Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>>
         {
-            [GoCounting.Player.Black] = new[] { new Point(0, 0), new Point(0, 1) },
-            [GoCounting.Player.White] = new[] { new Point(3, 0), new Point(3, 1) }
+            [GoPlayer.Black] = new[] { new Tuple<int, int>(0, 0), new Tuple<int, int>(0, 1) },
+            [GoPlayer.White] = new[] { new Tuple<int, int>(3, 0), new Tuple<int, int>(3, 1) }
         };
+                
+        Assert.Equal(expected.Keys, actual.Keys);
+        Assert.Equal(expected[GoPlayer.Black], actual[GoPlayer.Black]);
+        Assert.Equal(expected[GoPlayer.White], actual[GoPlayer.White]);
+    }
+
+    private class EnumerableEqualityComparer<T> : IEqualityComparer<IEnumerable<T>>
+    {
+        public static readonly EnumerableEqualityComparer<T> Instance = new EnumerableEqualityComparer<T>();
+
+        public bool Equals(IEnumerable<T> x, IEnumerable<T> y) => x.SequenceEqual(y);
 
-        Assert.That(board.Territories(), Is.EquivalentTo(expected));
+        public int GetHashCode(IEnumerable<T> obj)
+        {
+            throw new NotImplementedException();
+        }
     }
 }