public void TestGetSquareFromPosition()
{
var p = new MockedPiece(true);
var position = CreatePosition(p);
Assert.Equal(new Square(Files.a, Ranks.two), p.GetSquareFrom(position));
}
public void TestGetSquareFromPieceNotInPosition()
{
var p = new MockedPiece(false);
var position = CreatePosition();
Assert.Null(p.GetSquareFrom(position));
}
public void TestAttackFromOffThePosition()
{
var piece = new MockedPiece(true);
var m = piece.AttackSquare(
new Square(Files.a, Ranks.two),
CreatePositionA());
Assert.Null(m);
}
public void TestAttackNoSquares()
{
var piece = new MockedPiece(true);
var m = piece.AttackSquare(
null,
CreatePositionA(piece));
Assert.Null(m);
}
public void TestAttackOnSquareOccupiedBySameColor()
{
var piece = new MockedPiece(true);
var m = piece.AttackSquare(
new Square(Files.b, Ranks.one),
CreatePositionA(piece));
Assert.Null(m);
}
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 TestAttackThroughFromOffThePosition()
{
var piece = new MockedPiece(true);
var m = piece.Attack(
Through.Files,
true,
CreatePositionA());
Assert.Empty(m);
}
public void TestAttackOnSquareOcuppiedByOppositeColor()
{
var piece = new MockedPiece(true);
var m = piece.AttackSquare(
new Square(Files.b, Ranks.two),
CreatePositionA(piece));
Assert.Equal(new Square(Files.a, Ranks.one), m.FromSquare);
Assert.Equal(new Square(Files.b, Ranks.two), m.ToSquare);
Assert.Equal(MoveType.Capture, m.Type);
}
public void TestAttackOnEmptySquare()
{
var piece = new MockedPiece(true);
var m = piece.AttackSquare(
new Square(Files.a, Ranks.two),
CreatePositionA(piece));
Assert.Equal(new Square(Files.a, Ranks.one), m.FromSquare);
Assert.Equal(new Square(Files.a, Ranks.two), m.ToSquare);
Assert.Equal(MoveType.Normal, m.Type);
}
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]);
}
private IReadOnlyDictionary <Square, IPiece> CreatePositionB(
Square sWhite = null,
Square sBlack = null)
{
var position = new Dictionary <Square, IPiece>()
{
{ SquareEFour, new MockedPiece(true) }
};
if (sWhite is not null)
{
position[sWhite] = new MockedPiece(true);
}
if (sBlack is not null)
{
position[sBlack] = new MockedPiece(false);
}
return(position);
}
public void TestIPieceInterface()
{
IPiece p = new MockedPiece(false);
Assert.Empty(p.AvailableMoves(new Dictionary <Square, IPiece>()));
}
public void TestPieceConstruction()
{
var p = new MockedPiece(true);
p.AvailableMoves(new Dictionary <Square, IPiece>());
}
