trackler 2.2.1.153 → 2.2.1.154

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e991216d9ea33bd87ff86e3588f1cf95947a7897
-  data.tar.gz: e97ed241757d28be0a367f79cef2dd736c706bfd
+  metadata.gz: 891cfc46c3753f1097f043124ad3d933b970024b
+  data.tar.gz: f77a21a3997e6167c19f64eace521749c90a8397
 SHA512:
-  metadata.gz: dde1e87b24a0de86ea3d2de1bb5ac31f6e33c2d45cc907682a8518e76c65aa9cd611a09c35603feee4df96a5550a2bd146817ab61f161f71357c63cfdaab69da
-  data.tar.gz: 7551620e5417926310541ccb3c2f711610a817149d068a2b5c28df0f1f2e2c2b608272fc6cab46ae71801f239adf74b1a6ebd684225f907763f3a0880e4d035a
+  metadata.gz: 0e47f625db64fa5a520715350120cf821dff4e07df8a6d640daf4c21cba9bcd21545a5a9ae6f33599aea4bd2413c2a4afc0ec2afd21fed91f1ffb048e3cf3f14
+  data.tar.gz: 05c5ed9423ef4bb614a0476f8888ffefb753422189a6ae0a91ce0809994473dbea666cb39c8a9a6bab94af00a03479a0685fc65157e0ffaaf9db2a179dd44abe

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.153"
+  VERSION = "2.2.1.154"
 end

data/problem-specifications/exercises/grade-school/canonical-data.json

@@ -0,0 +1,68 @@
+{
+    "exercise": "grade-school",
+    "version": "1.0.0",
+    "comments": [
+        "Given students' names along with the grade that they are in, ",
+        "create a roster for the school."
+    ],
+    "cases": [
+        {
+            "description": "Adding a student adds them to the sorted roster",
+            "property": "roster",
+            "input": {
+              "students": [["Aimee", 2]]
+            },
+            "expected": ["Aimee"]
+        },
+        {
+            "description": "Adding more student adds them to the sorted roster",
+            "property": "roster",
+            "input": {
+              "students": [["Blair", 2], ["James", 2], ["Paul", 2]]
+            },
+            "expected": ["Blair", "James", "Paul"]
+        },
+        {
+            "description": "Adding students to different grades adds them to the same sorted roster",
+            "property": "roster",
+            "input": {
+              "students": [["Chelsea", 3], ["Logan", 7]]
+            },
+            "expected": ["Chelsea", "Logan"]
+        },
+        {
+            "description": "Roster returns an empty list if there are no students enrolled",
+            "property": "roster",
+            "input": {
+              "students": []
+            },
+            "expected": []
+        },
+        {
+            "description": "Student names with grades are displayed in the same sorted roster",
+            "property": "roster",
+            "input": {
+              "students": [["Peter", 2], ["Anna", 1], ["Barb", 1], ["Zoe", 2], ["Alex", 2], ["Jim", 3], ["Charlie", 1]]
+            },
+            "expected": ["Anna", "Barb", "Charlie", "Alex", "Peter", "Zoe", "Jim"]
+        },
+        {
+            "description": "Grade returns the students in that grade in alphabetical order",
+            "property": "grade",
+            "input": {
+              "students": [["Franklin", 5], ["Bradley", 5], ["Jeff", 1]],
+              "desiredGrade": 5
+            },
+            "expected": ["Bradley", "Franklin"]
+        },
+        {
+            "description": "Grade returns an empty list if there are no students in that grade",
+            "property": "grade",
+            "input": {
+              "students": [],
+              "desiredGrade": 1
+            },
+            "expected": []
+        }
+    ]
+}

data/problem-specifications/exercises/luhn/canonical-data.json

@@ -1,6 +1,6 @@
 {
   "exercise": "luhn",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "cases": [
     {
       "description": "single digit strings can not be valid",
@@ -105,6 +105,14 @@
         "value": "091"
       },
       "expected": true
+    },
+    {
+      "description": "strings with non-digits is invalid",
+      "property": "valid",
+      "input": {
+        "value": ":9"
+      },
+      "expected": false
     }
   ]
 }

data/problem-specifications/exercises/say/description.md

@@ -22,7 +22,7 @@ Some good test cases for this program are:
 ### Extension
 
 If you're on a Mac, shell out to Mac OS X's `say` program to talk out
-loud.
+loud. If you're on Linux or Windows, eSpeakNG may be available with the command `espeak`.
 
 ## Step 2
 

data/problem-specifications/exercises/word-search/canonical-data.json

@@ -1,9 +1,8 @@
 {
   "exercise": "word-search",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "comments": [
-    "Grid rows and columns are 1-indexed.",
-    "An expected value of -1 indicates that some sort of failure should occur."
+    "Grid rows and columns are 1-indexed."
   ],
   "cases": [
     {

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

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 
-public enum GoPlayer
+public enum Owner
 {
     None,
     Black,
@@ -11,74 +11,71 @@ public enum GoPlayer
 
 public class GoCounting
 {
-    private readonly GoPlayer[][] board;
+    private readonly Owner[][] board;
 
     public GoCounting(string input)
     {
         board = ParseBoard(input);
     }
 
-    private static GoPlayer CharToPlayer(char c)
+    private static Owner CharToPlayer(char c)
     {
         switch (c)
         {
-            case 'B': return GoPlayer.Black;
-            case 'W': return GoPlayer.White;
-            default: return GoPlayer.None;
+            case 'B': return Owner.Black;
+            case 'W': return Owner.White;
+            default: return Owner.None;
         }
     }
 
-    private static GoPlayer[][] ParseBoard(string input)
+    private static Owner[][] ParseBoard(string input)
     {
         var split = input.Split('\n');
-        var rows = split.Length;
-        var cols = split[0].Length;
-
         return split.Select(row => row.Select(CharToPlayer).ToArray()).ToArray();
     }
 
     private int Cols => board[0].Length;
     private int Rows => board.Length;
 
-    private bool IsValidCoordinate(Tuple<int, int> coordinate) =>
+    private bool IsValidCoordinate(ValueTuple<int, int> coordinate) =>
         coordinate.Item2 >= 0 && coordinate.Item2 < Rows &&
         coordinate.Item1 >= 0 && coordinate.Item1 < Cols;
 
-    private GoPlayer GetPlayer(Tuple<int, int> coordinate) => board[coordinate.Item2][coordinate.Item1];
+    private Owner GetPlayer(ValueTuple<int, int> coordinate) => board[coordinate.Item2][coordinate.Item1];
 
-    private bool IsEmpty(Tuple<int, int> coordinate) => GetPlayer(coordinate) == GoPlayer.None;
-    private bool IsTaken(Tuple<int, int> coordinate) => !IsEmpty(coordinate);
+    private bool IsEmpty(ValueTuple<int, int> coordinate) => GetPlayer(coordinate) == Owner.None;
+    private bool IsTaken(ValueTuple<int, int> coordinate) => !IsEmpty(coordinate);
 
-    private IEnumerable<Tuple<int, int>> EmptyCoordinates()
+    private IEnumerable<ValueTuple<int, int>> EmptyCoordinates()
     {
         return Enumerable.Range(0, Cols).SelectMany(col =>
-               Enumerable.Range(0, Rows).Select(row => new Tuple<int, int>(col, row)))
+               Enumerable.Range(0, Rows).Select(row => new ValueTuple<int, int>(col, row)))
                 .Where(IsEmpty);
     }
 
-    private IEnumerable<Tuple<int, int>> NeighborCoordinates(Tuple<int, int> coordinate)
+    private IEnumerable<ValueTuple<int, int>> NeighborCoordinates(ValueTuple<int, int> coordinate)
     {
         var row = coordinate.Item2;
         var col = coordinate.Item1;
 
         var coords = new[]
         {
-            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)
+            new ValueTuple<int, int>(col,   row - 1),
+            new ValueTuple<int, int>(col-1, row),
+            new ValueTuple<int, int>(col+1, row),
+            new ValueTuple<int, int>(col,   row+1)
         };
 
         return coords.Where(IsValidCoordinate);
     }
 
-    private IEnumerable<Tuple<int, int>> TakenNeighborCoordinates(Tuple<int, int> coordinate) =>
+    private IEnumerable<ValueTuple<int, int>> TakenNeighborCoordinates(ValueTuple<int, int> coordinate) =>
         NeighborCoordinates(coordinate).Where(IsTaken);
 
-    private IEnumerable<Tuple<int, int>> EmptyNeighborCoordinates(Tuple<int, int> coordinate) =>
+    private IEnumerable<ValueTuple<int, int>> EmptyNeighborCoordinates(ValueTuple<int, int> coordinate) =>
         NeighborCoordinates(coordinate).Where(IsEmpty);
 
-    private GoPlayer TerritoryOwner(HashSet<Tuple<int, int>> coords)
+    private Owner TerritoryOwner(IEnumerable<ValueTuple<int, int>> coords)
     {
         var neighborColors = coords.SelectMany(TakenNeighborCoordinates).Select(GetPlayer);
         var uniqueNeighborColors = ToSet(neighborColors);
@@ -86,15 +83,15 @@ private GoPlayer TerritoryOwner(HashSet<Tuple<int, int>> coords)
         if (uniqueNeighborColors.Count == 1)
             return uniqueNeighborColors.First();
 
-        return GoPlayer.None;
+        return Owner.None;
     }
 
-    private HashSet<Tuple<int, int>> TerritoryHelper(HashSet<Tuple<int, int>> remainder, HashSet<Tuple<int, int>> acc)
+    private HashSet<ValueTuple<int, int>> TerritoryHelper(HashSet<ValueTuple<int, int>> remainder, HashSet<ValueTuple<int, int>> acc)
     {
         if (!remainder.Any())
             return acc;
 
-        var emptyNeighbors = new HashSet<Tuple<int, int>>(remainder.SelectMany(EmptyNeighborCoordinates));
+        var emptyNeighbors = new HashSet<ValueTuple<int, int>>(remainder.SelectMany(EmptyNeighborCoordinates));
         emptyNeighbors.ExceptWith(acc);
 
         var newAcc = ToSet(acc);
@@ -102,44 +99,54 @@ private GoPlayer TerritoryOwner(HashSet<Tuple<int, int>> coords)
         return TerritoryHelper(emptyNeighbors, newAcc);
     }
 
-    private HashSet<Tuple<int, int>> Territory(Tuple<int, int> coordinate) =>
+    private HashSet<ValueTuple<int, int>> TerritoryHelper(ValueTuple<int, int> coordinate) =>
         IsValidCoordinate(coordinate) && IsEmpty(coordinate)
             ? TerritoryHelper(ToSingletonSet(coordinate), ToSingletonSet(coordinate))
-            : new HashSet<Tuple<int, int>>();
+            : new HashSet<ValueTuple<int, int>>();
 
-    public Tuple<GoPlayer, IEnumerable<Tuple<int, int>>> TerritoryFor(Tuple<int, int> coord)
+    public ValueTuple<Owner, IEnumerable<ValueTuple<int, int>>> Territory(ValueTuple<int, int> coord)
     {
-        var coords = Territory(coord);
+        if (coord.Item1 < 0 || coord.Item1 >= Rows || coord.Item2 < 0 || coord.Item2 >= Cols)
+        {
+            throw new ArgumentException();
+        }
+        
+        var coords = TerritoryHelper(coord);
         if (!coords.Any())
-            return null;
+            return (Owner.None, Enumerable.Empty<ValueTuple<int, int>>());
 
         var owner = TerritoryOwner(coords);
-        return Tuple.Create(owner, coords.AsEnumerable());
+        return (owner, coords.OrderBy(x => x.Item1).ThenBy(x => x.Item2).ToArray());
     }
 
-    private Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>> TerritoriesHelper(HashSet<Tuple<int, int>> remainder, Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>> acc)
+    private Dictionary<Owner, ValueTuple<int, int>[]> TerritoriesHelper(HashSet<ValueTuple<int, int>> remainder, Dictionary<Owner, ValueTuple<int, int>[]> acc)
     {
         if (!remainder.Any())
             return acc;
 
         var coord = remainder.First();
-        var coords = Territory(coord);
+        var coords = TerritoryHelper(coord);
         var owner = TerritoryOwner(coords);
 
         var newRemainder = ToSet(remainder);
         newRemainder.ExceptWith(coords);
 
-        var newAcc = new Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>>(acc)
-        {
-            [owner] = coords
-        };
-        return TerritoriesHelper(newRemainder, newAcc);
+        acc[owner] = acc[owner].Concat(coords).ToArray();
+        return TerritoriesHelper(newRemainder, acc);
     }
 
-    public Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>> Territories()
+    public Dictionary<Owner, ValueTuple<int, int>[]> Territories()
     {
         var emptyCoords = EmptyCoordinates();
-        return TerritoriesHelper(ToSet(emptyCoords), new Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>>());
+
+        var territories = new Dictionary<Owner, ValueTuple<int, int>[]>
+        {
+            [Owner.Black] = new ValueTuple<int, int>[0],
+            [Owner.White] = new ValueTuple<int, int>[0],
+            [Owner.None] = new ValueTuple<int, int>[0]
+        };
+        
+        return TerritoriesHelper(ToSet(emptyCoords), territories);
     }
 
     private static HashSet<T> ToSet<T>(IEnumerable<T> value) => new HashSet<T>(value);

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

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 
-public enum GoPlayer
+public enum Owner
 {
     None,
     Black,
@@ -15,12 +15,12 @@ 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)
+    public Tuple<Owner, IEnumerable<ValueTuple<int, int>>> TerritoryFor(ValueTuple<int, int> coord)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>> Territories()
+    public Dictionary<Owner, IEnumerable<ValueTuple<int, int>>> Territories()
     {
         throw new NotImplementedException("You need to implement this function.");
     }

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

@@ -1,139 +1,188 @@
-using Xunit;
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+using Xunit;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 
 public class GoCountingTest
 {
-    private static readonly string boardFiveByFive =
-        string.Join("\n", new[]
-            {
-                "  B  ",
-                " B B ",
-                "B W B",
-                " W W ",
-                "  W  "
-            });
-
-    private static readonly string board9x9 =
-        string.Join("\n", new[]
-            {
-                "  B   B  ",
-                "B   B   B",
-                "WBBBWBBBW",
-                "W W W W W",
-                "         ",
-                " W W W W ",
-                "B B   B B",
-                " W BBB W ",
-                "   B B   "
-            });
-
     [Fact]
-    public void FiveByFiveTerritoryForBlack()
+    public void Black_corner_territory_on_5x5_board()
     {
-        var board = new GoCounting(boardFiveByFive);
-        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));
+        var coordinate = (0, 1);
+        var board = 
+            "  B  \n" +
+            " B B \n" +
+            "B W B\n" +
+            " W W \n" +
+            "  W  ";
+        var sut = new GoCounting(board);
+        var actual = sut.Territory(coordinate);
+        var expected = (Owner.Black, new[] { (0, 0), (0, 1), (1, 0) });
+        Assert.Equal(expected.Item1, actual.Item1);
+        Assert.Equal(expected.Item2, actual.Item2);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FiveByFiveTerritoryForWhite()
+    public void White_center_territory_on_5x5_board()
     {
-        var board = new GoCounting(boardFiveByFive);
-        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));
+        var coordinate = (2, 3);
+        var board = 
+            "  B  \n" +
+            " B B \n" +
+            "B W B\n" +
+            " W W \n" +
+            "  W  ";
+        var sut = new GoCounting(board);
+        var actual = sut.Territory(coordinate);
+        var expected = (Owner.White, new[] { (2, 3) });
+        Assert.Equal(expected.Item1, actual.Item1);
+        Assert.Equal(expected.Item2, actual.Item2);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FiveByFiveOpenTerritory()
+    public void Open_corner_territory_on_5x5_board()
     {
-        var board = new GoCounting(boardFiveByFive);
-        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));
+        var coordinate = (1, 4);
+        var board = 
+            "  B  \n" +
+            " B B \n" +
+            "B W B\n" +
+            " W W \n" +
+            "  W  ";
+        var sut = new GoCounting(board);
+        var actual = sut.Territory(coordinate);
+        var expected = (Owner.None, new[] { (0, 3), (0, 4), (1, 4) });
+        Assert.Equal(expected.Item1, actual.Item1);
+        Assert.Equal(expected.Item2, actual.Item2);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FiveByFiveNonTerritoryStone()
+    public void A_stone_and_not_a_territory_on_5x5_board()
     {
-        var board = new GoCounting(boardFiveByFive);
-        Assert.Null(board.TerritoryFor(new Tuple<int, int>(1, 1)));
+        var coordinate = (1, 1);
+        var board = 
+            "  B  \n" +
+            " B B \n" +
+            "B W B\n" +
+            " W W \n" +
+            "  W  ";
+        var sut = new GoCounting(board);
+        var actual = sut.Territory(coordinate);
+        var expected = (Owner.None, new ValueTuple<int,int>[0]);
+        Assert.Equal(expected.Item1, actual.Item1);
+        Assert.Equal(expected.Item2, actual.Item2);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FiveByFiveNonTerritoryDueToTooLowCoordinate()
+    public void Invalid_because_x_is_too_low_for_5x5_board()
     {
-        var board = new GoCounting(boardFiveByFive);
-        Assert.Null(board.TerritoryFor(new Tuple<int, int>(-1, 1)));
+        var coordinate = (-1, 1);
+        var board = 
+            "  B  \n" +
+            " B B \n" +
+            "B W B\n" +
+            " W W \n" +
+            "  W  ";
+        var sut = new GoCounting(board);
+        Assert.Throws<ArgumentException>(() => sut.Territory(coordinate));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FiveByFiveNonTerritoryDueToTooHighCoordinate()
+    public void Invalid_because_x_is_too_high_for_5x5_board()
     {
-        var board = new GoCounting(boardFiveByFive);
-        Assert.Null(board.TerritoryFor(new Tuple<int, int>(1, 5)));
+        var coordinate = (5, 1);
+        var board = 
+            "  B  \n" +
+            " B B \n" +
+            "B W B\n" +
+            " W W \n" +
+            "  W  ";
+        var sut = new GoCounting(board);
+        Assert.Throws<ArgumentException>(() => sut.Territory(coordinate));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void MinimalBoardWithNoTerritories()
+    public void Invalid_because_y_is_too_low_for_5x5_board()
     {
-        var input = "B";
-        var board = new GoCounting(input);
-
-        var expected = new Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>>();
-
-        Assert.Equal(expected, board.Territories());
+        var coordinate = (1, -1);
+        var board = 
+            "  B  \n" +
+            " B B \n" +
+            "B W B\n" +
+            " W W \n" +
+            "  W  ";
+        var sut = new GoCounting(board);
+        Assert.Throws<ArgumentException>(() => sut.Territory(coordinate));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void OneTerritoryCoveringTheWholeBoard()
+    public void Invalid_because_y_is_too_high_for_5x5_board()
     {
-        var input = " ";
-        var board = new GoCounting(input);
-        var actual = board.Territories();
+        var coordinate = (1, 5);
+        var board = 
+            "  B  \n" +
+            " B B \n" +
+            "B W B\n" +
+            " W W \n" +
+            "  W  ";
+        var sut = new GoCounting(board);
+        Assert.Throws<ArgumentException>(() => sut.Territory(coordinate));
+    }
 
-        var expected = new Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>>
+    [Fact(Skip = "Remove to run test")]
+    public void One_territory_is_the_whole_board()
+    {
+        var board = " ";
+        var sut = new GoCounting(board);
+        var actual = sut.Territories();
+        var expected = new Dictionary<Owner, ValueTuple<int,int>[]>
         {
-            [GoPlayer.None] = new[] { new Tuple<int, int>(0, 0) }
+            [Owner.Black] = new ValueTuple<int,int>[0],
+            [Owner.White] = new ValueTuple<int,int>[0],
+            [Owner.None] = new[] { (0, 0) }
         };
-        
         Assert.Equal(expected.Keys, actual.Keys);
-        Assert.Equal(expected[GoPlayer.None], actual[GoPlayer.None]);
+        Assert.Equal(expected[Owner.Black], actual[Owner.Black]);
+        Assert.Equal(expected[Owner.White], actual[Owner.White]);
+        Assert.Equal(expected[Owner.None], actual[Owner.None]);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void TwoTerritoriesOnRectangularBoard()
+    public void Two_territory_rectangular_board()
     {
-        var input = string.Join("\n", new[] { " BW ", " BW " });
-        var board = new GoCounting(input);
-        var actual = board.Territories();
-
-        var expected = new Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>>
+        var board = 
+            " BW \n" +
+            " BW ";
+        var sut = new GoCounting(board);
+        var actual = sut.Territories();
+        var expected = new Dictionary<Owner, ValueTuple<int,int>[]>
         {
-            [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) }
+            [Owner.Black] = new[] { (0, 0), (0, 1) },
+            [Owner.White] = new[] { (3, 0), (3, 1) },
+            [Owner.None] = new ValueTuple<int,int>[0]
         };
-                
         Assert.Equal(expected.Keys, actual.Keys);
-        Assert.Equal(expected[GoPlayer.Black], actual[GoPlayer.Black]);
-        Assert.Equal(expected[GoPlayer.White], actual[GoPlayer.White]);
+        Assert.Equal(expected[Owner.Black], actual[Owner.Black]);
+        Assert.Equal(expected[Owner.White], actual[Owner.White]);
+        Assert.Equal(expected[Owner.None], actual[Owner.None]);
     }
 
-    private class EnumerableEqualityComparer<T> : IEqualityComparer<IEnumerable<T>>
+    [Fact(Skip = "Remove to run test")]
+    public void Two_region_rectangular_board()
     {
-        public static readonly EnumerableEqualityComparer<T> Instance = new EnumerableEqualityComparer<T>();
-
-        public bool Equals(IEnumerable<T> x, IEnumerable<T> y) => x.SequenceEqual(y);
-
-        public int GetHashCode(IEnumerable<T> obj)
+        var board = " B ";
+        var sut = new GoCounting(board);
+        var actual = sut.Territories();
+        var expected = new Dictionary<Owner, ValueTuple<int,int>[]>
         {
-            throw new NotImplementedException();
-        }
+            [Owner.Black] = new[] { (0, 0), (2, 0) },
+            [Owner.White] = new ValueTuple<int,int>[0],
+            [Owner.None] = new ValueTuple<int,int>[0]
+        };
+        Assert.Equal(expected.Keys, actual.Keys);
+        Assert.Equal(expected[Owner.Black], actual[Owner.Black]);
+        Assert.Equal(expected[Owner.White], actual[Owner.White]);
+        Assert.Equal(expected[Owner.None], actual[Owner.None]);
     }
-}
+}