public void VerifyMoveCauseCheck_MoveNotCauseCheck_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var pawnStartPosition = new Position(1, 0);
var pawnEndPosition = new Position(2, 0);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(pawnStartPosition, pawnEndPosition);
// assert
Assert.False(result);
}
public void VerifyMoveCauseCheck_NoFigureAtPosition_ShouldThrowException()
{
// arrange
var board = new OrdinaryChessBoard();
var pawnStartPosition = new Position(2, 0);
var pawnEndPosition = new Position(3, 0);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
// assert
Assert.Throws <RemoveFromBoardEmptyFieldException>(() =>
verifier.VerifyMoveCauseCheck(pawnStartPosition, pawnEndPosition));
}
public void VerifyMoveCauseCheck_CannotMove_InvalidMoveForFigure_ShouldThrowException()
{
// arrange
var board = new OrdinaryChessBoard();
var knightStartPosition = new Position(0, 1);
var knightEndPosition = new Position(5, 1);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
// assert
Assert.Throws <InvalidMoveException>(() =>
verifier.VerifyMoveCauseCheck(knightStartPosition, knightEndPosition));
}
public void IsCheckMate_OnlyCheck_PathMayBeBlocked_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var blackPawnStartPosition = new Position(1, 3);
var blackPawnEndPosition = new Position(2, 3);
var whitePawnStartPosition = new Position(6, 2);
var whitePawnEndPosition = new Position(5, 2);
var whiteQueenStartPosition = new Position(7, 3);
var whiteQueenEndPosition = new Position(4, 0);
var blackPawn1 = board.RemoveFigure(blackPawnStartPosition);
blackPawn1.Move(blackPawnEndPosition);
board.SetFigure(blackPawn1, blackPawnEndPosition);
var whitePawn = board.RemoveFigure(whitePawnStartPosition);
whitePawn.Move(whitePawnEndPosition);
board.SetFigure(whitePawn, whitePawnEndPosition);
var whiteQueen = board.RemoveFigure(whiteQueenStartPosition);
whiteQueen.Move(whiteQueenEndPosition);
board.SetFigure(whiteQueen, whiteQueenEndPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm = new LastMoveViewModel(whiteQueen, whiteQueenStartPosition, whitePawnEndPosition, null);
var moveResult =
new ValidMoveResult(board, verifier, validator, lastMoveVm, null);
var team1 = TeamColor.White;
var team2 = TeamColor.Black;
// act
var result1 = moveResult.IsCheck(team1);
var result2 = moveResult.IsCheck(team2);
var result3 = moveResult.IsCheckMate(team1);
var result4 = moveResult.IsCheckMate(team2);
// assert
Assert.True(result1);
Assert.False(result2);
Assert.False(result3);
Assert.False(result4);
}
public void CanMove_King_CanMove_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var destPosition = new Models.Position.Position(1, 4);
var kingPosition = new Models.Position.Position(0, 4);
board.RemoveFigure(destPosition);
var king = board.FigureAt(kingPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(king, destPosition);
// assert
Assert.True(result.Item1);
}
public void CanMove_Queen_CanMove_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var startQueenPosition = new Models.Position.Position(0, 3);
var destQueenPosition = new Models.Position.Position(4, 7);
var pawnPosition = new Models.Position.Position(1, 4);
board.RemoveFigure(pawnPosition);
var queen = board.FigureAt(startQueenPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(queen, destQueenPosition);
// assert
Assert.True(result.Item1);
}
public void CanMove_Bishop_OutOfBoundaries_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var startBishopPosition = new Models.Position.Position(0, 2);
var destBishopPosition = new Models.Position.Position(5, 8);
var pawnPosition = new Models.Position.Position(1, 3);
board.RemoveFigure(pawnPosition);
var bishop = board.FigureAt(startBishopPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(bishop, destBishopPosition);
// assert
Assert.False(result.Item1);
}
public void CanMove_Rook_EnemyBlockPath_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var startRookPosition = new Models.Position.Position(0, 0);
var destRookPosition = new Models.Position.Position(7, 0);
var pawnPosition = new Models.Position.Position(1, 0);
board.RemoveFigure(pawnPosition);
var queen = board.FigureAt(startRookPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(queen, destRookPosition);
// assert
Assert.False(result.Item1);
}
public void LastMoveFigureAndPositionFromAndDest_Smash()
{
// arrange
var board = new OrdinaryChessBoard();
var startBlackPawnPosition = new Position(1, 5);
var oneHopBlackPawnPosition = new Position(3, 5);
var startWhitePawnPosition = new Position(6, 4);
var oneHopWhitePawnPosition = new Position(4, 4);
var blackPawn = board.RemoveFigure(startBlackPawnPosition);
blackPawn.Move(oneHopBlackPawnPosition);
board.SetFigure(blackPawn, oneHopBlackPawnPosition);
var whitePawn = board.RemoveFigure(startWhitePawnPosition);
whitePawn.Move(oneHopWhitePawnPosition);
board.SetFigure(whitePawn, oneHopWhitePawnPosition);
board.RemoveFigure(oneHopWhitePawnPosition);
blackPawn = board.RemoveFigure(oneHopBlackPawnPosition);
blackPawn.Move(oneHopWhitePawnPosition);
board.SetFigure(blackPawn, oneHopWhitePawnPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm =
new LastMoveViewModel(blackPawn, oneHopBlackPawnPosition, oneHopWhitePawnPosition, whitePawn);
var moveResult = new ValidMoveResult(board, verifier, null, lastMoveVm, null);
var expectedLastMoveFigure = blackPawn;
var expectedLastMovePositionFrom = oneHopBlackPawnPosition;
var expectedLastMovePositionDest = oneHopWhitePawnPosition;
// act
var result = moveResult.LastMoveFigureAndPositionFromAndDest();
// assert
Assert.AreEqual(expectedLastMoveFigure, result.Item1);
Assert.AreEqual(expectedLastMovePositionFrom, result.Item2);
Assert.AreEqual(expectedLastMovePositionDest, result.Item3);
}
public void VerifyMoveCauseCheck_MoveBlackBishop_CheckWhiteKing_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var whiteRemovePawnPosition = new Position(6, 3);
var blackRemovePawnPosition = new Position(1, 4);
var blackBishopStartPosition = new Position(0, 5);
var blackBishopEndPosition = new Position(4, 1);
board.RemoveFigure(whiteRemovePawnPosition);
board.RemoveFigure(blackRemovePawnPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(blackBishopStartPosition, blackBishopEndPosition);
// assert
Assert.True(result);
}
/// <summary>
/// Helper function to IsCheckMate
/// Verify if Any of king possible move is not Check
/// </summary>
/// <param name="king"></param>
/// <param name="teamColor"></param>
/// <returns></returns>
private bool VerifyIfKingMayEscape(Figure king, TeamColor teamColor)
{
IBoard copyBoard = _board.Copy();
var validator = new OrdinaryBoardMoveValidator(copyBoard);
var verifier = new OrdinaryBoardCheckVerifier(copyBoard, validator);
foreach (var possibleKingMove in GetPossibleKingMoves(king))
{
King newKing = new King(possibleKingMove, king.TeamColor);
copyBoard.RemoveFigure(king.Position);
var figureAtKingMove = copyBoard.RemoveFigure(possibleKingMove);
copyBoard.SetFigure(newKing, possibleKingMove);
if (!verifier.IsCheck(teamColor))
{
return(true);
}
copyBoard.SetFigure(figureAtKingMove, possibleKingMove);
copyBoard.SetFigure(king, king.Position);
}
return(false);
}
public void GetScore_AfterKilledWhite_BlackTeam_ShouldBe_Minus19()
{
// arrange
var board = new OrdinaryChessBoard();
TeamColor team = TeamColor.Black;
var startBlackPawnPosition = new Position(1, 5);
var oneHopBlackPawnPosition = new Position(3, 5);
var startWhitePawnPosition = new Position(6, 4);
var oneHopWhitePawnPosition = new Position(4, 4);
var blackPawn = board.RemoveFigure(startBlackPawnPosition);
blackPawn.Move(oneHopBlackPawnPosition);
board.SetFigure(blackPawn, oneHopBlackPawnPosition);
var whitePawn = board.RemoveFigure(startWhitePawnPosition);
whitePawn.Move(oneHopWhitePawnPosition);
board.SetFigure(whitePawn, oneHopWhitePawnPosition);
board.RemoveFigure(oneHopWhitePawnPosition);
blackPawn = board.RemoveFigure(oneHopBlackPawnPosition);
blackPawn.Move(oneHopWhitePawnPosition);
board.SetFigure(blackPawn, oneHopWhitePawnPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm =
new LastMoveViewModel(blackPawn, oneHopBlackPawnPosition, oneHopWhitePawnPosition, whitePawn);
var moveResult = new ValidMoveResult(board, verifier, null, lastMoveVm, null);
int expectedScore = -19;
// act
var result = moveResult.GetScore(team);
// assert
Assert.AreEqual(expectedScore, result);
}
public void SmashedFigure_SmashedWhitePawn_ShouldThisFigure()
{
// arrange
var board = new OrdinaryChessBoard();
var startBlackPawnPosition = new Position(1, 5);
var oneHopBlackPawnPosition = new Position(3, 5);
var startWhitePawnPosition = new Position(6, 4);
var oneHopWhitePawnPosition = new Position(4, 4);
var blackPawn = board.RemoveFigure(startBlackPawnPosition);
blackPawn.Move(oneHopBlackPawnPosition);
board.SetFigure(blackPawn, oneHopBlackPawnPosition);
var whitePawn = board.RemoveFigure(startWhitePawnPosition);
whitePawn.Move(oneHopWhitePawnPosition);
board.SetFigure(whitePawn, oneHopWhitePawnPosition);
board.RemoveFigure(oneHopWhitePawnPosition);
blackPawn = board.RemoveFigure(oneHopBlackPawnPosition);
blackPawn.Move(oneHopWhitePawnPosition);
board.SetFigure(blackPawn, oneHopWhitePawnPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm =
new LastMoveViewModel(blackPawn, oneHopBlackPawnPosition, oneHopWhitePawnPosition, whitePawn);
var moveResult = new ValidMoveResult(board, verifier, null, lastMoveVm, null);
var expected = whitePawn;
// act
var isSmash = moveResult.IsLastMoveSmash();
var result = moveResult.SmashedFigure();
// assert
Assert.True(isSmash);
Assert.AreEqual(expected, result);
}
public void CanMove_Pawn_PositionAlreadyTakenByEnemy_NotAttack_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var startPawnPosition = new Models.Position.Position(1, 0);
var destPawnPosition = new Models.Position.Position(2, 0);
var enemyStartPosition = new Models.Position.Position(6, 0);
var enemy = board.RemoveFigure(enemyStartPosition);
enemy.Move(destPawnPosition);
board.SetFigure(enemy, destPawnPosition);
var pawn = board.FigureAt(startPawnPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(pawn, destPawnPosition);
// assert
Assert.False(result.Item1);
}
public void IsCheck_WhiteTeam_NotCheck_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var startBlackPawnPosition = new Position(1, 5);
var endBlackPawnPosition = new Position(3, 5);
var blackPawn = board.RemoveFigure(startBlackPawnPosition);
blackPawn.Move(endBlackPawnPosition);
board.SetFigure(blackPawn, endBlackPawnPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var checkVerifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
TeamColor teamColor = TeamColor.White;
// act
var result = checkVerifier.IsCheck(teamColor);
// assert
Assert.False(result);
}
public void CanMove_Rook_PositionAlreadyTakenByAlly_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var startRookPosition = new Models.Position.Position(0, 0);
var destRookPosition = new Models.Position.Position(4, 0);
var pawnPosition = new Models.Position.Position(1, 0);
var pawn = board.RemoveFigure(pawnPosition);
pawn.Move(destRookPosition);
board.SetFigure(pawn, destRookPosition);
var queen = board.FigureAt(startRookPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(queen, destRookPosition);
// assert
Assert.False(result.Item1);
}
public void VerifyMoveCauseCheck_MoveWhiteKnight_CheckBlackKing_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var whiteKnightStartPosition = new Position(7, 1);
var whiteKnightMiddlePosition = new Position(4, 2);
var whiteKnightEndPosition = new Position(2, 3);
var knight = board.RemoveFigure(whiteKnightStartPosition);
knight.Move(whiteKnightMiddlePosition);
board.SetFigure(knight, whiteKnightMiddlePosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(whiteKnightMiddlePosition, whiteKnightEndPosition);
// assert
Assert.True(result);
}
[Test] public void IsCheck_WhiteTeam_WhiteChecked_Knight_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var knightStartPosition = new Position(0, 1);
var knightEndPosition = new Position(5, 3);
var knight = board.RemoveFigure(knightStartPosition);
knight.Move(knightEndPosition);
board.SetFigure(knight, knightEndPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
TeamColor teamColor = TeamColor.White;
// act
var result = verifier.IsCheck(teamColor);
// assert
Assert.False(result);
}
public void CanMove_King_PositionAlreadyTakenByEnemy_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var destPosition = new Models.Position.Position(1, 4);
var startEnemyPosition = new Models.Position.Position(6, 4);
var kingPosition = new Models.Position.Position(0, 4);
board.RemoveFigure(destPosition);
var enemyPawn = board.RemoveFigure(startEnemyPosition);
enemyPawn.Move(destPosition);
board.SetFigure(enemyPawn, destPosition);
var king = board.FigureAt(kingPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(king, destPosition);
// assert
Assert.True(result.Item1);
}
/// <summary>
/// Helper function to IsCheckMate
/// Verify if after killing there is not Check
/// </summary>
/// <param name="aimPosition">Position of figure which cause Check</param>
/// <param name="teamColor">Color of checked Team</param>
/// <returns></returns>
private bool VerifyIfAfterKillKingWillBeFree(Position aimPosition, TeamColor teamColor)
{
IBoard copyBoard = _board.Copy();
var validator = new OrdinaryBoardMoveValidator(copyBoard);
var verifier = new OrdinaryBoardCheckVerifier(copyBoard, validator);
copyBoard.RemoveFigure(aimPosition);
foreach (var possibleKiller in FindPossibleKillers(aimPosition, teamColor))
{
var startPosition = possibleKiller.Position;
var killer = copyBoard.RemoveFigure(startPosition);
killer.Move(aimPosition);
copyBoard.SetFigure(killer, aimPosition);
if (!verifier.IsCheck(teamColor))
{
killer.Move(startPosition);
return(true);
}
killer.Move(startPosition);
copyBoard.SetFigure(killer, startPosition);
}
return(false);
}
public void CanMove_Knight_PositionAlreadyTakenByEnemy_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var startKnightPosition = new Models.Position.Position(0, 1);
var destKnightPosition = new Models.Position.Position(2, 2);
var enemyPawnStartPosition = new Models.Position.Position(6, 2);
var enemyPawnEndPosition = new Models.Position.Position(2, 2);
var enemy = board.RemoveFigure(enemyPawnStartPosition);
enemy.Move(enemyPawnEndPosition);
board.SetFigure(enemy, enemyPawnEndPosition);
var bishop = board.FigureAt(startKnightPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(bishop, destKnightPosition);
// assert
Assert.True(result.Item1);
}
public void VerifyMoveCauseCheck_BlackKingChecked_MoveToCheckedPosition_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var blackPawnRemove1Postion = new Position(1, 3);
var blackPawnRemove2Postion = new Position(1, 4);
var startWhiteQueenPosition = new Position(7, 3);
var endWhiteQueenPosition = new Position(4, 0);
var whiteBishopStartPosition = new Position(7, 2);
var whiteBishopEndPosition = new Position(4, 1);
var blackKingStartPosition = new Position(0, 4);
var blackKingEndPosition = new Position(1, 4);
board.RemoveFigure(blackPawnRemove1Postion);
board.RemoveFigure(blackPawnRemove2Postion);
var whiteQueen = board.RemoveFigure(startWhiteQueenPosition);
whiteQueen.Move(endWhiteQueenPosition);
board.SetFigure(whiteQueen, endWhiteQueenPosition);
var bishop = board.RemoveFigure(whiteBishopStartPosition);
bishop.Move(whiteBishopEndPosition);
board.SetFigure(bishop, whiteBishopEndPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(blackKingStartPosition, blackKingEndPosition);
// assert
Assert.True(result);
}
private bool VerifyIfOtherFigureMayBlock(Figure culprit, Position kingPosition, TeamColor teamColor)
{
IBoard copyBoard = _board.Copy();
var validator = new OrdinaryBoardMoveValidator(copyBoard);
var verifier = new OrdinaryBoardCheckVerifier(copyBoard, validator);
foreach (var figureAndPos in FindPossibleBlockers(culprit, kingPosition, teamColor))
{
var startPosition = figureAndPos.Item1.Position;
var blocker = copyBoard.RemoveFigure(startPosition);
var figureAtEndPos = copyBoard.RemoveFigure(figureAndPos.Item2);
blocker.Move(figureAndPos.Item2);
copyBoard.SetFigure(blocker, figureAndPos.Item2);
if (!verifier.IsCheck(teamColor))
{
blocker.Move(startPosition);
return(true);
}
blocker.Move(startPosition);
copyBoard.SetFigure(blocker, startPosition);
copyBoard.SetFigure(figureAtEndPos, figureAndPos.Item2);
}
return(false);
}
public void VerifyMoveCauseCheck_BlackPawn_RevealsTheBlackKing_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var blackPawnStartPosition = new Position(1, 3);
var blackPawnEndPosition = new Position(2, 3);
var startWhiteQueenPosition = new Position(7, 3);
var endWhiteQueenPosition = new Position(4, 0);
var whiteQueen = board.RemoveFigure(startWhiteQueenPosition);
whiteQueen.Move(endWhiteQueenPosition);
board.SetFigure(whiteQueen, endWhiteQueenPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(blackPawnStartPosition, blackPawnEndPosition);
// assert
Assert.True(result);
}
public void GetScore_AfterMovementBlack_BottomLeftPawnTwoFieldUp_BlackTeam_ShouldBe_1()
{
// arrange
var board = new OrdinaryChessBoard();
TeamColor team = TeamColor.Black;
var startPawnPosition = new Position(1, 0);
var endPawnPosition = new Position(3, 0);
var pawn = board.RemoveFigure(startPawnPosition);
pawn.Move(endPawnPosition);
board.SetFigure(pawn, endPawnPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm = new LastMoveViewModel(pawn, startPawnPosition, endPawnPosition, null);
var moveResult = new ValidMoveResult(board, verifier, null, lastMoveVm, null);
int expectedScore = 1;
// act
var result = moveResult.GetScore(team);
// assert
Assert.AreEqual(expectedScore, result);
}
