You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
228 lines
15 KiB
228 lines
15 KiB
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));
|
|
}
|
|
}
|