chessfriend/position/src/testing.rs

// Eryn Wells <eryn@erynwells.me>

use crate::position::MakeMoveError;
use chessfriend_moves::BuildMoveError;

#[macro_export]
macro_rules! assert_move_list {
    ($generated:expr, $expected:expr, $position:expr) => {
        assert_eq!(
            $generated,
            $expected,
            "\n\tMatching: {:?}\n\tGenerated, not expected: {:?}\n\tExpected, not generated: {:?}",
            $generated
                .intersection(&$expected)
                .map(|mv| format!("{}", mv))
                .collect::<Vec<String>>(),
            $generated
                .difference(&$expected)
                .map(|mv| format!("{}", mv))
                .collect::<Vec<String>>(),
            $expected
                .difference(&$generated)
                .map(|mv| format!("{}", mv))
                .collect::<Vec<String>>(),
        )
    };
}

#[macro_export]
macro_rules! formatted_move_list {
    ($move_list:expr, $position:expr) => {
        $move_list
            .iter()
            .map(|mv| format!("{}", mv))
            .collect::<Vec<String>>()
    };
}

#[macro_export]
macro_rules! assert_eq_bitboards {
    ($result:expr, $expected:expr) => {{
        let result = $result;
        let expected = $expected;
        assert_eq!(
            result, expected,
            "Result:\n{}\nExpected:\n{}",
            result, expected
        );
    }};
}

pub type TestResult = Result<(), TestError>;

#[derive(Debug, Eq, PartialEq)]
pub enum TestError {
    BuildMove(BuildMoveError),
    MakeMove(MakeMoveError),
    NoLegalMoves,
}

impl From<BuildMoveError> for TestError {
    fn from(value: BuildMoveError) -> Self {
        TestError::BuildMove(value)
    }
}

impl From<MakeMoveError> for TestError {
    fn from(value: MakeMoveError) -> Self {
        TestError::MakeMove(value)
    }
}