306 lines
14 KiB
C
306 lines
14 KiB
C
/*----------------------------------------------------------
|
|
* HTBLA-Leonding
|
|
* ----------------------------------------------------------
|
|
* Description:
|
|
* Test functions for chess.
|
|
* ----------------------------------------------------------
|
|
*/
|
|
#include <stdbool.h>
|
|
#include "shortcut.h"
|
|
#include "test_chess.h"
|
|
#include "chess.h"
|
|
|
|
static ChessBoard chess_board;
|
|
|
|
static struct ChessPiece white_pawn = {White, Pawn};
|
|
static struct ChessPiece white_rook = {White, Rook};
|
|
static struct ChessPiece white_knight = {White, Knight};
|
|
static struct ChessPiece white_bishop = {White, Bishop};
|
|
static struct ChessPiece white_queen = {White, Queen};
|
|
static struct ChessPiece white_king = {White, King};
|
|
|
|
static struct ChessPiece black_pawn = {Black, Pawn};
|
|
static struct ChessPiece black_rook = {Black, Rook};
|
|
static struct ChessPiece black_knight = {Black, Knight};
|
|
static struct ChessPiece black_bishop = {Black, Bishop};
|
|
static struct ChessPiece black_queen = {Black, Queen};
|
|
static struct ChessPiece black_king = {Black, King};
|
|
|
|
TEST(test_is_piece)
|
|
{
|
|
ASSERT_TRUE(is_piece(white_pawn, White, Pawn), "Piece is white pawn");
|
|
ASSERT_TRUE(is_piece(white_rook, White, Rook), "Piece is white rook");
|
|
ASSERT_TRUE(is_piece(white_knight, White, Knight), "Piece is white knight");
|
|
ASSERT_TRUE(is_piece(white_bishop, White, Bishop), "Piece is white bishop");
|
|
ASSERT_TRUE(is_piece(white_queen, White, Queen), "Piece is white queen");
|
|
ASSERT_TRUE(is_piece(white_king, White, King), "Piece is white king");
|
|
|
|
ASSERT_TRUE(is_piece(black_pawn, Black, Pawn), "Piece is black pawn");
|
|
ASSERT_TRUE(is_piece(black_rook, Black, Rook), "Piece is black rook");
|
|
ASSERT_TRUE(is_piece(black_knight, Black, Knight), "Piece is black knight");
|
|
ASSERT_TRUE(is_piece(black_bishop, Black, Bishop), "Piece is black bishop");
|
|
ASSERT_TRUE(is_piece(black_queen, Black, Queen), "Piece is black queen");
|
|
ASSERT_TRUE(is_piece(black_king, Black, King), "Piece is black king");
|
|
|
|
ASSERT_FALSE(is_piece(black_king, White, King), "Piece is not white king");
|
|
}
|
|
|
|
static void check_board_for_being_empty(struct TestCase* tc);
|
|
TEST(test_init_chess_board)
|
|
{
|
|
init_chess_board(chess_board);
|
|
check_board_for_being_empty(tc);
|
|
|
|
chess_board[5][6].is_occupied = true;
|
|
struct ChessPiece p = {White, Queen};
|
|
chess_board[5][6].piece = p;
|
|
|
|
init_chess_board(chess_board);
|
|
check_board_for_being_empty(tc);
|
|
}
|
|
|
|
static void check_board_for_being_empty(struct TestCase* tc)
|
|
{
|
|
for (int i = 0; i < 8; i++) {
|
|
for (int j = 0; j < 8; j++) {
|
|
ASSERT_FALSE(chess_board[i][j].is_occupied, "Chessboard not empty");
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(test_get_square)
|
|
{
|
|
struct ChessSquare* square;
|
|
int rank;
|
|
int file;
|
|
|
|
init_chess_board(chess_board);
|
|
|
|
chess_board[4][2].is_occupied = true;
|
|
chess_board[4][2].piece = black_rook;
|
|
|
|
for (rank = 1; rank <= 8; rank++) {
|
|
for (file = 'a'; file <= 'h'; file++) {
|
|
square = get_square(chess_board, file, rank);
|
|
ASSERT_TRUE(square != 0, "Square must not be 0");
|
|
if (square) {
|
|
if (file == 'c' && rank == 5) {
|
|
ASSERT_TRUE(square->is_occupied, "Position c5 must be occupied");
|
|
ASSERT_TRUE(is_piece(square->piece, Black, Rook), "Piece at c5 must be black rook");
|
|
}
|
|
else {
|
|
ASSERT_FALSE(square->is_occupied, "Square must NOT be occupied");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
square = get_square(chess_board, 'i', 8);
|
|
ASSERT_TRUE(square == 0, "Position out of range, 0 expected");
|
|
}
|
|
|
|
TEST(test_is_square_occupied)
|
|
{
|
|
int rank;
|
|
int file;
|
|
|
|
init_chess_board(chess_board);
|
|
|
|
for (rank = 1; rank <= 8; rank++) {
|
|
for (file = 'a'; file <= 'h'; file++) {
|
|
ASSERT_FALSE(is_square_occupied(chess_board, file, rank), "Chessboard not empty");
|
|
}
|
|
}
|
|
|
|
chess_board[4][2].is_occupied = true;
|
|
chess_board[4][2].piece = black_rook;
|
|
|
|
ASSERT_TRUE(is_square_occupied(chess_board, 'c', 5), "Square must be occupied");
|
|
}
|
|
|
|
TEST(test_add_piece)
|
|
{
|
|
bool add_ok;
|
|
|
|
init_chess_board(chess_board);
|
|
add_ok = add_piece(chess_board, 'a', 1, black_rook);
|
|
|
|
ASSERT_TRUE(add_ok, "Adding black rook returned False though adding should be possible");
|
|
ASSERT_TRUE(is_square_occupied(chess_board, 'a', 1), "Black rook is not placed properly");
|
|
if (is_square_occupied(chess_board, 'a', 1)) {
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'a', 1), Black, Rook), "Piece at a1 must be black rook");
|
|
}
|
|
|
|
add_ok = add_piece(chess_board, 'h', 8, white_rook);
|
|
ASSERT_TRUE(add_ok, "Adding white rook returned False though adding is possible");
|
|
ASSERT_TRUE(is_square_occupied(chess_board, 'h', 8), "White rook is not placed properly");
|
|
if (is_square_occupied(chess_board, 'h', 8)) {
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'h', 8), White, Rook), "Piece at h8 must be white rook");
|
|
}
|
|
|
|
add_ok = add_piece(chess_board, 'i', 8, white_rook);
|
|
ASSERT_FALSE(add_ok, "Adding white_rook returned True though adding is impossible");
|
|
|
|
add_ok = add_piece(chess_board, 'h', 9, white_rook);
|
|
ASSERT_FALSE(add_ok, "Adding white_rook returned True though adding is impossible");
|
|
}
|
|
|
|
TEST(test_get_piece)
|
|
{
|
|
init_chess_board(chess_board);
|
|
add_piece(chess_board, 'c', 4, black_pawn);
|
|
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'c', 4), Black, Pawn), "Piece at c4 must be black pawn");
|
|
|
|
ASSERT_EQUALS(NoPiece, get_piece(chess_board, 'c', 5).type);
|
|
|
|
ASSERT_EQUALS(NoPiece, get_piece(chess_board, 'i', 8).type);
|
|
ASSERT_EQUALS(NoPiece, get_piece(chess_board, 'h', 9).type);
|
|
ASSERT_EQUALS(NoPiece, get_piece(chess_board, 'i', 9).type);
|
|
}
|
|
|
|
TEST(test_setup_chess_board)
|
|
{
|
|
File file;
|
|
Rank rank;
|
|
|
|
init_chess_board(chess_board);
|
|
add_piece(chess_board, 'd', 4, white_pawn);
|
|
|
|
setup_chess_board(chess_board);
|
|
|
|
for (file = 'a'; file <= 'h'; file++) {
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, file, 2), White, Pawn), "Rank 2 must be white");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, file, 7), Black, Pawn), "Rank 7 must be black");
|
|
}
|
|
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'a', 1), White, Rook), "a1 must be white rook");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'h', 1), White, Rook), "h1 must be white rook");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'b', 1), White, Knight), "b1 must be white knight");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'g', 1), White, Knight), "g1 must be white knight");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'c', 1), White, Bishop), "c1 must be white bishop");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'f', 1), White, Bishop), "f1 must be white bishop");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'd', 1), White, Queen), "d1 must be white queen");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'e', 1), White, King), "e1 must be white king");
|
|
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'a', 8), Black, Rook), "a7 must be black rook");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'h', 8), Black, Rook), "h7 must be black rook");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'b', 8), Black, Knight), "b7 must be black knight");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'g', 8), Black, Knight), "g7 must be black knight");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'c', 8), Black, Bishop), "c7 must be black bishop");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'f', 8), Black, Bishop), "f7 must be black bishop");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'd', 8), Black, Queen), "d7 must be black queen");
|
|
ASSERT_TRUE(is_piece(get_piece(chess_board, 'e', 8), Black, King), "e7 must be black king");
|
|
|
|
for (file = 'a'; file <= 'h'; file++) {
|
|
for (rank = 3; rank <= 6; rank++) {
|
|
ASSERT_FALSE(is_square_occupied(chess_board, file, rank), "Ranks 3 to 6 must not be occupied");
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(test_remove_piece)
|
|
{
|
|
bool remove_ok;
|
|
|
|
init_chess_board(chess_board);
|
|
add_piece(chess_board, 'a', 1, black_rook);
|
|
ASSERT_TRUE(is_square_occupied(chess_board, 'a', 1), "black rook not placed properly");
|
|
|
|
remove_ok = remove_piece(chess_board, 'a', 1);
|
|
ASSERT_TRUE(remove_ok, "returned false though removing is possible");
|
|
ASSERT_FALSE(is_square_occupied(chess_board, 'a', 1), "piece at a1 was not removed");
|
|
|
|
remove_ok = remove_piece(chess_board, 'c', 2);
|
|
ASSERT_FALSE(remove_ok, "returned true though removing is impossible");
|
|
}
|
|
|
|
TEST(test_squares_share_file)
|
|
{
|
|
ASSERT_TRUE(squares_share_file('a', 1, 'a', 8), "Squares share file in a");
|
|
ASSERT_TRUE(squares_share_file('h', 1, 'h', 8), "Squares share file in h");
|
|
ASSERT_TRUE(squares_share_file('c', 3, 'c', 7), "Squares share file in c");
|
|
|
|
ASSERT_FALSE(squares_share_file('a', 1, 'h', 1), "Squares DON'T share file in 1");
|
|
ASSERT_FALSE(squares_share_file('a', 0, 'a', 7), "Squares DON'T share file because of invalid position");
|
|
}
|
|
|
|
TEST(test_squares_share_rank)
|
|
{
|
|
ASSERT_TRUE(squares_share_rank('a', 1, 'h', 1), "Squares share rank in 1");
|
|
ASSERT_TRUE(squares_share_rank('a', 8, 'h', 8), "Squares share rank in 8");
|
|
ASSERT_TRUE(squares_share_rank('c', 3, 'f', 3), "Squares share rank in 3");
|
|
|
|
ASSERT_FALSE(squares_share_rank('a', 1, 'a', 8), "Squares DON'T share rank in a");
|
|
ASSERT_FALSE(squares_share_rank('a', 1, 'i', 1), "Squares DON'T share rank because of invalid position");
|
|
}
|
|
|
|
TEST(test_squares_share_diagonal)
|
|
{
|
|
ASSERT_TRUE(squares_share_diagonal('a', 1, 'h', 8), "Squares share diagonal right up");
|
|
ASSERT_TRUE(squares_share_diagonal('h', 1, 'a', 8), "Squares share diagonal left up");
|
|
ASSERT_TRUE(squares_share_diagonal('a', 7, 'b', 8), "Squares share diagonal from a7 to b8");
|
|
ASSERT_TRUE(squares_share_diagonal('f', 8, 'h', 6), "Squares share diagonal right down");
|
|
ASSERT_TRUE(squares_share_diagonal('e', 5, 'b', 2), "Squares share diagonal left down");
|
|
|
|
ASSERT_FALSE(squares_share_diagonal('c', 0, 'f', 3), "Squares DON'T share diagonal because of invalid position");
|
|
}
|
|
|
|
TEST(test_squares_share_knights_move)
|
|
{
|
|
ASSERT_TRUE(squares_share_knights_move('e', 3, 'd', 5), "Squares share knights move 11 o'clock");
|
|
ASSERT_TRUE(squares_share_knights_move('e', 3, 'f', 5), "Squares share knights move 1 o'clock");
|
|
ASSERT_TRUE(squares_share_knights_move('e', 3, 'c', 4), "Squares share knights move 10 o'clock");
|
|
ASSERT_TRUE(squares_share_knights_move('e', 3, 'g', 4), "Squares share knights move 2 o'clock");
|
|
ASSERT_TRUE(squares_share_knights_move('e', 3, 'c', 2), "Squares share knights move 8 o'clock");
|
|
ASSERT_TRUE(squares_share_knights_move('e', 3, 'g', 2), "Squares share knights move 4 o'clock");
|
|
ASSERT_TRUE(squares_share_knights_move('e', 3, 'd', 1), "Squares share knights move 7 o'clock");
|
|
ASSERT_TRUE(squares_share_knights_move('e', 3, 'f', 1), "Squares share knights move 5 o'clock");
|
|
}
|
|
|
|
TEST(test_squares_share_pawns_move)
|
|
{
|
|
ASSERT_TRUE(squares_share_pawns_move(White, NormalMove, 'a', 2, 'a', 4), "Squares share opening move for white pawn");
|
|
ASSERT_TRUE(squares_share_pawns_move(Black, NormalMove, 'f', 7, 'f', 5), "Squares share opening move for black pawn");
|
|
ASSERT_TRUE(squares_share_pawns_move(White, NormalMove, 'd', 2, 'd', 3), "Squares share normal move for white pawn from base line");
|
|
ASSERT_TRUE(squares_share_pawns_move(Black, NormalMove, 'f', 7, 'f', 6), "Squares share normal move for black pawn from base line");
|
|
ASSERT_TRUE(squares_share_pawns_move(White, NormalMove, 'e', 3, 'e', 4), "Squares share normal move for white pawn from arbitrary position");
|
|
ASSERT_TRUE(squares_share_pawns_move(Black, NormalMove, 'c', 5, 'c', 4), "Squares share normal move for black pawn from arbitrary position");
|
|
ASSERT_TRUE(squares_share_pawns_move(White, CaptureMove, 'b', 2, 'a', 3), "Squares share capture move for white pawn");
|
|
ASSERT_TRUE(squares_share_pawns_move(White, CaptureMove, 'b', 2, 'c', 3), "Squares share capture move for white pawn");
|
|
ASSERT_TRUE(squares_share_pawns_move(Black, CaptureMove, 'c', 6, 'b', 5), "Squares share capture move for black pawn");
|
|
ASSERT_TRUE(squares_share_pawns_move(Black, CaptureMove, 'c', 6, 'd', 5), "Squares share capture move for black pawn");
|
|
|
|
ASSERT_FALSE(squares_share_pawns_move(White, NormalMove, 'f', 7, 'f', 5), "Squares DON'T share backward move for white pawn");
|
|
ASSERT_FALSE(squares_share_pawns_move(Black, NormalMove, 'a', 2, 'a', 4), "Squares DON'T share backward move for black pawn");
|
|
ASSERT_FALSE(squares_share_pawns_move(White, NormalMove, 'e', 3, 'e', 5), "Squares DON'T share opening move for white pawn from arbitrary position");
|
|
ASSERT_FALSE(squares_share_pawns_move(Black, NormalMove, 'g', 5, 'g', 3), "Squares DON'T share opening move for black pawn from arbitrary position");
|
|
ASSERT_FALSE(squares_share_pawns_move(White, NormalMove, 'd', 1, 'd', 2), "Squares DON'T share white pawn to start from rank 1");
|
|
ASSERT_FALSE(squares_share_pawns_move(Black, NormalMove, 'd', 8, 'd', 7), "Squares DON'T share black pawn to start from rank 7");
|
|
ASSERT_FALSE(squares_share_pawns_move(White, CaptureMove, 'c', 4, 'd', 3), "Squares DON'T share backward capture move for white pawn");
|
|
ASSERT_FALSE(squares_share_pawns_move(Black, CaptureMove, 'e', 4, 'd', 5), "Squares DON'T share backward capture move for black pawn");
|
|
}
|
|
|
|
TEST(test_squares_share_queens_move)
|
|
{
|
|
ASSERT_TRUE(squares_share_queens_move('d', 1, 'd', 6), "Square share queens move up");
|
|
ASSERT_TRUE(squares_share_queens_move('d', 6, 'g', 3), "Square share queens move right down");
|
|
ASSERT_TRUE(squares_share_queens_move('g', 3, 'e', 1), "Square share queens move left down");
|
|
ASSERT_TRUE(squares_share_queens_move('e', 1, 'h', 1), "Square share queens move right");
|
|
ASSERT_TRUE(squares_share_queens_move('h', 1, 'a', 8), "Square share queens move left up");
|
|
ASSERT_TRUE(squares_share_queens_move('a', 8, 'a', 3), "Square share queens move down");
|
|
ASSERT_TRUE(squares_share_queens_move('h', 1, 'e', 4), "Square share queens move left up");
|
|
ASSERT_TRUE(squares_share_queens_move('e', 4, 'b', 4), "Square share queens move left");
|
|
}
|
|
|
|
TEST(test_squares_share_kings_move)
|
|
{
|
|
ASSERT_TRUE(squares_share_kings_move('e', 1, 'e', 2), "Squares share kings move up");
|
|
ASSERT_TRUE(squares_share_kings_move('e', 8, 'e', 7), "Squares share kings move down");
|
|
ASSERT_TRUE(squares_share_kings_move('e', 1, 'f', 1), "Squares share kings move right");
|
|
ASSERT_TRUE(squares_share_kings_move('e', 8, 'd', 8), "Squares share kings move left");
|
|
ASSERT_TRUE(squares_share_kings_move('g', 5, 'h', 4), "Squares share kings move right down");
|
|
ASSERT_TRUE(squares_share_kings_move('g', 5, 'h', 6), "Squares share kings move right up");
|
|
ASSERT_TRUE(squares_share_kings_move('g', 5, 'f', 4), "Squares share kings move left down");
|
|
ASSERT_TRUE(squares_share_kings_move('g', 5, 'f', 6), "Squares share kings move left up");
|
|
}
|