test/test-fen.c

/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2026 Mike Becker. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "chess/fen.h"
#include "ucxtest.h"

static CX_TEST(test_fen_basic) {
    /* a test that simply checks if an arbitrary FEN is parsed correctly */
    const char * fen = "r1n3k1/5qbp/p5p1/1p6/4Q3/B6P/P4PP1/R4RK1 b - - 0 27";
    Board expected_board = {
        {WROOK,   0,       0,       0,      0,      WROOK,   WKING,   0},
        {WPAWN,   0,       0,       0,      0,      WPAWN,   WPAWN,   0},
        {WBISHOP, 0,       0,       0,      0,      0,       0,       WPAWN},
        {0,       0,       0,       0,      WQUEEN, 0,       0,       0},
        {0,       BPAWN,   0,       0,      0,      0,       0,       0},
        {BPAWN,   0,       0,       0,      0,      0,       BPAWN,   0},
        {0,       0,       0,       0,      0,      BQUEEN,  BBISHOP, BPAWN},
        {BROOK,   0,       BKNIGHT, 0,      0,      0,       BKING,   0}
    };
    GameState gs;
    int result = fen_parse(fen, &gs);
    CX_TEST_DO {
        CX_TEST_ASSERT(result == 0);
        CX_TEST_ASSERT(strcmp(gs.fen_start, fen) == 0);
        /* counter for fifty-move rule initialized with zero */
        CX_TEST_ASSERT(gs.fifty_cntr_start == 0);
        /* we start after 53 half-moves have been played */
        CX_TEST_ASSERT(gs.move_start == 53);
        /* it's black's turn */
        CX_TEST_ASSERT(current_color(&gs) == BLACK);
        /* we have no move history */
        CX_TEST_ASSERT(gs.movecount == 0);
        CX_TEST_ASSERT(gs.movecapacity == 0);
        CX_TEST_ASSERT(gs.moves == NULL);
        CX_TEST_ASSERT(gs.fen == NULL);
        /* all castling rights should be revoked */
        CX_TEST_ASSERT(gs.castling.K == true);
        CX_TEST_ASSERT(gs.castling.Q == true);
        CX_TEST_ASSERT(gs.castling.k == true);
        CX_TEST_ASSERT(gs.castling.q == true);
        /* check the board */
        for (File f = 0 ; f < 8 ; f++) {
            for (Rank r = 0 ; r < 8 ; r++) {
                Piece exp = expected_board[r][f];
                Piece p = piece_at(&gs, f, r);
                char msg[64];
                sprintf(msg, "expected %u at %c:%c but got %u",
                    exp, filechr(f), rankchr(r), p);
                CX_TEST_ASSERTM(exp == p, msg);
            }
        }
        /* check that other stuff is empty-initialized */
        CX_TEST_ASSERT(gs.bname[0] == 0);
        CX_TEST_ASSERT(gs.wname[0] == 0);
        CX_TEST_ASSERT(gs.premove[0] == 0);
        CX_TEST_ASSERT(!gs.checkmate);
        CX_TEST_ASSERT(!gs.stalemate);
        CX_TEST_ASSERT(!gs.threefold);
        CX_TEST_ASSERT(!gs.nomaterial);
        CX_TEST_ASSERT(!gs.remis);
        CX_TEST_ASSERT(!gs.wresign);
        CX_TEST_ASSERT(!gs.bresign);
        CX_TEST_ASSERT(!gs.ragequit);
        CX_TEST_ASSERT(!gs.review);
        /* check that we get the original FEN back */
        char fen_chk[FEN_MAX_LENGTH];
        fen_compute(fen_chk, &gs);
        CX_TEST_ASSERTM(strcmp(fen, fen_chk) == 0, fen_chk);
    }
    gamestate_cleanup(&gs);
}

static CX_TEST(test_fen_with_castling_rights) {
    /* this test contains castling rights and a non-zero fifty-moves counter */
    const char * fen = "1rbqk1nr/ppp2ppp/2np4/2b1p3/2P5/2N1P1P1/PP1P1PBP/R1BQK1NR w KQk - 1 6";
    Board expected_board = {
        {WROOK, 0,       WBISHOP, WQUEEN, WKING, 0,       WKNIGHT, WROOK},
        {WPAWN, WPAWN,   0,       WPAWN,  0,     WPAWN,   WBISHOP, WPAWN},
        {0,     0,       WKNIGHT, 0,      WPAWN, 0,       WPAWN,   0},
        {0,     0,       WPAWN,   0,      0,     0,       0,       0},
        {0,     0,       BBISHOP, 0,      BPAWN, 0,       0,       0},
        {0,     0,       BKNIGHT, BPAWN,  0,     0,       0,       0},
        {BPAWN, BPAWN,   BPAWN,   0,      0,     BPAWN,   BPAWN,   BPAWN},
        {0,     BROOK,   BBISHOP, BQUEEN, BKING, 0,       BKNIGHT, BROOK}
    };
    GameState gs;
    int result = fen_parse(fen, &gs);
    CX_TEST_DO {
        CX_TEST_ASSERT(result == 0);
        CX_TEST_ASSERT(strcmp(gs.fen_start, fen) == 0);
        /* counter for fifty-move rule */
        CX_TEST_ASSERT(gs.fifty_cntr_start == 1);
        /* we start after 10 half-moves have been played */
        CX_TEST_ASSERT(gs.move_start == 10);
        /* it's white's turn */
        CX_TEST_ASSERT(current_color(&gs) == WHITE);
        /* we have no move history */
        CX_TEST_ASSERT(gs.movecount == 0);
        CX_TEST_ASSERT(gs.movecapacity == 0);
        CX_TEST_ASSERT(gs.moves == NULL);
        CX_TEST_ASSERT(gs.fen == NULL);
        /* black queen-side castling right revoked */
        CX_TEST_ASSERT(gs.castling.K == false);
        CX_TEST_ASSERT(gs.castling.Q == false);
        CX_TEST_ASSERT(gs.castling.k == false);
        CX_TEST_ASSERT(gs.castling.q == true);
        /* check the board */
        for (File f = 0 ; f < 8 ; f++) {
            for (Rank r = 0 ; r < 8 ; r++) {
                Piece exp = expected_board[r][f];
                Piece p = piece_at(&gs, f, r);
                char msg[64];
                sprintf(msg, "expected %u at %c:%c but got %u",
                    exp, filechr(f), rankchr(r), p);
                CX_TEST_ASSERTM(exp == p, msg);
            }
        }
        /* check that other stuff is empty-initialized */
        CX_TEST_ASSERT(gs.bname[0] == 0);
        CX_TEST_ASSERT(gs.wname[0] == 0);
        CX_TEST_ASSERT(gs.premove[0] == 0);
        CX_TEST_ASSERT(!gs.checkmate);
        CX_TEST_ASSERT(!gs.stalemate);
        CX_TEST_ASSERT(!gs.threefold);
        CX_TEST_ASSERT(!gs.nomaterial);
        CX_TEST_ASSERT(!gs.remis);
        CX_TEST_ASSERT(!gs.wresign);
        CX_TEST_ASSERT(!gs.bresign);
        CX_TEST_ASSERT(!gs.ragequit);
        CX_TEST_ASSERT(!gs.review);
        /* check that we get the original FEN back */
        char fen_chk[FEN_MAX_LENGTH];
        fen_compute(fen_chk, &gs);
        CX_TEST_ASSERTM(strcmp(fen, fen_chk) == 0, fen_chk);
    }
    gamestate_cleanup(&gs);
}

static CX_TEST(test_fen_checkmate) {
    /* this test contains a full game where white is checkmated */
    const char * fen = "5rk1/1pp4p/p1n3p1/4b1N1/8/1P1N4/P1P3P1/qKB4R w - - 2 26";
    GameState gs;
    int result = fen_parse(fen, &gs);
    CX_TEST_DO {
        CX_TEST_ASSERT(result == 0);
        CX_TEST_ASSERT(strcmp(gs.fen_start, fen) == 0);
        CX_TEST_ASSERT(gs.fifty_cntr_start == 2);
        CX_TEST_ASSERT(gs.move_start == 50);
        CX_TEST_ASSERT(current_color(&gs) == WHITE);
        CX_TEST_ASSERT(!gs.stalemate);
        CX_TEST_ASSERT(!gs.threefold);
        CX_TEST_ASSERT(!gs.nomaterial);
        CX_TEST_ASSERT(!gs.remis);
        CX_TEST_ASSERT(!gs.wresign);
        CX_TEST_ASSERT(!gs.bresign);
        CX_TEST_ASSERT(!gs.ragequit);
        CX_TEST_ASSERT(!gs.review);
        /* the checkmate flag must be set */
        CX_TEST_ASSERT(gs.checkmate);
        /* check that we get the original FEN back */
        char fen_chk[FEN_MAX_LENGTH];
        fen_compute(fen_chk, &gs);
        CX_TEST_ASSERTM(strcmp(fen, fen_chk) == 0, fen_chk);
    }
    gamestate_cleanup(&gs);
}

static CX_TEST(test_fen_stalemate) {
    const char * fen = "8/8/kBK5/P7/8/8/8/8 b - - 6 57";
    GameState gs;
    int result = fen_parse(fen, &gs);
    CX_TEST_DO {
        CX_TEST_ASSERT(result == 0);
        CX_TEST_ASSERT(strcmp(gs.fen_start, fen) == 0);
        CX_TEST_ASSERT(gs.fifty_cntr_start == 6);
        CX_TEST_ASSERT(gs.move_start == 113);
        CX_TEST_ASSERT(current_color(&gs) == BLACK);
        CX_TEST_ASSERT(gs.stalemate);
        CX_TEST_ASSERT(!gs.threefold);
        CX_TEST_ASSERT(!gs.nomaterial);
        CX_TEST_ASSERT(!gs.remis);
        CX_TEST_ASSERT(!gs.wresign);
        CX_TEST_ASSERT(!gs.bresign);
        CX_TEST_ASSERT(!gs.ragequit);
        CX_TEST_ASSERT(!gs.review);
        CX_TEST_ASSERT(!gs.checkmate);
        /* check that we get the original FEN back */
        char fen_chk[FEN_MAX_LENGTH];
        fen_compute(fen_chk, &gs);
        CX_TEST_ASSERTM(strcmp(fen, fen_chk) == 0, fen_chk);
    }
    gamestate_cleanup(&gs);
}

static CX_TEST(test_fen_nomaterial) {
    const char * fen = "8/5K1k/8/8/8/8/8/8 w - - 0 77";
    GameState gs;
    int result = fen_parse(fen, &gs);
    CX_TEST_DO {
        CX_TEST_ASSERT(result == 0);
        CX_TEST_ASSERT(strcmp(gs.fen_start, fen) == 0);
        CX_TEST_ASSERT(gs.fifty_cntr_start == 0);
        CX_TEST_ASSERT(gs.move_start == 152);
        CX_TEST_ASSERT(current_color(&gs) == WHITE);
        CX_TEST_ASSERT(!gs.stalemate);
        CX_TEST_ASSERT(!gs.threefold);
        CX_TEST_ASSERT(gs.nomaterial);
        CX_TEST_ASSERT(!gs.remis);
        CX_TEST_ASSERT(!gs.wresign);
        CX_TEST_ASSERT(!gs.bresign);
        CX_TEST_ASSERT(!gs.ragequit);
        CX_TEST_ASSERT(!gs.review);
        CX_TEST_ASSERT(!gs.checkmate);
        /* check that we get the original FEN back */
        char fen_chk[FEN_MAX_LENGTH];
        fen_compute(fen_chk, &gs);
        CX_TEST_ASSERTM(strcmp(fen, fen_chk) == 0, fen_chk);
    }
    gamestate_cleanup(&gs);
}

static CX_TEST(test_fen_enpassant) {
    /* this test contains a full game where white is checkmated */
    const char * fen = "rnQ4r/pp4kp/3p2pn/1BpPp1N1/5P2/2BK4/P1P3qP/8 w - e6 0 19";
    GameState gs;
    int result = fen_parse(fen, &gs);
    CX_TEST_DO {
        CX_TEST_ASSERT(result == 0);
        /* verify that only e5 has an active enpassant threat */
        for (File f = 0 ; f < 8 ; f++) {
            for (Rank r = 0 ; r < 8 ; r++) {
                if (f == fileidx('e') && r == rankidx('5')) {
                    CX_TEST_ASSERT(enpassant_threat_exists(&gs, f, r));
                } else {
                    CX_TEST_ASSERT(!enpassant_threat_exists(&gs, f, r));
                }
            }
        }

        /* check that we get the original FEN back */
        char fen_chk[FEN_MAX_LENGTH];
        fen_compute(fen_chk, &gs);
        CX_TEST_ASSERTM(strcmp(fen, fen_chk) == 0, fen_chk);
    }
    gamestate_cleanup(&gs);
}

CxTestSuite* test_fen_suite(void) {
    CxTestSuite* suite = cx_test_suite_new("Test FEN API");

    cx_test_register(suite, test_fen_basic);
    cx_test_register(suite, test_fen_with_castling_rights);
    cx_test_register(suite, test_fen_checkmate);
    cx_test_register(suite, test_fen_stalemate);
    cx_test_register(suite, test_fen_nomaterial);
    cx_test_register(suite, test_fen_enpassant);

    return suite;
}