public void TestStalemate()
{
// Prepare a classical standard game
IGame game = new Standard <Classical>();
// Load stalemate game data
Assert.All(StalemateGameData, data =>
{
// Separate data
var move = data.Item1;
var outcome = data.Item2;
var score = data.Item3;
// Process move
Assert.True(game.ProcessMove(move));
// Make assertions
Assert.Equal(outcome, game.Outcome);
Assert.Equal(score, game.Score);
});
// Post-game assertions
Assert.Empty(game.AvailableMoves());
Assert.Equal(Outcome.Stalemate, game.Outcome);
Assert.Equal(10, (int)game.MoveCount);
Assert.Equal(10, game.Moves.Count);
Assert.Single(game.Moves.Last());
}
public void TestProcessMove()
{
IGame game = new Standard <Classical>();
// Get a list of several different moves
var validMove = game.AvailableMoves()
.Where(m => m.ToSquare.IsSameSquareAs(
new Square(Files.e, Ranks.four)))
.Single();
var outOfOrderMove = game.AvailableMoves()
.Where(m => m.ToSquare.IsSameSquareAs(
new Square(Files.b, Ranks.four)))
.Single();
var errorMove = validMove;
var invalidMove = new Move(
new Square(Files.a, Ranks.seven),
new Square(Files.a, Ranks.three),
MoveType.Normal);
// Process a valid move
Assert.True(game.ProcessMove(validMove));
// Process an white move on black turn
Assert.False(game.ProcessMove(outOfOrderMove));
// Process a move from an unoccupied square
Assert.Throws <KeyNotFoundException>(() => game.ProcessMove(errorMove));
// Process an invalid move
Assert.False(game.ProcessMove(invalidMove));
// It is black's first turn - make some assertions
AssertGame(game, 0, 20, 1, false, Outcome.Game);
Assert.Single(game.MoveEntries);
Assert.Equal(validMove, game.MoveEntries.Last().Move);
}
public void TestGame()
{
// Set a new standard game of classical chess.
IGame game = new Standard <Classical>();
// Load game data
var gameData = TestClassical.GameOfChessData;
// Initialize assertion metrics
int loop = 0;
int score = 0;
bool player = true;
int moves = 0;
Outcome outcome = Outcome.Game;
int counter = 0;
// Play the game
Assert.All(gameData, tuple => {
// Assert conditions
AssertGame(game, score, game.AvailableMoves().Count, moves, player, outcome);
// Get move data
var move = tuple.Item1;
var numberOfPieces = tuple.Item4;
var captured = tuple.Item3;
// Process move
Assert.True(game.ProcessMove(move));
// Post-move assertions
Assert.Equal(32, game.Position.Count + game.CapturedPieces.Count);
Assert.Equal(numberOfPieces, game.Position.Count);
// Update assertion metrics
switch (captured)
{
case Pawn p:
score += (captured.Color ? -1 : +1) * 1;
break;
case Knight n:
case Bishop b:
score += (captured.Color ? -1 : +1) * 3;
break;
case Rook r:
score += (captured.Color ? -1 : +1) * 5;
break;
case Queen q:
score += (captured.Color ? -1 : +1) * 9;
break;
default:
break;
}
player = !player;
if (!player)
{
moves++;
}
if (game.AvailableMoves().Count == 0)
{
outcome = Outcome.Checkmate;
}
else
{
outcome = Outcome.Game;
}
loop++;
if (loop == 5 || loop == 19 || loop == 25)
{
outcome = Outcome.Checked;
}
});
// Post-game assertions
AssertGame(game, -17, 0, 17, true, outcome);
Assert.Equal(Outcome.Checkmate, outcome);
// Assert game.Moves
Assert.Equal((int)moves, game.Moves.Count);
Assert.All(game.Moves, moves =>
{
// Every player played each move
Assert.Equal(2, moves.Count);
Assert.All(moves, move =>
{
// Assert every move
var moveEntry = game.MoveEntries.ElementAt(counter);
Assert.Equal(moveEntry.Move, move);
Assert.Equal(player, moveEntry.Position[move.FromSquare].Color);
// Update assertion metrics
counter++;
player = !player;
});
});
}