CliArcadeService/src/test/java/Game/ChessObj/ChessBoardTest.java

package Game.ChessObj;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.mock;

class ChessBoardTest {

    ChessFigure.Type[] startOrder = {
            ChessFigure.Type.CASTLE, ChessFigure.Type.KNIGHT, ChessFigure.Type.BISHOP, ChessFigure.Type.QUEEN, ChessFigure.Type.KING, ChessFigure.Type.BISHOP, ChessFigure.Type.KNIGHT, ChessFigure.Type.CASTLE
    };

    ChessBoard chessBoard;

    @BeforeEach
    void setUp() {
        chessBoard = new ChessBoard();
    }

    @AfterEach
    void tearDown() {
    }

    @Test
    void initBoard() {
        ChessFigure[][] board = chessBoard.getBoard();
        for (int x = 0; x < board[0].length; x++) {
            for (int y = 0; y < board.length; y++) {
                //test pawns
                if (y == 1) {
                    assertEquals(new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK), board[y][x]);
                    continue;
                }
                if (y == 6) {
                    assertEquals(new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE), board[y][x]);
                    continue;
                }

                if (y == 0) {
                    assertEquals(new ChessFigure(startOrder[x], ChessFigure.Team.BLACK), board[y][x]);
                    continue;
                }
                if (y == 7) {
                    assertEquals(new ChessFigure(startOrder[x], ChessFigure.Team.WHITE), board[y][x]);
                    continue;
                }
                //rest should be empty(null)
                assertNull(board[y][x]);
            }
        }
    }

    @Test
    void getCellSymbols() {
        String[][] expectedArray = {
                {"|T|", "|Z|", "|I|", "|Q|", "|K|", "|I|", "|Z|", "|T|"},
                {"|o|", "|o|", "|o|", "|o|", "|o|", "|o|", "|o|", "|o|"},
                {"   ", "   ", "   ", "   ", "   ", "   ", "   ", "   "},
                {"   ", "   ", "   ", "   ", "   ", "   ", "   ", "   "},
                {"   ", "   ", "   ", "   ", "   ", "   ", "   ", "   "},
                {"   ", "   ", "   ", "   ", "   ", "   ", "   ", "   "},
                {" o ", " o ", " o ", " o ", " o ", " o ", " o ", " o "},
                {" T ", " Z ", " I ", " Q ", " K ", " I ", " Z ", " T "}
        };
        assertArrayEquals(expectedArray, chessBoard.getCellSymbols());
    }

    @Test
    void isCellInBoard() {
        assertTrue(chessBoard.isCellInBoard(0, 0));
        assertTrue(chessBoard.isCellInBoard(7, 7));
        assertTrue(chessBoard.isCellInBoard(2, 1));
        assertTrue(chessBoard.isCellInBoard(5, 7));
        assertFalse(chessBoard.isCellInBoard(-1, 0));
        assertFalse(chessBoard.isCellInBoard(4, 8));
        assertFalse(chessBoard.isCellInBoard(10, 20));
    }

    @Test
    void validateCleanPath() {
        ChessFigure[][] tempBoard = chessBoard.getBoard();

        tempBoard[3][0] = mock(ChessFigure.class);
        tempBoard[3][5] = mock(ChessFigure.class);
        chessBoard.setChessBoard(tempBoard);

        assertFalse(chessBoard.validateCleanPath(-2, 0, 1, 4));
        assertTrue(chessBoard.validateCleanPath(0, 3, 5, 3));
        assertFalse(chessBoard.validateCleanPath(0, 3, 6, 3));
        assertFalse(chessBoard.validateCleanPath(0, 3, 7, 3));
        assertFalse(chessBoard.validateCleanPath(0, 3, 5, 5));
        assertFalse(chessBoard.validateCleanPath(0, 3, 4, 7));
        assertTrue(chessBoard.validateCleanPath(0, 3, 2, 5));
        assertTrue(chessBoard.validateCleanPath(7, 3, 5, 5));
        assertFalse(chessBoard.validateCleanPath(7, 3, 6, 6));
    }

    /*
            0     1     2     3     4     5     6     7
         ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
      0  │     │     │     │     │     │     │     │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      1  │     │     │     │     │     │     │     │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      2  │     │     │     │     │  o  │     │     │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      3  │     │     │     │ |o| │     │ |o| │     │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      4  │     │     │  o  │     │  o  │     │     │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      5  │     │     │     │ |o| │     │     │ |T| │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      6  │     │     │     │     │     │     │     │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      7  │     │     │  T  │     │  B  │     │     │     │
         └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
     */
    @Test
    void validateMove() {
        ChessFigure[][] tempBoard = new ChessFigure[8][8];

        tempBoard[4][2] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE);
        tempBoard[4][4] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE);
        tempBoard[2][4] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE);
        tempBoard[3][3] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK);
        tempBoard[3][5] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK);
        tempBoard[5][3] = new ChessFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK);
        tempBoard[7][2] = new ChessFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.WHITE);
        tempBoard[7][4] = new ChessFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.WHITE);
        tempBoard[5][6] = new ChessFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.BLACK);

        chessBoard.setChessBoard(tempBoard);

        //White pawn normal move
        assertTrue(chessBoard.validateMove(4, 2, 4, 1));
        assertFalse(chessBoard.validateMove(4, 2, 4, 3));
        assertFalse(chessBoard.validateMove(4, 2, 3, 1));
        assertFalse(chessBoard.validateMove(4, 2, 5, 1));
        //White pawn beats Black
        assertTrue(chessBoard.validateMove(4, 4, 3, 3));
        assertTrue(chessBoard.validateMove(4, 4, 5, 3));
        //Black pawn normal move
        assertTrue(chessBoard.validateMove(3, 5, 3, 6));
        assertFalse(chessBoard.validateMove(3, 5, 3, 4));
        assertFalse(chessBoard.validateMove(3, 5, 2, 6));
        assertFalse(chessBoard.validateMove(3, 5, 6, 6));
        //Black pawn beats White
        assertTrue(chessBoard.validateMove(3, 3, 2, 4));
        assertTrue(chessBoard.validateMove(3, 3, 4, 4));

        //CastleMoves for testing global rules
        assertTrue(chessBoard.validateMove(2, 7, 2, 5));
        assertFalse(chessBoard.validateMove(2, 7, 2, 4));
        assertFalse(chessBoard.validateMove(2, 7, 2, 2));

        //Bishop Moves for testing global moves
        assertTrue(chessBoard.validateMove(4, 7, 5, 6));
        assertTrue(chessBoard.validateMove(4, 7, 6, 5));
        assertFalse(chessBoard.validateMove(4, 7, 7, 4));
    }

    /*
            0     1     2     3     4     5     6     7                 0     1     2     3     4     5     6     7
         ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐           ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
      0  │     │     │     │     │     │     │     │     │        0  │     │     │     │     │     │     │     │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤           ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      1  │     │     │     │  T  │     │     │     │  K  │        1  │     │     │     │     │     │     │     │  K  │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤           ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      2  │     │     │     │     │     │     │     │     │        2  │     │     │     │     │     │     │     │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤           ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      3  │     │     │     │     │     │  Z  │     │     │        3  │     │     │     │     │     │  Z  │     │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤   -->     ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      4  │     │     │     │     │     │     │     │     │        4  │     │     │     │     │  B  │     │     │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤           ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      5  │     │     │ |Q| │     │     │     │     │     │        5  │     │     │  T  │     │     │     │     │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤           ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      6  │     │     │     │     │     │     │  B  │     │        6  │     │     │     │     │     │     │     │     │
         ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤           ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
      7  │     │     │     │     │     │     │     │     │        7  │     │     │     │     │     │     │     │     │
         └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘           └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
     */
    @Test
    void moveFigure() {
        ChessFigure[][] tempBoard = new ChessFigure[8][8];
        ChessFigure[][] resultBoard = new ChessFigure[8][8];

        tempBoard[1][3] = new ChessFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.WHITE);
        tempBoard[1][7] = new ChessFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.WHITE);
        tempBoard[6][6] = new ChessFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.WHITE);
        tempBoard[3][5] = new ChessFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.WHITE);
        tempBoard[5][2] = new ChessFigure(ChessFigure.Type.QUEEN, ChessFigure.Team.BLACK);

        resultBoard[5][2] = new ChessFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.WHITE);
        resultBoard[1][7] = new ChessFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.WHITE);
        resultBoard[4][4] = new ChessFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.WHITE);
        resultBoard[3][5] = new ChessFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.WHITE);

        chessBoard.setChessBoard(tempBoard);

        assertEquals(chessBoard.moveFigure(3, 1, 2, 1), ChessBoard.MoveFeedback.MOVE);
        assertEquals(chessBoard.moveFigure(2, 1, 2, 5), ChessBoard.MoveFeedback.ENEMYBEATEN);
        assertEquals(chessBoard.moveFigure(6, 6, 4, 4), ChessBoard.MoveFeedback.MOVE);
        assertEquals(chessBoard.moveFigure(7, 1, 8, 1), ChessBoard.MoveFeedback.OUTSIDEOFBOARD);
        assertEquals(chessBoard.moveFigure(5, 3, 4, 2), ChessBoard.MoveFeedback.INVALID);

        assertArrayEquals(resultBoard, chessBoard.getBoard());
    }

    @Test
    void scanForOccurringFigure() {
        assertEquals(8, chessBoard.scanForOccurringFigure(ChessFigure.Type.PAWN, ChessFigure.Team.WHITE));
        assertEquals(2, chessBoard.scanForOccurringFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.WHITE));
        assertEquals(2, chessBoard.scanForOccurringFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.WHITE));
        assertEquals(2, chessBoard.scanForOccurringFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.WHITE));
        assertEquals(1, chessBoard.scanForOccurringFigure(ChessFigure.Type.QUEEN, ChessFigure.Team.WHITE));
        assertEquals(1, chessBoard.scanForOccurringFigure(ChessFigure.Type.KING, ChessFigure.Team.WHITE));

        assertEquals(8, chessBoard.scanForOccurringFigure(ChessFigure.Type.PAWN, ChessFigure.Team.BLACK));
        assertEquals(2, chessBoard.scanForOccurringFigure(ChessFigure.Type.CASTLE, ChessFigure.Team.BLACK));
        assertEquals(2, chessBoard.scanForOccurringFigure(ChessFigure.Type.BISHOP, ChessFigure.Team.BLACK));
        assertEquals(2, chessBoard.scanForOccurringFigure(ChessFigure.Type.KNIGHT, ChessFigure.Team.BLACK));
        assertEquals(1, chessBoard.scanForOccurringFigure(ChessFigure.Type.QUEEN, ChessFigure.Team.BLACK));
        assertEquals(1, chessBoard.scanForOccurringFigure(ChessFigure.Type.KING, ChessFigure.Team.BLACK));
    }
}