1
exercism fetch csharp go-counting

GoCountingTest.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
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()
    {
        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));
    }

    [Fact(Skip = "Remove to run test")]
    public void FiveByFiveTerritoryForWhite()
    {
        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));
    }

    [Fact(Skip = "Remove to run test")]
    public void FiveByFiveOpenTerritory()
    {
        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));
    }

    [Fact(Skip = "Remove to run test")]
    public void FiveByFiveNonTerritoryStone()
    {
        var board = new GoCounting(boardFiveByFive);
        Assert.Null(board.TerritoryFor(new Tuple<int, int>(1, 1)));
    }

    [Fact(Skip = "Remove to run test")]
    public void FiveByFiveNonTerritoryDueToTooLowCoordinate()
    {
        var board = new GoCounting(boardFiveByFive);
        Assert.Null(board.TerritoryFor(new Tuple<int, int>(-1, 1)));
    }

    [Fact(Skip = "Remove to run test")]
    public void FiveByFiveNonTerritoryDueToTooHighCoordinate()
    {
        var board = new GoCounting(boardFiveByFive);
        Assert.Null(board.TerritoryFor(new Tuple<int, int>(1, 5)));
    }

    [Fact(Skip = "Remove to run test")]
    public void MinimalBoardWithNoTerritories()
    {
        var input = "B";
        var board = new GoCounting(input);

        var expected = new Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>>();

        Assert.Equal(expected, board.Territories());
    }

    [Fact(Skip = "Remove to run test")]
    public void OneTerritoryCoveringTheWholeBoard()
    {
        var input = " ";
        var board = new GoCounting(input);
        var actual = board.Territories();

        var expected = new Dictionary<GoPlayer, IEnumerable<Tuple<int, int>>>
        {
            [GoPlayer.None] = new[] { new Tuple<int, int>(0, 0) }
        };
        
        Assert.Equal(expected.Keys, actual.Keys);
        Assert.Equal(expected[GoPlayer.None], actual[GoPlayer.None]);
    }

    [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<GoPlayer, IEnumerable<Tuple<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) }
        };
                
        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);

        public int GetHashCode(IEnumerable<T> obj)
        {
            throw new NotImplementedException();
        }
    }
}