public void IsCheckMate_NotCheck_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var pawnStartPosition = new Position(1, 0);
var pawnEndPosition = new Position(2, 0);
var pawn = board.RemoveFigure(pawnStartPosition);
pawn.Move(pawnEndPosition);
board.SetFigure(pawn, pawnEndPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm = new LastMoveViewModel(pawn, pawnStartPosition, pawnEndPosition, null);
var moveResult =
new ValidMoveResult(board, verifier, validator, lastMoveVm, null);
var team1 = TeamColor.Black;
var team2 = TeamColor.White;
// act
var result1 = moveResult.IsCheck(team1);
var result2 = moveResult.IsCheck(team2);
var result3 = moveResult.IsCheckMate(team1);
var result4 = moveResult.IsCheckMate(team2);
// assert
Assert.False(result1);
Assert.False(result2);
Assert.False(result3);
Assert.False(result4);
}
public void GetScoreForTeam_AfterMovementWhite_BottomLeftPawnTwoFieldUp_WhiteTeam_ShouldBe_Minus1()
{
// arrange
var board = new OrdinaryChessBoard();
TeamColor team = TeamColor.White;
int expectedScore = -1;
var startPawnPosition = new Models.Position.Position(1, 0);
var endPawnPosition = new Models.Position.Position(3, 0);
// act
var pawn = board.RemoveFigure(startPawnPosition);
var x = new OrdinaryChessBoardFigurePositionWeight();
x.GetPositionWeight(pawn);
board.SetFigure(pawn, endPawnPosition);
pawn.Move(endPawnPosition);
x.GetPositionWeight(pawn);
var result = board.GetScoreForTeam(team);
// assert
Assert.AreEqual(expectedScore, result);
}
public void GetScore_AfterMovementBlack_BottomLeftPawnTwoFieldUp_WhiteTeam_ShouldBe_Minus1()
{
// arrange
var startingBoard = new OrdinaryChessBoard();
TeamColor team = TeamColor.White;
var startPawnPosition = new Position(1, 0);
var endPawnPosition = new Position(3, 0);
var pawn = startingBoard.RemoveFigure(startPawnPosition);
startingBoard.SetFigure(pawn, endPawnPosition);
pawn.Move(endPawnPosition);
var validator = new OrdinaryBoardMoveValidator(startingBoard);
var verifier = new OrdinaryBoardCheckVerifier(startingBoard, validator);
var lastMoveVm = new LastMoveViewModel(pawn, startPawnPosition, endPawnPosition, null);
var moveResult =
new ValidMoveResult(startingBoard, verifier, null, lastMoveVm, null);
int expectedScore = -1;
// act
var result = moveResult.GetScore(team);
// assert
Assert.AreEqual(expectedScore, result);
}
public void VerifyMoveCauseCheck_BlackKingChecked_MoveToSavePosition_ShouldReturnFalse()
{
// 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 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 moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(blackKingStartPosition, blackKingEndPosition);
// assert
Assert.False(result);
}
public void IsCheck_BlackTeam_BlackChecked_Bishop_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var blackPawnDeletePosition = new Position(1, 3);
var whiteBishopStartPosition = new Position(7, 5);
var whiteBishopEndPosition = new Position(4, 0);
board.RemoveFigure(blackPawnDeletePosition);
var bishop = board.RemoveFigure(whiteBishopStartPosition);
bishop.Move(whiteBishopEndPosition);
board.SetFigure(bishop, whiteBishopEndPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
TeamColor teamColor = TeamColor.Black;
// act
var result = verifier.IsCheck(teamColor);
// assert
Assert.False(result);
}
public void SetRemoveOperation_Test()
{
// arrange
var board = new OrdinaryChessBoard();
var startKnightPosition = new Models.Position.Position(0, 1);
var knightPosition1 = new Models.Position.Position(2, 1);
var knightPosition2 = new Models.Position.Position(3, 0);
// act
var check0 = board.FigureAt(knightPosition1);
var knight = board.RemoveFigure(startKnightPosition);
board.SetFigure(knight, knightPosition1);
var check1 = board.FigureAt(startKnightPosition);
var check2 = board.FigureAt(knightPosition1);
board.RemoveFigure(knightPosition1);
board.SetFigure(knight, knightPosition2);
var check3 = board.FigureAt(knightPosition1);
var check4 = board.FigureAt(knightPosition2);
// assert
Assert.AreEqual(null, check0);
Assert.AreEqual(null, check1);
Assert.AreEqual(FigureType.Knight, check2.FigureType);
Assert.AreEqual(null, check3);
Assert.AreEqual(FigureType.Knight, check4.FigureType);
}
public void IsLastMoveSmash_NotSmash_ShouldReturnFalse()
{
// 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);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm = new LastMoveViewModel(whitePawn, startWhitePawnPosition, oneHopWhitePawnPosition, null);
var moveResult = new ValidMoveResult(board, verifier, null, lastMoveVm, null);
// act
var result = moveResult.IsLastMoveSmash();
// assert
Assert.False(result);
}
public void CanMove_Queen_EnemyBlockPath_ShouldReturnFalse()
{
// 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);
var enemyPawnStartPosition = new Models.Position.Position(6, 6);
var enemyPawnEndPosition = new Models.Position.Position(3, 6);
board.RemoveFigure(pawnPosition);
var enemyPawn = board.RemoveFigure(enemyPawnStartPosition);
enemyPawn.Move(enemyPawnEndPosition);
board.SetFigure(enemyPawn, enemyPawnEndPosition);
var queen = board.FigureAt(startQueenPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(queen, destQueenPosition);
// assert
Assert.False(result.Item1);
}
static void ShowInstructions()
{
Console.WriteLine(_introText1);
var board = new OrdinaryChessBoard();
BoardDisplay.ShowBoard(new BoardViewModel(board));
ShowInColor(_introText2, ConsoleColor.Red);
ShowInColor(_introText3, ConsoleColor.Blue);
Console.Write(_introText4);
ShowInColor("1", ConsoleColor.Green);
Console.Write(_introText5);
ShowInColor("2", ConsoleColor.Green);
Console.Write(_introText6);
ShowInColor("3", ConsoleColor.Green);
Console.Write(_introText7);
ShowInColor("1", ConsoleColor.Green);
Console.WriteLine(_introText8);
var knight = board.RemoveFigure(board.GetPositionAt(0, 1));
board.SetFigure(knight, board.GetPositionAt(2, 0));
BoardDisplay.ShowBoard(new BoardViewModel(board));
Console.WriteLine(_introText9);
Console.WriteLine(_introText10);
}
public void Serialize_NextDeserialize_AlreadyWrittenFile()
{
// arrange
var board = new OrdinaryChessBoard();
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
LastMoveViewModel lastMoveVm = new LastMoveViewModel(new King(new Position(1, 2), TeamColor.Black),
new Position(1, 2), new Position(2, 3), null);
var moveResult = new ValidMoveResult(board, verifier, validator, lastMoveVm, null);
const bool isGameEnded = false;
TeamColor currentTeam = TeamColor.Black;
const string filePath = "Serialize_NextDeserialize_AlreadyWrittenFile.bin";
ChessGameState gameState =
new ChessGameState(moveResult, isGameEnded, null, currentTeam, PlayerMode.TwoPlayers, 0);
// act
ChessGameSerializer.SaveInFile(filePath, gameState);
ChessGameSerializer.SaveInFile(filePath, gameState);
ChessGameState fromFile = ChessGameSerializer.ReadFromFile <ChessGameState>(filePath);
// assert
Assert.AreEqual(fromFile.IsEnded, isGameEnded);
Assert.AreEqual(fromFile.CurrentMovingTeam, currentTeam);
Assert.AreEqual(fromFile.LastGameMoveResult.LastMoveFigureAndPositionFromAndDest().Item2,
moveResult.LastMoveFigureAndPositionFromAndDest().Item2);
// clear
Assert.True(ChessGameSerializer.ClearFile(filePath));
}
public void Serialize_NextDeserialize_NullObject()
{
// arrange
var board = new OrdinaryChessBoard();
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var moveResult = new ValidMoveResult(board, verifier, validator, null, null);
const bool isGameEnded = false;
TeamColor currentTeam = TeamColor.Black;
const string filePath = "Test_Serialize_NextDeserialize_NullObject.bin";
ChessGameState gameState =
new ChessGameState(moveResult, isGameEnded, null, currentTeam, PlayerMode.TwoPlayers, 0);
// act
ChessGameSerializer.SaveInFile(filePath, gameState);
ChessGameState fromFile = ChessGameSerializer.ReadFromFile <ChessGameState>(filePath);
// assert
Assert.AreEqual(fromFile.IsEnded, isGameEnded);
Assert.AreEqual(fromFile.CurrentMovingTeam, currentTeam);
// clear
Assert.True(ChessGameSerializer.ClearFile(filePath));
}
public void CanMove_Bishop_EnemyBlockPath_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var startBishopPosition = new Models.Position.Position(0, 2);
var destBishopPosition = new Models.Position.Position(5, 7);
var pawnPosition = new Models.Position.Position(1, 3);
var startEnemyPawnPosition = new Models.Position.Position(6, 6);
var destEnemyPawnPosition = new Models.Position.Position(4, 6);
board.RemoveFigure(pawnPosition);
var enemyPawn = board.RemoveFigure(startEnemyPawnPosition);
enemyPawn.Move(destEnemyPawnPosition);
board.SetFigure(enemyPawn, destEnemyPawnPosition);
var bishop = board.FigureAt(startBishopPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(bishop, destBishopPosition);
// assert
Assert.False(result.Item1);
}
public void IsCheck_BlackTeam_Check_Bishop_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var pawnDeletePosition = new Position(6, 3);
var bishopStartPosition = new Position(0, 5);
var bishopEndPosition = new Position(3, 0);
board.RemoveFigure(pawnDeletePosition);
var bishop = board.RemoveFigure(bishopStartPosition);
bishop.Move(bishopEndPosition);
board.SetFigure(bishop, bishopEndPosition);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
TeamColor teamColor = TeamColor.Black;
// act
var result = verifier.IsCheck(teamColor);
// assert
Assert.True(result);
}
public void DefaultConstructor_InitializationTest()
{
// arrange
// act
var board = new OrdinaryChessBoard();
var whiteRock = board.FigureAt(new Models.Position.Position(0, 0));
var blackKnight = board.FigureAt(new Models.Position.Position(7, 1));
var whiteBishop = board.FigureAt(new Models.Position.Position(0, 5));
var blackQueen = board.FigureAt(new Models.Position.Position(7, 3));
var whiteKing = board.FigureAt(new Models.Position.Position(0, 4));
var blackPawn = board.FigureAt(new Models.Position.Position(6, 2));
// assert
Assert.AreEqual(FigureType.Rook, whiteRock.FigureType);
Assert.AreEqual(TeamColor.White, whiteRock.TeamColor);
Assert.AreEqual(FigureType.Knight, blackKnight.FigureType);
Assert.AreEqual(TeamColor.Black, blackKnight.TeamColor);
Assert.AreEqual(FigureType.Bishop, whiteBishop.FigureType);
Assert.AreEqual(TeamColor.White, whiteBishop.TeamColor);
Assert.AreEqual(FigureType.Queen, blackQueen.FigureType);
Assert.AreEqual(TeamColor.Black, blackQueen.TeamColor);
Assert.AreEqual(FigureType.King, whiteKing.FigureType);
Assert.AreEqual(TeamColor.White, whiteKing.TeamColor);
Assert.AreEqual(FigureType.Pawn, blackPawn.FigureType);
Assert.AreEqual(TeamColor.Black, blackPawn.TeamColor);
}
public void IsCheckMate_OnlyCheck_CulpritMayBeKilled_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var blackPawnStartPosition = new Position(1, 7);
var blackPawnMiddlePosition = new Position(2, 7);
var blackPawnEndPosition = new Position(3, 7);
var whiteKnightStartPosition = new Position(7, 1);
var whiteKnightFirstHopPosition = new Position(5, 2);
var whiteKnightSecondHopPosition = new Position(3, 3);
var whiteKnightEndPosition = new Position(2, 5);
var blackPawn = board.RemoveFigure(blackPawnStartPosition);
blackPawn.Move(blackPawnMiddlePosition);
board.SetFigure(blackPawn, blackPawnMiddlePosition);
board.RemoveFigure(blackPawnMiddlePosition);
blackPawn.Move(blackPawnEndPosition);
board.SetFigure(blackPawn, blackPawnEndPosition);
var whiteKnight = board.RemoveFigure(whiteKnightStartPosition);
whiteKnight.Move(whiteKnightFirstHopPosition);
board.SetFigure(whiteKnight, whiteKnightFirstHopPosition);
board.RemoveFigure(whiteKnightFirstHopPosition);
whiteKnight.Move(whiteKnightSecondHopPosition);
board.SetFigure(whiteKnight, whiteKnightSecondHopPosition);
board.RemoveFigure(whiteKnightSecondHopPosition);
whiteKnight.Move(whiteKnightEndPosition);
board.SetFigure(whiteKnight, whiteKnightEndPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm =
new LastMoveViewModel(whiteKnight, whiteKnightSecondHopPosition, whiteKnightEndPosition, 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 IsCheckMate_CheckMateWhiteTeam()
{
// arrange
var board = new OrdinaryChessBoard();
var whitePawn1StartPosition = new Position(6, 5);
var whitePawn1EndPosition = new Position(5, 5);
var whitePawn2StartPosition = new Position(6, 6);
var whitePawn2EndPosition = new Position(4, 6);
var blackPawnStartPosition = new Position(1, 4);
var blackPawnEndPosition = new Position(3, 4);
var blackQueenStartPosition = new Position(0, 3);
var blackQueenEndPosition = new Position(4, 7);
var whitePawn1 = board.RemoveFigure(whitePawn1StartPosition);
whitePawn1.Move(whitePawn1EndPosition);
board.SetFigure(whitePawn1, whitePawn1EndPosition);
var blackPawn = board.RemoveFigure(blackPawnStartPosition);
blackPawn.Move(blackPawnEndPosition);
board.SetFigure(blackPawn, blackPawnEndPosition);
var whitePawn2 = board.RemoveFigure(whitePawn2StartPosition);
whitePawn2.Move(whitePawn2EndPosition);
board.SetFigure(whitePawn2, whitePawn2EndPosition);
var blackQueen = board.RemoveFigure(blackQueenStartPosition);
blackQueen.Move(blackQueenEndPosition);
board.SetFigure(blackQueen, blackQueenEndPosition);
var validator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, validator);
var lastMoveVm = new LastMoveViewModel(blackQueen, blackQueenStartPosition, blackPawnEndPosition, 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.False(result1);
Assert.True(result2);
Assert.False(result3);
Assert.True(result4);
}
public void GetScoreForTeam_InitialConfiguration_ShouldBe0()
{
// arrange
var board = new OrdinaryChessBoard();
TeamColor team = TeamColor.Black;
int expectedScore = 0;
// act
var result = board.GetScoreForTeam(team);
// assert
Assert.AreEqual(expectedScore, result);
}
public void StartGame_White_Depth2_Breadth5()
{
// arrange
var computer = new ComputerPlayer(TeamColor.White, 2, 5);
var board = new OrdinaryChessBoard();
var boardVm = new BoardViewModel(board);
// act
var move = computer.NextMove(boardVm);
// assert
Assert.NotNull(move);
Assert.AreEqual(0, move.Score);
}
public void CanMove_King_PositionAlreadyTakenByAlly_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var destPosition = new Models.Position.Position(1, 4);
var kingPosition = new Models.Position.Position(0, 4);
var king = board.FigureAt(kingPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(king, destPosition);
// assert
Assert.False(result.Item1);
}
public void CanMove_Rook_OutOfBoundaries_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var startRookPosition = new Models.Position.Position(0, 0);
var destRookPosition = new Models.Position.Position(-1, 0);
var queen = board.FigureAt(startRookPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(queen, destRookPosition);
// assert
Assert.False(result.Item1);
}
public void CanMove_Queen_PositionAlreadyTakenByAlly_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var startQueenPosition = new Models.Position.Position(0, 3);
var destQueenPosition = new Models.Position.Position(1, 4);
var queen = board.FigureAt(startQueenPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(queen, destQueenPosition);
// assert
Assert.False(result.Item1);
}
public void GetScoreForTeam_AfterDeleteWhite_BottomLeftPawn_BlackTeam_ShouldBe_21()
{
// arrange
var board = new OrdinaryChessBoard();
TeamColor team = TeamColor.Black;
int expectedScore = 21;
var pawnPosition = new Models.Position.Position(1, 0);
// act
board.RemoveFigure(pawnPosition);
var result = board.GetScoreForTeam(team);
// assert
Assert.AreEqual(expectedScore, result);
}
public void CanMove_Pawn_CanMove_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var startPawnPosition = new Models.Position.Position(1, 0);
var destPawnPosition = new Models.Position.Position(2, 0);
var pawn = board.FigureAt(startPawnPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(pawn, destPawnPosition);
// assert
Assert.True(result.Item1);
}
public void CanMove_Knight_OutOfBoundaries_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var startKnightPosition = new Models.Position.Position(0, 1);
var destKnightPosition = new Models.Position.Position(-1, 3);
var bishop = board.FigureAt(startKnightPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(bishop, destKnightPosition);
// assert
Assert.False(result.Item1);
}
public void CanMove_Knight_AllyBlockPath_CanMove_ShouldReturnTrue()
{
// arrange
var board = new OrdinaryChessBoard();
var startKnightPosition = new Models.Position.Position(0, 1);
var destKnightPosition = new Models.Position.Position(2, 2);
var bishop = board.FigureAt(startKnightPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(bishop, destKnightPosition);
// assert
Assert.True(result.Item1);
}
public void CanMove_Bishop_AllyBlockPath_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var startBishopPosition = new Models.Position.Position(0, 2);
var destBishopPosition = new Models.Position.Position(5, 7);
var bishop = board.FigureAt(startBishopPosition);
var validator = new OrdinaryBoardMoveValidator(board);
// act
var result = validator.CanMove(bishop, destBishopPosition);
// assert
Assert.False(result.Item1);
}
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 VerifyMoveCauseCheck_CannotMove_Rook_OtherFigureBlock_ShouldThrowException()
{
// arrange
var board = new OrdinaryChessBoard();
var rookStartPosition = new Position(0, 0);
var rookEndPosition = new Position(2, 0);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
// assert
Assert.Throws <InvalidMoveException>(() =>
verifier.VerifyMoveCauseCheck(rookStartPosition, rookEndPosition));
}
public void VerifyMoveCauseCheck_Knight_OtherFigureBlock_OK_ShouldReturnFalse()
{
// arrange
var board = new OrdinaryChessBoard();
var knightStartPosition = new Position(0, 1);
var knightEndPosition = new Position(2, 0);
var moveValidator = new OrdinaryBoardMoveValidator(board);
var verifier = new OrdinaryBoardCheckVerifier(board, moveValidator);
// act
var result = verifier.VerifyMoveCauseCheck(knightStartPosition, knightEndPosition);
// assert
Assert.False(result);
}
