public void Deserialize_ShouldSetBoardState_WhenValidStringGiven()
{
const string FenString = "pQ4N1/3k3R/1r4n1/KbBbBppP/8/8/q7/7n";
FenSerializer ser = new FenSerializer();
BoardState actual;
BoardState expected = BoardState.Empty
.SetPiece(MoveParser.ParseSquare("a8"), SquareContents.Black | SquareContents.Pawn)
.SetPiece(MoveParser.ParseSquare("b8"), SquareContents.White | SquareContents.Queen)
.SetPiece(MoveParser.ParseSquare("g8"), SquareContents.White | SquareContents.Knight)
.SetPiece(MoveParser.ParseSquare("d7"), SquareContents.Black | SquareContents.King)
.SetPiece(MoveParser.ParseSquare("h7"), SquareContents.White | SquareContents.Rook)
.SetPiece(MoveParser.ParseSquare("b6"), SquareContents.Black | SquareContents.King)
.SetPiece(MoveParser.ParseSquare("g6"), SquareContents.Black | SquareContents.Knight)
.SetPiece(MoveParser.ParseSquare("a5"), SquareContents.White | SquareContents.King)
.SetPiece(MoveParser.ParseSquare("b5"), SquareContents.Black | SquareContents.Bishop)
.SetPiece(MoveParser.ParseSquare("c5"), SquareContents.White | SquareContents.Bishop)
.SetPiece(MoveParser.ParseSquare("d5"), SquareContents.Black | SquareContents.Bishop)
.SetPiece(MoveParser.ParseSquare("e5"), SquareContents.White | SquareContents.Bishop)
.SetPiece(MoveParser.ParseSquare("f5"), SquareContents.Black | SquareContents.Pawn)
.SetPiece(MoveParser.ParseSquare("g5"), SquareContents.Black | SquareContents.Pawn)
.SetPiece(MoveParser.ParseSquare("h5"), SquareContents.White | SquareContents.Pawn)
.SetPiece(MoveParser.ParseSquare("a2"), SquareContents.Black | SquareContents.Queen)
.SetPiece(MoveParser.ParseSquare("h1"), SquareContents.Black | SquareContents.Knight);
// Act
actual = ser.Deserialize(FenString);
Assert.That(expected.AllPieces, Is.EqualTo(actual.AllPieces));
Assert.That(expected.WhitePieces, Is.EqualTo(actual.WhitePieces));
Assert.That(expected.BlackPieces, Is.EqualTo(actual.BlackPieces));
}
public void Deserialize_ShouldThrowException_WhenTooLong()
{
var fenString = new string('0', 80);
var serializer = new FenSerializer();
Assert.That(() => serializer.Deserialize(fenString), Throws.ArgumentException);
}
public void King_UnableMoveIntoPawnMovementPath(string fen, string move)
{
var serializer = new FenSerializer();
var board = serializer.Deserialize(fen);
var game = new Game(board, PieceColor.Black);
var result = game.Move(move);
Assert.That(result, Is.EqualTo(ErrorCondition.InvalidMovement));
}
public void Serialize_ShouldSerializeCorrectPosition()
{
var defaultFen = FenSerializer.DefaultValue;
var board = BoardState.DefaultPositions;
var serializer = new FenSerializer();
var actualValue = serializer.Serialize(board);
Assert.AreEqual(defaultFen, actualValue);
}
public AttackState Move_DetectsAttackState_ForPromotion(string position, string move)
{
var fen = new FenSerializer();
var board = fen.Deserialize(position);
var game = new Game(board, PieceColor.White);
var error = game.Move(move);
Assert.That(error, Is.EqualTo(ErrorCondition.None));
return(game.AttackState);
}
public void PawnPromotion_WillDetectCheckmate()
{
const string fen = "rnb1kbnr/pppp1ppp/8/8/4q3/1P5P/P1PP1Kp1/RNBQ1BNR";
const string move = "gxh1=N#";
var fenBoard = new FenSerializer().Deserialize(fen);
var game = new Game(fenBoard, PieceColor.Black);
var result = game.Move(move);
Assert.That(result, Is.EqualTo(ErrorCondition.None));
Assert.That(game.AttackState, Is.EqualTo(AttackState.Checkmate));
}
public void GetValidMoves_DetectsWhenOnEdge(string position, string targetSq, string expectedSq)
{
var fen = new FenSerializer();
var board = fen.Deserialize(position);
var target = MoveParser.ParseSquare(targetSq);
var targetMask = BitTranslator.TranslateToBit(target.File, target.Rank);
var validMovesMask = MoveGenerator.GetBishopMovements(targetMask, board);
var validMoves = BitTranslator.TranslateToSquares(validMovesMask);
var expected = MoveParser.ParseSquare(expectedSq);
Assert.That(validMoves, Does.Contain(expected));
}
public void PawnPromotion_WillClearPawnFromFinalSquare()
{
const string fen = "rnb1kbnr/pppp1ppp/8/8/4q3/1P5P/P1PP1Kp1/RNBQ1BNR";
const string move = "gxh1=N#";
var fenBoard = new FenSerializer().Deserialize(fen);
var game = new Game(fenBoard, PieceColor.Black);
var result = game.Move(move);
var board = game.CurrentState.Board;
var targetSquare = BitTranslator.TranslateToBit('h', 1);
Assert.That(board.Pawns & targetSquare, Is.EqualTo(0));
Assert.That(board.Knights & targetSquare, Is.EqualTo(targetSquare));
Assert.That(board.WhitePieces & targetSquare, Is.EqualTo(0));
Assert.That(board.BlackPieces & targetSquare, Is.EqualTo(targetSquare));
}
public async Task ReplayedGameMatchesExpectedFEN(string scenario)
{
var pgnSerializer = new PGNSerializer();
using var stream = ResourceHelpers.GetEmbeddedPGNStream(scenario);
var pgn = await pgnSerializer.DeserializeAsync(new StreamReader(stream));
var expectedFen = Scenarios.FinalPositions[scenario];
var game = new Game();
foreach (var move in pgn.Moves)
{
var result = game.Move(move);
Warn.If(result, Is.Not.EqualTo(ErrorCondition.None), $"Unexpected result for move {move}");
}
var fenSerializer = new FenSerializer();
var actualFen = fenSerializer.Serialize(game.CurrentState.Board);
Assert.That(actualFen, Is.EqualTo(expectedFen));
}
public void Deserialize_ShouldThrowException_WhenInvalid(string fenString, string expectedMessage)
{
var serializer = new FenSerializer();
Assert.That(() => serializer.Deserialize(fenString), Throws.InvalidOperationException.With.Message.EqualTo(expectedMessage));
}
public void Deserialize_ShouldThrowException_WhenEmpty()
{
var serializer = new FenSerializer();
Assert.That(() => serializer.Deserialize(string.Empty), Throws.ArgumentNullException);
}
