public void TestEmptyChessBoard()
{
IChess chess = new MockedChess();
Assert.Empty(chess.MoveEntries);
Assert.Empty(chess.Position);
}
public void TestConstructorOverload()
{
var move = new Move(
new Square(Files.a, Ranks.one),
new Square(Files.b, Ranks.two),
MoveType.Normal
);
IReadOnlyDictionary <Square, IPiece> pastPosition =
new Dictionary <Square, IPiece>()
{
{ new Square(Files.a, Ranks.one), new MockedPiece(true) }
};
IReadOnlyDictionary <Square, IPiece> position =
new Dictionary <Square, IPiece>()
{
{ new Square(Files.a, Ranks.two), new MockedPiece(true) }
};
IReadOnlyCollection <MoveEntry> moveEntries =
new List <MoveEntry>()
{
new MoveEntry(move, pastPosition)
};
IChess chess = new MockedChess(position, moveEntries);
Assert.Equal(moveEntries, chess.MoveEntries);
Assert.Equal(position.Keys, chess.Position.Keys);
Assert.True(chess.Position.Values.Single() is MockedPiece);
Assert.True(chess.MoveEntries.Single().Position.Values.Single() is MockedPiece);
}
public void TestClearEmptySquare()
{
Chess chess = new MockedChess();
Square square = new Square(Files.a, Ranks.one);
Assert.Throws <ArgumentException>(() => chess.Clear(square));
}
public void TestRemovePieceFromChess()
{
var occupiedSquare = new Square(Files.a, Ranks.one);
var emptySquare = new Square(Files.b, Ranks.two);
var chess = new MockedChess(new Dictionary <Square, IPiece>()
{
{ occupiedSquare, new MockedPiece(false) }
});
IPiece nullPiece;
IPiece boardPiece;
Assert.False(chess.RemovePiece(emptySquare, out nullPiece));
Assert.Null(nullPiece);
Assert.True(chess.Position.ContainsKey(occupiedSquare));
Assert.True(chess.RemovePiece(occupiedSquare, out boardPiece));
Assert.NotNull(boardPiece);
Assert.True(boardPiece is MockedPiece);
Assert.False(boardPiece.Color);
Assert.Empty(chess.Position);
}
public void TestPlaceAt()
{
Chess chess = new MockedChess();
IPiece piece = new MockedPiece(true);
Square square = new Square(Files.a, Ranks.one);
chess.PlaceAt(square, piece);
Assert.Single(chess.Position);
Assert.True(piece == chess.Position[square]);
}
public void TestPlaceAtOccupiedSquare()
{
Chess chess = new MockedChess();
IPiece occupyingPiece = new MockedPiece(true);
IPiece piece = new MockedPiece(false);
Square square = new Square(Files.a, Ranks.one);
chess.PlaceAt(square, occupyingPiece);
Assert.Throws <ArgumentException>(() => chess.PlaceAt(square, piece));
Assert.True(occupyingPiece == chess.Position[square]);
}
public void TestClear()
{
Chess chess = new MockedChess();
IPiece piece = new MockedPiece(false);
Square square = new Square(Files.a, Ranks.one);
chess.PlaceAt(square, piece);
chess.Clear(square);
Assert.Empty(chess.Position);
Assert.Throws <System.Collections.Generic.KeyNotFoundException>(() => chess.Position[square]);
}
public void TestAddPieceInChess()
{
var chess = new MockedChess();
var piece = new MockedPiece(true);
var square = new Square(Files.a, Ranks.one);
Assert.True(chess.AddPiece(square, piece));
Assert.False(chess.AddPiece(square, piece));
Assert.Single(chess.Position);
Assert.Equal(piece, chess.Position[square]);
}
public void TestMockedChessOverrides()
{
var chess = new MockedChess();
Assert.Empty(chess.AllMoves(true));
Assert.Empty(chess.AllMoves(false));
Assert.Empty(chess.AvailableMoves(true));
Assert.Empty(chess.AvailableMoves(false));
Assert.False(chess.Process(
new Move(
new Square(Files.a, Ranks.one),
new Square(Files.a, Ranks.one),
MoveType.Normal),
out IPiece piece));
Assert.Null(piece);
}
public void TestInvalidMove(
bool withPiece
)
{
IChess chess = new MockedChess();
var invalid = new Move(
new Square(Files.a, Ranks.one),
new Square(Files.b, Ranks.two),
MoveType.Normal);
if (withPiece)
{
((Chess)chess).PlaceAt(invalid.FromSquare, new MockedPiece(true));
}
Assert.False(chess.Process(invalid, out IPiece p));
}
public void TestAdd()
{
IChess chess = new MockedChess(new Dictionary <Square, IPiece>()
{
{ new Square(Files.a, Ranks.one), new MockedPiece(true) }
});
var move = new Move(
new Square(Files.a, Ranks.one),
new Square(Files.b, Ranks.two),
MoveType.Normal);
var entry = new MoveEntry(move, chess.Position);
((Chess)chess).Add(entry);
Assert.Single(chess.MoveEntries);
Assert.Equal(chess.Position.Keys, chess.MoveEntries.Last().Position.Keys);
Assert.All(chess.Position.Keys, k =>
{
Assert.True(chess.MoveEntries.Last().Position[k] is MockedPiece);
Assert.True(chess.MoveEntries.Last().Position[k].Color);
});
Assert.Equal(move, chess.MoveEntries.Last().Move);
}
public void TestChessBoard()
{
IReadOnlyDictionary <Square, IPiece> position = new Dictionary <Square, IPiece>()
{
{ new Square(Files.a, Ranks.one), new MockedPiece(true) },
{ new Square(Files.b, Ranks.two), new MockedPiece(false) },
{ new Square(Files.c, Ranks.three), new MockedPiece(true) },
{ new Square(Files.d, Ranks.four), new MockedPiece(false) },
{ new Square(Files.e, Ranks.five), new MockedPiece(true) },
{ new Square(Files.f, Ranks.six), new MockedPiece(false) },
{ new Square(Files.g, Ranks.seven), new MockedPiece(true) },
{ new Square(Files.h, Ranks.eight), new MockedPiece(false) },
};
IChess chess = new MockedChess(position);
Assert.Empty(chess.MoveEntries);
Assert.Empty(chess.AvailableMoves(false));
Assert.Equal(8, chess.Position.Count);
Assert.All(
position.Keys,
s => {
Assert.NotEqual(position[s], chess.Position[s]);
Assert.True(chess.Position[s] is MockedPiece);
if ((int)s.File % 2 == 0)
{
Assert.False(chess.Position[s].Color);
}
else
{
Assert.True(chess.Position[s].Color);
}
}
);
}
