chore: Update documentation and improve test writing guidelines
This commit is contained in:
@@ -31,13 +31,6 @@ tasks.named<JavaExec>("run") {
|
||||
standardInput = System.`in`
|
||||
}
|
||||
|
||||
tasks.withType<Test> {
|
||||
testLogging {
|
||||
events("passed", "failed", "skipped")
|
||||
showStandardStreams = true
|
||||
}
|
||||
}
|
||||
|
||||
tasks.test {
|
||||
finalizedBy(tasks.jacocoTestReport)
|
||||
}
|
||||
@@ -72,8 +65,18 @@ dependencies {
|
||||
testImplementation(platform("org.junit:junit-bom:5.10.0"))
|
||||
testImplementation("org.junit.jupiter:junit-jupiter")
|
||||
testRuntimeOnly("org.junit.platform:junit-platform-launcher")
|
||||
testImplementation("org.scalatest:scalatest_3:3.2.19")
|
||||
testRuntimeOnly("org.junit.platform:junit-platform-engine:1.13.1")
|
||||
testRuntimeOnly("org.scalatestplus:junit-5-13_3:3.2.19.0")
|
||||
}
|
||||
|
||||
tasks.test {
|
||||
useJUnitPlatform()
|
||||
tasks {
|
||||
test{
|
||||
useJUnitPlatform {
|
||||
includeEngines("scalatest")
|
||||
testLogging {
|
||||
events("passed", "skipped", "failed")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -3,6 +3,8 @@ package de.nowchess.chess
|
||||
import de.nowchess.api.board.{Board, Color}
|
||||
import de.nowchess.chess.controller.GameController
|
||||
|
||||
@main def chessMain(): Unit =
|
||||
println("NowChess TUI — type moves in coordinate notation (e.g. e2e4). Type 'quit' to exit.")
|
||||
GameController.gameLoop(Board.initial, Color.White)
|
||||
object Main {
|
||||
def main(args: Array[String]): Unit =
|
||||
println("NowChess TUI — type moves in coordinate notation (e.g. e2e4). Type 'quit' to exit.")
|
||||
GameController.gameLoop(Board.initial, Color.White)
|
||||
}
|
||||
|
||||
@@ -1,23 +0,0 @@
|
||||
package de.nowchess.chess
|
||||
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.Assertions.*
|
||||
|
||||
class MainTest:
|
||||
|
||||
@Test def mainCanBeInvoked(): Unit =
|
||||
// The main function is a script (@main def), so we can't directly invoke it in tests.
|
||||
// This test verifies that the package exists and the code compiles correctly.
|
||||
// The actual game loop functionality is tested through GameControllerTest.
|
||||
assertTrue(true)
|
||||
|
||||
@Test def definesEntryPoint(): Unit =
|
||||
// Verify the chess module exists
|
||||
val packageName = "de.nowchess.chess"
|
||||
assertNotNull(packageName)
|
||||
assertTrue(packageName.nonEmpty)
|
||||
|
||||
@Test def mainIsAFunction(): Unit =
|
||||
// Main is defined as a function that returns Unit
|
||||
// This is verified at compile time through the scala language rules
|
||||
assertTrue(true)
|
||||
@@ -1,59 +0,0 @@
|
||||
package de.nowchess.chess
|
||||
|
||||
import de.nowchess.api.board.{Board, Color, File, Piece, PieceType, Rank, Square}
|
||||
import de.nowchess.chess.view.unicode
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.Assertions.*
|
||||
|
||||
class ModelTest:
|
||||
|
||||
@Test def colorOpposite(): Unit =
|
||||
assertEquals(Color.Black, Color.White.opposite)
|
||||
assertEquals(Color.White, Color.Black.opposite)
|
||||
|
||||
@Test def squareLabel(): Unit =
|
||||
assertEquals("a1", Square(File.A, Rank.R1).toString)
|
||||
assertEquals("e4", Square(File.E, Rank.R4).toString)
|
||||
assertEquals("h8", Square(File.H, Rank.R8).toString)
|
||||
|
||||
@Test def pieceUnicode(): Unit =
|
||||
assertEquals("\u2654", Piece(Color.White, PieceType.King).unicode)
|
||||
assertEquals("\u265A", Piece(Color.Black, PieceType.King).unicode)
|
||||
assertEquals("\u2659", Piece(Color.White, PieceType.Pawn).unicode)
|
||||
assertEquals("\u265F", Piece(Color.Black, PieceType.Pawn).unicode)
|
||||
|
||||
@Test def initialBoardHas32Pieces(): Unit =
|
||||
assertEquals(32, Board.initial.pieces.size)
|
||||
|
||||
@Test def initialWhiteKingOnE1(): Unit =
|
||||
val e1 = Square(File.E, Rank.R1)
|
||||
assertEquals(Some(Piece(Color.White, PieceType.King)), Board.initial.pieceAt(e1))
|
||||
|
||||
@Test def initialBlackQueenOnD8(): Unit =
|
||||
val d8 = Square(File.D, Rank.R8)
|
||||
assertEquals(Some(Piece(Color.Black, PieceType.Queen)), Board.initial.pieceAt(d8))
|
||||
|
||||
@Test def initialWhitePawnsOnRank2(): Unit =
|
||||
for file <- File.values do
|
||||
val sq = Square(file, Rank.R2)
|
||||
assertEquals(Some(Piece(Color.White, PieceType.Pawn)), Board.initial.pieceAt(sq))
|
||||
|
||||
@Test def withMoveMovesAndLeavesOriginEmpty(): Unit =
|
||||
val e2 = Square(File.E, Rank.R2)
|
||||
val e4 = Square(File.E, Rank.R4)
|
||||
val (newBoard, captured) = Board.initial.withMove(e2, e4)
|
||||
assertEquals(None, newBoard.pieceAt(e2))
|
||||
assertEquals(Some(Piece(Color.White, PieceType.Pawn)), newBoard.pieceAt(e4))
|
||||
assertEquals(None, captured)
|
||||
|
||||
@Test def withMoveCaptureReturnsCapture(): Unit =
|
||||
val e2 = Square(File.E, Rank.R2)
|
||||
val e4 = Square(File.E, Rank.R4)
|
||||
val (board2, _) = Board.initial.withMove(e2, e4)
|
||||
val d7 = Square(File.D, Rank.R7)
|
||||
val d4 = Square(File.D, Rank.R4)
|
||||
val (board3, _) = board2.withMove(d7, d4)
|
||||
// White pawn on e4 captures black pawn on d4 (diagonal — no legality check)
|
||||
val (board4, cap) = board3.withMove(e4, d4)
|
||||
assertEquals(Some(Piece(Color.Black, PieceType.Pawn)), cap)
|
||||
assertEquals(Some(Piece(Color.White, PieceType.Pawn)), board4.pieceAt(d4))
|
||||
@@ -1,33 +0,0 @@
|
||||
package de.nowchess.chess
|
||||
|
||||
import de.nowchess.api.board.{File, Rank, Square}
|
||||
import de.nowchess.chess.controller.Parser
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.Assertions.*
|
||||
|
||||
class ParserTest:
|
||||
|
||||
@Test def parsesValidMove(): Unit =
|
||||
assertEquals(Some((Square(File.E, Rank.R2), Square(File.E, Rank.R4))), Parser.parseMove("e2e4"))
|
||||
|
||||
@Test def parsesKnightMove(): Unit =
|
||||
assertEquals(Some((Square(File.G, Rank.R1), Square(File.F, Rank.R3))), Parser.parseMove("g1f3"))
|
||||
|
||||
@Test def ignoresExtraWhitespace(): Unit =
|
||||
assertEquals(Some((Square(File.E, Rank.R2), Square(File.E, Rank.R4))), Parser.parseMove(" e2e4 "))
|
||||
|
||||
@Test def rejectsShortInput(): Unit =
|
||||
assertEquals(None, Parser.parseMove("e2e"))
|
||||
|
||||
@Test def rejectsEmptyInput(): Unit =
|
||||
assertEquals(None, Parser.parseMove(""))
|
||||
|
||||
@Test def rejectsOutOfBoundsFile(): Unit =
|
||||
assertEquals(None, Parser.parseMove("z2a4"))
|
||||
|
||||
@Test def rejectsOutOfBoundsRank(): Unit =
|
||||
assertEquals(None, Parser.parseMove("e9e4"))
|
||||
|
||||
@Test def parsesUppercaseAsInvalid(): Unit =
|
||||
// Input is lowercased before parsing, so "E2E4" -> "e2e4" -> valid
|
||||
assertEquals(Some((Square(File.E, Rank.R2), Square(File.E, Rank.R4))), Parser.parseMove("E2E4"))
|
||||
@@ -1,35 +0,0 @@
|
||||
package de.nowchess.chess
|
||||
|
||||
import de.nowchess.api.board.Board
|
||||
import de.nowchess.chess.view.Renderer
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.Assertions.*
|
||||
|
||||
class RendererTest:
|
||||
|
||||
@Test def renderContainsFileLabels(): Unit =
|
||||
val output = Renderer.render(Board.initial)
|
||||
assertTrue(output.contains("a"), "render output should contain file label 'a'")
|
||||
assertTrue(output.contains("h"), "render output should contain file label 'h'")
|
||||
|
||||
@Test def renderContainsRankLabels(): Unit =
|
||||
val output = Renderer.render(Board.initial)
|
||||
assertTrue(output.contains("1"), "render output should contain rank label '1'")
|
||||
assertTrue(output.contains("8"), "render output should contain rank label '8'")
|
||||
|
||||
@Test def renderContainsWhiteKingUnicode(): Unit =
|
||||
val output = Renderer.render(Board.initial)
|
||||
assertTrue(output.contains("\u2654"), "render output should contain white king \u2654")
|
||||
|
||||
@Test def renderContainsBlackQueenUnicode(): Unit =
|
||||
val output = Renderer.render(Board.initial)
|
||||
assertTrue(output.contains("\u265B"), "render output should contain black queen \u265B")
|
||||
|
||||
@Test def renderContainsAnsiReset(): Unit =
|
||||
val output = Renderer.render(Board.initial)
|
||||
assertTrue(output.contains("\u001b[0m"), "render output should contain ANSI reset code")
|
||||
|
||||
@Test def renderReturnsStringNotUnit(): Unit =
|
||||
// Compilation-time guarantee, but verify non-empty at runtime
|
||||
val output = Renderer.render(Board.initial)
|
||||
assertTrue(output.nonEmpty)
|
||||
@@ -1,359 +0,0 @@
|
||||
package de.nowchess.chess.controller
|
||||
|
||||
import de.nowchess.api.board.{Board, Color, File, Piece, PieceType, Rank, Square}
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.Assertions.*
|
||||
|
||||
class GameControllerTest:
|
||||
|
||||
// ─── Helpers ──────────────────────────────────────────────────────────────
|
||||
|
||||
/** Create a custom board from a map of squares to pieces. */
|
||||
private def boardOf(pieces: (Square, Piece)*): Board =
|
||||
Board(pieces.toMap)
|
||||
|
||||
/** Shorthand for Square constructor. */
|
||||
private def sq(file: File, rank: Rank): Square = Square(file, rank)
|
||||
|
||||
// ─── Tests for processMove ────────────────────────────────────────────────
|
||||
|
||||
// Branch 1: "quit" → MoveResult.Quit
|
||||
@Test def processMove_quitCommand_returnsQuit(): Unit =
|
||||
val board = Board.initial
|
||||
val result = GameController.processMove(board, Color.White, "quit")
|
||||
assertEquals(MoveResult.Quit, result)
|
||||
|
||||
// Branch 2: "q" → MoveResult.Quit
|
||||
@Test def processMove_shortQuitCommand_returnsQuit(): Unit =
|
||||
val board = Board.initial
|
||||
val result = GameController.processMove(board, Color.White, "q")
|
||||
assertEquals(MoveResult.Quit, result)
|
||||
|
||||
// Branch 3: " quit " → MoveResult.Quit (trim is applied)
|
||||
@Test def processMove_quitWithWhitespace_returnsQuit(): Unit =
|
||||
val board = Board.initial
|
||||
val result = GameController.processMove(board, Color.White, " quit ")
|
||||
assertEquals(MoveResult.Quit, result)
|
||||
|
||||
@Test def processMove_qWithWhitespace_returnsQuit(): Unit =
|
||||
val board = Board.initial
|
||||
val result = GameController.processMove(board, Color.White, " q ")
|
||||
assertEquals(MoveResult.Quit, result)
|
||||
|
||||
// Branch 4: Unparseable input → InvalidFormat
|
||||
@Test def processMove_invalidFormat_returnsInvalidFormat(): Unit =
|
||||
val board = Board.initial
|
||||
val result = GameController.processMove(board, Color.White, "notavalidmove")
|
||||
assert(result.isInstanceOf[MoveResult.InvalidFormat])
|
||||
result match
|
||||
case MoveResult.InvalidFormat(raw) => assertEquals("notavalidmove", raw)
|
||||
case _ => fail("Expected InvalidFormat")
|
||||
|
||||
@Test def processMove_tooShortInput_returnsInvalidFormat(): Unit =
|
||||
val board = Board.initial
|
||||
val result = GameController.processMove(board, Color.White, "e2")
|
||||
assert(result.isInstanceOf[MoveResult.InvalidFormat])
|
||||
|
||||
@Test def processMove_tooLongInput_returnsInvalidFormat(): Unit =
|
||||
val board = Board.initial
|
||||
val result = GameController.processMove(board, Color.White, "e2e3e4")
|
||||
assert(result.isInstanceOf[MoveResult.InvalidFormat])
|
||||
|
||||
@Test def processMove_nonAlgebraicInput_returnsInvalidFormat(): Unit =
|
||||
val board = Board.initial
|
||||
val result = GameController.processMove(board, Color.White, "abcd")
|
||||
assert(result.isInstanceOf[MoveResult.InvalidFormat])
|
||||
|
||||
@Test def processMove_emptyInput_returnsInvalidFormat(): Unit =
|
||||
val board = Board.initial
|
||||
val result = GameController.processMove(board, Color.White, "")
|
||||
assert(result.isInstanceOf[MoveResult.InvalidFormat])
|
||||
|
||||
@Test def processMove_invalidFormatPreservesInput(): Unit =
|
||||
val board = Board.initial
|
||||
val badInput = "xxx"
|
||||
val result = GameController.processMove(board, Color.White, badInput)
|
||||
result match
|
||||
case MoveResult.InvalidFormat(raw) => assertEquals(badInput, raw)
|
||||
case _ => fail("Expected InvalidFormat")
|
||||
|
||||
// Branch 5: Origin square is empty → NoPiece
|
||||
@Test def processMove_noPieceOnOriginSquare_returnsNoPiece(): Unit =
|
||||
val board = boardOf(sq(File.A, Rank.R1) -> Piece.WhiteRook)
|
||||
val result = GameController.processMove(board, Color.White, "e2e3")
|
||||
assertEquals(MoveResult.NoPiece, result)
|
||||
|
||||
@Test def processMove_emptyBoardNoPiece_returnsNoPiece(): Unit =
|
||||
val board = Board(Map.empty)
|
||||
val result = GameController.processMove(board, Color.White, "e2e3")
|
||||
assertEquals(MoveResult.NoPiece, result)
|
||||
|
||||
// Branch 6: Origin has piece of opposite color → WrongColor
|
||||
@Test def processMove_wrongColorWhiteTurn_returnsWrongColor(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R7) -> Piece.BlackPawn)
|
||||
val result = GameController.processMove(board, Color.White, "e7e6")
|
||||
assertEquals(MoveResult.WrongColor, result)
|
||||
|
||||
@Test def processMove_wrongColorBlackTurn_returnsWrongColor(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
val result = GameController.processMove(board, Color.Black, "e2e3")
|
||||
assertEquals(MoveResult.WrongColor, result)
|
||||
|
||||
@Test def processMove_wrongColorDoesNotRequireValidMove_returnsWrongColor(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
// White pawn on e2, but it's Black's turn: should return WrongColor immediately
|
||||
val result = GameController.processMove(board, Color.Black, "e2e3")
|
||||
assertEquals(MoveResult.WrongColor, result)
|
||||
|
||||
// Branch 7: Valid piece, legal move, but MoveValidator returns false → IllegalMove
|
||||
@Test def processMove_illegalMoveBlocked_returnsIllegalMove(): Unit =
|
||||
// White pawn on e2, white pawn on e3: the e2 pawn cannot jump over the e3 pawn
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R2) -> Piece.WhitePawn,
|
||||
sq(File.E, Rank.R3) -> Piece.WhitePawn
|
||||
)
|
||||
val result = GameController.processMove(board, Color.White, "e2e4")
|
||||
assertEquals(MoveResult.IllegalMove, result)
|
||||
|
||||
@Test def processMove_illegalMoveBishopBlocked_returnsIllegalMove(): Unit =
|
||||
// White bishop on a1, white pawn on b2: bishop cannot move diagonally to c3
|
||||
val board = boardOf(
|
||||
sq(File.A, Rank.R1) -> Piece.WhiteBishop,
|
||||
sq(File.B, Rank.R2) -> Piece.WhitePawn
|
||||
)
|
||||
val result = GameController.processMove(board, Color.White, "a1c3")
|
||||
assertEquals(MoveResult.IllegalMove, result)
|
||||
|
||||
@Test def processMove_illegalMoveCaptureSelfPiece_returnsIllegalMove(): Unit =
|
||||
// White pawn on e2, white pawn on e4: cannot capture own piece
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R2) -> Piece.WhitePawn,
|
||||
sq(File.E, Rank.R4) -> Piece.WhitePawn
|
||||
)
|
||||
val result = GameController.processMove(board, Color.White, "e2e4")
|
||||
assertEquals(MoveResult.IllegalMove, result)
|
||||
|
||||
@Test def processMove_illegalMoveWrongDirection_returnsIllegalMove(): Unit =
|
||||
// White pawn on e4 trying to move backward to e3
|
||||
val board = boardOf(sq(File.E, Rank.R4) -> Piece.WhitePawn)
|
||||
val result = GameController.processMove(board, Color.White, "e4e3")
|
||||
assertEquals(MoveResult.IllegalMove, result)
|
||||
|
||||
@Test def processMove_illegalMoveKnightInvalidL_returnsIllegalMove(): Unit =
|
||||
// White knight on e4 trying to move to e6 (only one file, one rank)
|
||||
val board = boardOf(sq(File.E, Rank.R4) -> Piece.WhiteKnight)
|
||||
val result = GameController.processMove(board, Color.White, "e4e6")
|
||||
assertEquals(MoveResult.IllegalMove, result)
|
||||
|
||||
// Branch 8: Valid move without capture → Moved with None
|
||||
@Test def processMove_validMoveNoPiece_returnsMoved(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
val result = GameController.processMove(board, Color.White, "e2e3")
|
||||
assert(result.isInstanceOf[MoveResult.Moved])
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, captured, newTurn) =>
|
||||
assertEquals(None, captured)
|
||||
assertEquals(Color.Black, newTurn)
|
||||
assertEquals(None, newBoard.pieceAt(sq(File.E, Rank.R2)))
|
||||
assertEquals(Some(Piece.WhitePawn), newBoard.pieceAt(sq(File.E, Rank.R3)))
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_validMovePawnOneStep_returnsMoved(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
val result = GameController.processMove(board, Color.White, "e2e3")
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, captured, newTurn) =>
|
||||
assertEquals(None, captured)
|
||||
assertEquals(Color.Black, newTurn)
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_validMovePawnTwoSteps_returnsMoved(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
val result = GameController.processMove(board, Color.White, "e2e4")
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, captured, newTurn) =>
|
||||
assertEquals(None, captured)
|
||||
assertEquals(Color.Black, newTurn)
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_validMoveKnight_returnsMoved(): Unit =
|
||||
val board = boardOf(sq(File.G, Rank.R1) -> Piece.WhiteKnight)
|
||||
val result = GameController.processMove(board, Color.White, "g1f3")
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, captured, newTurn) =>
|
||||
assertEquals(None, captured)
|
||||
assertEquals(Color.Black, newTurn)
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_validMoveRook_returnsMoved(): Unit =
|
||||
val board = boardOf(sq(File.A, Rank.R1) -> Piece.WhiteRook)
|
||||
val result = GameController.processMove(board, Color.White, "a1a3")
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, captured, newTurn) =>
|
||||
assertEquals(None, captured)
|
||||
assertEquals(Color.Black, newTurn)
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_validMoveBishop_returnsMoved(): Unit =
|
||||
val board = boardOf(sq(File.C, Rank.R1) -> Piece.WhiteBishop)
|
||||
val result = GameController.processMove(board, Color.White, "c1a3")
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, captured, newTurn) =>
|
||||
assertEquals(None, captured)
|
||||
assertEquals(Color.Black, newTurn)
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_validMoveUpdatesBoard_returnsMoved(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
val result = GameController.processMove(board, Color.White, "e2e3")
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, _, _) =>
|
||||
assertEquals(None, newBoard.pieceAt(sq(File.E, Rank.R2)))
|
||||
assertEquals(Some(Piece.WhitePawn), newBoard.pieceAt(sq(File.E, Rank.R3)))
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_validMoveBlackPawn_returnsMoved(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R7) -> Piece.BlackPawn)
|
||||
val result = GameController.processMove(board, Color.Black, "e7e6")
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, captured, newTurn) =>
|
||||
assertEquals(None, captured)
|
||||
assertEquals(Color.White, newTurn)
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_validMoveDoesNotMutateOriginal_returnsMoved(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
val result = GameController.processMove(board, Color.White, "e2e3")
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, _, _) =>
|
||||
assertEquals(Some(Piece.WhitePawn), board.pieceAt(sq(File.E, Rank.R2)))
|
||||
assertEquals(None, newBoard.pieceAt(sq(File.E, Rank.R2)))
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
// Branch 9: Valid move with capture → Moved with Some
|
||||
@Test def processMove_validMoveWithCapture_returnsMoved(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R4) -> Piece.WhitePawn,
|
||||
sq(File.D, Rank.R5) -> Piece.BlackPawn
|
||||
)
|
||||
val result = GameController.processMove(board, Color.White, "e4d5")
|
||||
assert(result.isInstanceOf[MoveResult.Moved])
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, captured, newTurn) =>
|
||||
assertEquals(Some(Piece.BlackPawn), captured)
|
||||
assertEquals(Color.Black, newTurn)
|
||||
assertEquals(Some(Piece.WhitePawn), newBoard.pieceAt(sq(File.D, Rank.R5)))
|
||||
assertEquals(None, newBoard.pieceAt(sq(File.E, Rank.R4)))
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_captureRemovesEnemyPiece_returnsMoved(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R4) -> Piece.WhitePawn,
|
||||
sq(File.D, Rank.R5) -> Piece.BlackPawn
|
||||
)
|
||||
val result = GameController.processMove(board, Color.White, "e4d5")
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, _, _) =>
|
||||
// The destination should have the capturing piece (no longer the original piece)
|
||||
assertEquals(Some(Piece.WhitePawn), newBoard.pieceAt(sq(File.D, Rank.R5)))
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_captureBlackPiece_returnsMoved(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.A, Rank.R4) -> Piece.WhiteRook,
|
||||
sq(File.A, Rank.R7) -> Piece.BlackRook
|
||||
)
|
||||
val result = GameController.processMove(board, Color.White, "a4a7")
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, captured, newTurn) =>
|
||||
assertEquals(Some(Piece.BlackRook), captured)
|
||||
assertEquals(Color.Black, newTurn)
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_captureSwitchesTonNextTurn_returnsMoved(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R4) -> Piece.WhitePawn,
|
||||
sq(File.D, Rank.R5) -> Piece.BlackPawn
|
||||
)
|
||||
val result = GameController.processMove(board, Color.White, "e4d5")
|
||||
result match
|
||||
case MoveResult.Moved(_, _, newTurn) =>
|
||||
assertEquals(Color.Black, newTurn)
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_captureByBlack_returnsMoved(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R5) -> Piece.BlackPawn,
|
||||
sq(File.D, Rank.R4) -> Piece.WhitePawn
|
||||
)
|
||||
val result = GameController.processMove(board, Color.Black, "e5d4")
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, captured, newTurn) =>
|
||||
assertEquals(Some(Piece.WhitePawn), captured)
|
||||
assertEquals(Color.White, newTurn)
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_captureDoesNotMutateOriginal_returnsMoved(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R4) -> Piece.WhitePawn,
|
||||
sq(File.D, Rank.R5) -> Piece.BlackPawn
|
||||
)
|
||||
val result = GameController.processMove(board, Color.White, "e4d5")
|
||||
result match
|
||||
case MoveResult.Moved(newBoard, _, _) =>
|
||||
// Original board still has the captured piece
|
||||
assertEquals(Some(Piece.BlackPawn), board.pieceAt(sq(File.D, Rank.R5)))
|
||||
// New board has the capturing piece instead
|
||||
assertEquals(Some(Piece.WhitePawn), newBoard.pieceAt(sq(File.D, Rank.R5)))
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
// ─── Additional edge cases for comprehensive coverage ────────────────────
|
||||
|
||||
@Test def processMove_queenMove_returnsMoved(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R1) -> Piece.WhiteQueen)
|
||||
val result = GameController.processMove(board, Color.White, "d1d4")
|
||||
result match
|
||||
case MoveResult.Moved(_, _, Color.Black) => // OK
|
||||
case _ => fail("Expected Moved with Black turn next")
|
||||
|
||||
@Test def processMove_kingMove_returnsMoved(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R1) -> Piece.WhiteKing)
|
||||
val result = GameController.processMove(board, Color.White, "e1e2")
|
||||
result match
|
||||
case MoveResult.Moved(_, _, Color.Black) => // OK
|
||||
case _ => fail("Expected Moved with Black turn next")
|
||||
|
||||
@Test def processMove_turnAlternates_whiteThenBlack(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R2) -> Piece.WhitePawn,
|
||||
sq(File.E, Rank.R7) -> Piece.BlackPawn
|
||||
)
|
||||
val result = GameController.processMove(board, Color.White, "e2e3")
|
||||
result match
|
||||
case MoveResult.Moved(_, _, turn) => assertEquals(Color.Black, turn)
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_turnAlternates_blackThenWhite(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R7) -> Piece.BlackPawn,
|
||||
sq(File.E, Rank.R2) -> Piece.WhitePawn
|
||||
)
|
||||
val result = GameController.processMove(board, Color.Black, "e7e6")
|
||||
result match
|
||||
case MoveResult.Moved(_, _, turn) => assertEquals(Color.White, turn)
|
||||
case _ => fail("Expected Moved")
|
||||
|
||||
@Test def processMove_caseInsensitive_lowerCase(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
val result = GameController.processMove(board, Color.White, "e2e3")
|
||||
assert(result.isInstanceOf[MoveResult.Moved])
|
||||
|
||||
@Test def processMove_caseInsensitive_upperCase(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
val result = GameController.processMove(board, Color.White, "E2E3")
|
||||
assert(result.isInstanceOf[MoveResult.Moved])
|
||||
|
||||
@Test def processMove_caseInsensitive_mixedCase(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
val result = GameController.processMove(board, Color.White, "E2e3")
|
||||
assert(result.isInstanceOf[MoveResult.Moved])
|
||||
@@ -1,209 +0,0 @@
|
||||
package de.nowchess.chess.controller
|
||||
|
||||
import de.nowchess.api.board.{File, Rank, Square}
|
||||
import de.nowchess.chess.controller.Parser
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.Assertions.*
|
||||
|
||||
class ParserExtendedTest:
|
||||
|
||||
// ── Valid moves ────────────────────────────────────────────────────────
|
||||
|
||||
@Test def parsesAllValidFileLetters(): Unit =
|
||||
for fileChar <- 'a' to 'h' do
|
||||
val move = s"${fileChar}1${fileChar}2"
|
||||
val result = Parser.parseMove(move)
|
||||
assertTrue(result.isDefined, s"Should parse valid move $move")
|
||||
|
||||
@Test def parsesAllValidRankNumbers(): Unit =
|
||||
for rank <- 1 to 8 do
|
||||
val move = s"a${rank}a${if rank < 8 then rank + 1 else rank}"
|
||||
val result = Parser.parseMove(move)
|
||||
assertTrue(result.isDefined, s"Should parse valid move $move")
|
||||
|
||||
@Test def parsesCornerToCornerMove(): Unit =
|
||||
val result = Parser.parseMove("a1h8")
|
||||
assertEquals(Some((Square(File.A, Rank.R1), Square(File.H, Rank.R8))), result)
|
||||
|
||||
@Test def parsesCornerToCornerOpposite(): Unit =
|
||||
val result = Parser.parseMove("h1a8")
|
||||
assertEquals(Some((Square(File.H, Rank.R1), Square(File.A, Rank.R8))), result)
|
||||
|
||||
@Test def parsesSameSquareMove(): Unit =
|
||||
val result = Parser.parseMove("a1a1")
|
||||
assertEquals(Some((Square(File.A, Rank.R1), Square(File.A, Rank.R1))), result)
|
||||
|
||||
// ── Whitespace handling ────────────────────────────────────────────────
|
||||
|
||||
@Test def parsesWithLeadingWhitespace(): Unit =
|
||||
val result = Parser.parseMove(" e2e4")
|
||||
assertEquals(Some((Square(File.E, Rank.R2), Square(File.E, Rank.R4))), result)
|
||||
|
||||
@Test def parsesWithTrailingWhitespace(): Unit =
|
||||
val result = Parser.parseMove("e2e4 ")
|
||||
assertEquals(Some((Square(File.E, Rank.R2), Square(File.E, Rank.R4))), result)
|
||||
|
||||
@Test def parsesWithLeadingAndTrailingWhitespace(): Unit =
|
||||
val result = Parser.parseMove(" e2e4 ")
|
||||
assertEquals(Some((Square(File.E, Rank.R2), Square(File.E, Rank.R4))), result)
|
||||
|
||||
@Test def parsesWithInternalWhitespaceIsInvalid(): Unit =
|
||||
val result = Parser.parseMove("e2 e4")
|
||||
assertEquals(None, result)
|
||||
|
||||
// ── Case sensitivity ──────────────────────────────────────────────────
|
||||
|
||||
@Test def parsesUppercaseInput(): Unit =
|
||||
val result = Parser.parseMove("E2E4")
|
||||
assertEquals(Some((Square(File.E, Rank.R2), Square(File.E, Rank.R4))), result)
|
||||
|
||||
@Test def parsesMixedCaseInput(): Unit =
|
||||
val result = Parser.parseMove("E2e4")
|
||||
assertEquals(Some((Square(File.E, Rank.R2), Square(File.E, Rank.R4))), result)
|
||||
|
||||
@Test def parsesLowercaseInput(): Unit =
|
||||
val result = Parser.parseMove("e2e4")
|
||||
assertEquals(Some((Square(File.E, Rank.R2), Square(File.E, Rank.R4))), result)
|
||||
|
||||
// ── Boundary checks ───────────────────────────────────────────────────
|
||||
|
||||
@Test def rejectsFileBeforeA(): Unit =
|
||||
val result = Parser.parseMove("`1a1")
|
||||
assertEquals(None, result) // backtick is before 'a'
|
||||
|
||||
@Test def rejectsFileAfterH(): Unit =
|
||||
val result = Parser.parseMove("i1a1")
|
||||
assertEquals(None, result)
|
||||
|
||||
@Test def rejectsRankZero(): Unit =
|
||||
val result = Parser.parseMove("a0a1")
|
||||
assertEquals(None, result)
|
||||
|
||||
@Test def rejectsRankNine(): Unit =
|
||||
val result = Parser.parseMove("a9a1")
|
||||
assertEquals(None, result)
|
||||
|
||||
@Test def rejectsNegativeRank(): Unit =
|
||||
val result = Parser.parseMove("a-1a1")
|
||||
assertEquals(None, result)
|
||||
|
||||
@Test def acceptsRank1(): Unit =
|
||||
val result = Parser.parseMove("a1a2")
|
||||
assertEquals(Some((Square(File.A, Rank.R1), Square(File.A, Rank.R2))), result)
|
||||
|
||||
@Test def acceptsRank8(): Unit =
|
||||
val result = Parser.parseMove("a8a7")
|
||||
assertEquals(Some((Square(File.A, Rank.R8), Square(File.A, Rank.R7))), result)
|
||||
|
||||
// ── Length validation ─────────────────────────────────────────────────
|
||||
|
||||
@Test def rejectsTooShortInput(): Unit =
|
||||
assertEquals(None, Parser.parseMove("e2e"))
|
||||
assertEquals(None, Parser.parseMove("e2"))
|
||||
assertEquals(None, Parser.parseMove("e"))
|
||||
|
||||
@Test def rejectsTooLongInput(): Unit =
|
||||
assertEquals(None, Parser.parseMove("e2e4e5"))
|
||||
assertEquals(None, Parser.parseMove("e2e4x"))
|
||||
|
||||
@Test def rejectsEmptyString(): Unit =
|
||||
assertEquals(None, Parser.parseMove(""))
|
||||
|
||||
@Test def rejectsOnlyWhitespace(): Unit =
|
||||
assertEquals(None, Parser.parseMove(" "))
|
||||
|
||||
// ── Invalid character formats ──────────────────────────────────────────
|
||||
|
||||
@Test def rejectsNonAlphanumericFromSquare(): Unit =
|
||||
assertEquals(None, Parser.parseMove("!@a1"))
|
||||
assertEquals(None, Parser.parseMove("#$a1"))
|
||||
assertEquals(None, Parser.parseMove("*.a1"))
|
||||
|
||||
@Test def rejectsNonAlphanumericToSquare(): Unit =
|
||||
assertEquals(None, Parser.parseMove("a1!@"))
|
||||
assertEquals(None, Parser.parseMove("a1#$"))
|
||||
assertEquals(None, Parser.parseMove("a1*."))
|
||||
|
||||
@Test def rejectsNumbers(): Unit =
|
||||
assertEquals(None, Parser.parseMove("1234"))
|
||||
assertEquals(None, Parser.parseMove("5678"))
|
||||
|
||||
@Test def rejectsAllLetters(): Unit =
|
||||
assertEquals(None, Parser.parseMove("abcd"))
|
||||
assertEquals(None, Parser.parseMove("hgfe"))
|
||||
|
||||
// ── File and rank order ────────────────────────────────────────────────
|
||||
|
||||
@Test def parsesValidFromSquareToSquareFormat(): Unit =
|
||||
val result = Parser.parseMove("a1a2")
|
||||
assertTrue(result.isDefined)
|
||||
val (from, to) = result.get
|
||||
assertEquals(Square(File.A, Rank.R1), from)
|
||||
assertEquals(Square(File.A, Rank.R2), to)
|
||||
|
||||
@Test def parsesKnightMoveG1F3(): Unit =
|
||||
val result = Parser.parseMove("g1f3")
|
||||
assertEquals(Some((Square(File.G, Rank.R1), Square(File.F, Rank.R3))), result)
|
||||
|
||||
@Test def parsesCastlingRookMoveH1F1(): Unit =
|
||||
val result = Parser.parseMove("h1f1")
|
||||
assertEquals(Some((Square(File.H, Rank.R1), Square(File.F, Rank.R1))), result)
|
||||
|
||||
// ── Special inputs ──────────────────────────────────────────────────────
|
||||
|
||||
@Test def rejectsQuitString(): Unit =
|
||||
assertEquals(None, Parser.parseMove("quit"))
|
||||
|
||||
@Test def rejectsQString(): Unit =
|
||||
assertEquals(None, Parser.parseMove("q"))
|
||||
|
||||
@Test def rejectsRandomText(): Unit =
|
||||
assertEquals(None, Parser.parseMove("hello"))
|
||||
assertEquals(None, Parser.parseMove("board"))
|
||||
|
||||
@Test def rejectsSpecialChars(): Unit =
|
||||
assertEquals(None, Parser.parseMove("e2-e4"))
|
||||
assertEquals(None, Parser.parseMove("e2xe4"))
|
||||
assertEquals(None, Parser.parseMove("e2/e4"))
|
||||
|
||||
// ── Very long strings ──────────────────────────────────────────────────
|
||||
|
||||
@Test def rejectsVeryLongInput(): Unit =
|
||||
val longString = "a" * 1000 + "1a1"
|
||||
assertEquals(None, Parser.parseMove(longString))
|
||||
|
||||
@Test def rejectsVeryLongOnlyAfterTrimming(): Unit =
|
||||
val longString = " " + ("a" * 1000)
|
||||
assertEquals(None, Parser.parseMove(longString))
|
||||
|
||||
// ── Exact length boundary ──────────────────────────────────────────────
|
||||
|
||||
@Test def acceptsExactlyFourCharacters(): Unit =
|
||||
val result = Parser.parseMove("a1b2")
|
||||
assertTrue(result.isDefined)
|
||||
|
||||
@Test def rejectsThreeCharacters(): Unit =
|
||||
val result = Parser.parseMove("a1b")
|
||||
assertEquals(None, result)
|
||||
|
||||
@Test def rejectsFiveCharacters(): Unit =
|
||||
val result = Parser.parseMove("a1b2c")
|
||||
assertEquals(None, result)
|
||||
|
||||
// ── Consistent parsing ────────────────────────────────────────────────
|
||||
|
||||
@Test def parsesSameMoveMultipleTimes(): Unit =
|
||||
val move = "e2e4"
|
||||
val result1 = Parser.parseMove(move)
|
||||
val result2 = Parser.parseMove(move)
|
||||
assertEquals(result1, result2)
|
||||
|
||||
@Test def parsesComprehensiveSquareSet(): Unit =
|
||||
val squares = for
|
||||
f <- 'a' to 'h'
|
||||
r <- '1' to '8'
|
||||
yield s"${f}${r}${f}${r}"
|
||||
|
||||
for move <- squares do
|
||||
val result = Parser.parseMove(move)
|
||||
assertTrue(result.isDefined, s"Should parse $move")
|
||||
@@ -1,330 +0,0 @@
|
||||
package de.nowchess.chess.logic
|
||||
|
||||
import de.nowchess.api.board.{Board, Color, File, Piece, PieceType, Rank, Square}
|
||||
import de.nowchess.chess.logic.MoveValidator
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.Assertions.*
|
||||
|
||||
class MoveValidatorExtendedTest:
|
||||
|
||||
private def sq(file: File, rank: Rank): Square = Square(file, rank)
|
||||
private def boardOf(pieces: (Square, Piece)*): Board = Board(pieces.toMap)
|
||||
|
||||
// ── Pawn edge cases ───────────────────────────────────────────────────
|
||||
|
||||
@Test def whitePawnCannotMoveTwoSquaresFromNonStartingRank(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R3) -> Piece.WhitePawn)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R3), sq(File.E, Rank.R5)))
|
||||
|
||||
@Test def blackPawnCannotMoveTwoSquaresFromNonStartingRank(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R6) -> Piece.BlackPawn)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R6), sq(File.E, Rank.R4)))
|
||||
|
||||
@Test def whitePawnBlockedByPieceBeforeDoubleMove(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R2) -> Piece.WhitePawn,
|
||||
sq(File.E, Rank.R3) -> Piece.BlackPawn
|
||||
)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R2), sq(File.E, Rank.R4)))
|
||||
|
||||
@Test def whitePawnBlockedByPieceAfterDoubleMove(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R2) -> Piece.WhitePawn,
|
||||
sq(File.E, Rank.R4) -> Piece.BlackPawn
|
||||
)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R2), sq(File.E, Rank.R4)))
|
||||
|
||||
@Test def blackPawnBlockedByPieceBeforeDoubleMove(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R7) -> Piece.BlackPawn,
|
||||
sq(File.E, Rank.R6) -> Piece.WhitePawn
|
||||
)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R7), sq(File.E, Rank.R5)))
|
||||
|
||||
@Test def blackPawnBlockedByPieceAfterDoubleMove(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R7) -> Piece.BlackPawn,
|
||||
sq(File.E, Rank.R5) -> Piece.WhitePawn
|
||||
)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R7), sq(File.E, Rank.R5)))
|
||||
|
||||
@Test def whitePawnForwardTwoAfterFirstMove(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R3) -> Piece.WhitePawn)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.D, Rank.R3), sq(File.D, Rank.R5)))
|
||||
|
||||
@Test def blackPawnBackwardIsIllegal(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R5) -> Piece.BlackPawn)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R5), sq(File.E, Rank.R6)))
|
||||
|
||||
@Test def whitePawnBackwardIsIllegal(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R5) -> Piece.WhitePawn)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R5), sq(File.E, Rank.R4)))
|
||||
|
||||
@Test def whitePawnSidewaysIsIllegal(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R4) -> Piece.WhitePawn)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R4), sq(File.D, Rank.R4)))
|
||||
|
||||
@Test def blackPawnSidewaysIsIllegal(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R5) -> Piece.BlackPawn)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R5), sq(File.F, Rank.R5)))
|
||||
|
||||
@Test def whitePawnDiagonalTwoSquaresIsIllegal(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R4) -> Piece.WhitePawn)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R4), sq(File.G, Rank.R6)))
|
||||
|
||||
@Test def whitePawnCapturesLeftDiagonal(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R4) -> Piece.WhitePawn,
|
||||
sq(File.D, Rank.R5) -> Piece.BlackPawn
|
||||
)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.E, Rank.R4), sq(File.D, Rank.R5)))
|
||||
|
||||
@Test def whitePawnCapturesRightDiagonal(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R4) -> Piece.WhitePawn,
|
||||
sq(File.F, Rank.R5) -> Piece.BlackPawn
|
||||
)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.E, Rank.R4), sq(File.F, Rank.R5)))
|
||||
|
||||
@Test def blackPawnCapturesLeftDiagonal(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R5) -> Piece.BlackPawn,
|
||||
sq(File.D, Rank.R4) -> Piece.WhitePawn
|
||||
)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.E, Rank.R5), sq(File.D, Rank.R4)))
|
||||
|
||||
@Test def blackPawnCapturesRightDiagonal(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R5) -> Piece.BlackPawn,
|
||||
sq(File.F, Rank.R4) -> Piece.WhitePawn
|
||||
)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.E, Rank.R5), sq(File.F, Rank.R4)))
|
||||
|
||||
// ── Knight comprehensive tests ──────────────────────────────────────────
|
||||
|
||||
@Test def knightCanMoveToAllEightSquares(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R4) -> Piece.WhiteKnight)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R4))
|
||||
val expected = Set(
|
||||
sq(File.C, Rank.R6), sq(File.E, Rank.R6),
|
||||
sq(File.B, Rank.R5), sq(File.F, Rank.R5),
|
||||
sq(File.B, Rank.R3), sq(File.F, Rank.R3),
|
||||
sq(File.C, Rank.R2), sq(File.E, Rank.R2)
|
||||
)
|
||||
assertEquals(expected, targets)
|
||||
|
||||
@Test def knightInCornerHasFewerMoves(): Unit =
|
||||
val board = boardOf(sq(File.A, Rank.R1) -> Piece.WhiteKnight)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.A, Rank.R1))
|
||||
assertEquals(2, targets.size)
|
||||
|
||||
@Test def knightNearEdgeHasFewerMoves(): Unit =
|
||||
val board = boardOf(sq(File.A, Rank.R4) -> Piece.WhiteKnight)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.A, Rank.R4))
|
||||
assertEquals(4, targets.size)
|
||||
|
||||
@Test def knightCanJumpAllAroundBoard(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.B, Rank.R1) -> Piece.WhiteKnight,
|
||||
sq(File.C, Rank.R3) -> Piece.BlackRook
|
||||
)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.B, Rank.R1), sq(File.C, Rank.R3)))
|
||||
|
||||
@Test def knightCannotMoveToNonLShapeSquare(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R4) -> Piece.WhiteKnight)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.D, Rank.R4), sq(File.D, Rank.R5)))
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.D, Rank.R4), sq(File.E, Rank.R4)))
|
||||
|
||||
@Test def knightAllTargetsExcludeOwnPieces(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.D, Rank.R4) -> Piece.WhiteKnight,
|
||||
sq(File.C, Rank.R6) -> Piece.WhitePawn,
|
||||
sq(File.E, Rank.R6) -> Piece.WhiteRook
|
||||
)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R4))
|
||||
assertFalse(targets.contains(sq(File.C, Rank.R6)))
|
||||
assertFalse(targets.contains(sq(File.E, Rank.R6)))
|
||||
|
||||
@Test def knightAllTargetsIncludeEnemyPieces(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.D, Rank.R4) -> Piece.WhiteKnight,
|
||||
sq(File.C, Rank.R6) -> Piece.BlackPawn,
|
||||
sq(File.E, Rank.R6) -> Piece.BlackRook
|
||||
)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R4))
|
||||
assertTrue(targets.contains(sq(File.C, Rank.R6)))
|
||||
assertTrue(targets.contains(sq(File.E, Rank.R6)))
|
||||
|
||||
// ── Bishop edge cases ──────────────────────────────────────────────────
|
||||
|
||||
@Test def bishopCannotMoveLikeRook(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R1) -> Piece.WhiteBishop)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.D, Rank.R1), sq(File.D, Rank.R8)))
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.D, Rank.R1), sq(File.H, Rank.R1)))
|
||||
|
||||
@Test def bishopAllDiagonalsBlocked(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.D, Rank.R4) -> Piece.WhiteBishop,
|
||||
sq(File.C, Rank.R5) -> Piece.WhitePawn,
|
||||
sq(File.E, Rank.R5) -> Piece.WhitePawn,
|
||||
sq(File.C, Rank.R3) -> Piece.WhitePawn,
|
||||
sq(File.E, Rank.R3) -> Piece.WhitePawn
|
||||
)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R4))
|
||||
assertEquals(0, targets.size)
|
||||
|
||||
@Test def bishopAllDiagonalsFree(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R4) -> Piece.WhiteBishop)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R4))
|
||||
assertTrue(targets.size > 0)
|
||||
// All targets should be on diagonals
|
||||
for target <- targets do
|
||||
val fileDiff = math.abs(target.file.ordinal - sq(File.D, Rank.R4).file.ordinal)
|
||||
val rankDiff = math.abs(target.rank.ordinal - sq(File.D, Rank.R4).rank.ordinal)
|
||||
assertEquals(fileDiff, rankDiff)
|
||||
|
||||
@Test def bishopCapturesMultiplePiecesButNotBeyond(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.C, Rank.R1) -> Piece.WhiteBishop,
|
||||
sq(File.E, Rank.R3) -> Piece.BlackRook,
|
||||
sq(File.F, Rank.R4) -> Piece.BlackBishop
|
||||
)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.C, Rank.R1))
|
||||
assertTrue(targets.contains(sq(File.E, Rank.R3)))
|
||||
assertFalse(targets.contains(sq(File.F, Rank.R4)))
|
||||
|
||||
// ── Rook edge cases ────────────────────────────────────────────────────
|
||||
|
||||
@Test def rookCannotMoveLikeBishop(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R1) -> Piece.WhiteRook)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.D, Rank.R1), sq(File.H, Rank.R5)))
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.D, Rank.R1), sq(File.A, Rank.R4)))
|
||||
|
||||
@Test def rookAllDirectionsBlocked(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.D, Rank.R4) -> Piece.WhiteRook,
|
||||
sq(File.D, Rank.R5) -> Piece.WhitePawn,
|
||||
sq(File.D, Rank.R3) -> Piece.WhitePawn,
|
||||
sq(File.C, Rank.R4) -> Piece.WhitePawn,
|
||||
sq(File.E, Rank.R4) -> Piece.WhitePawn
|
||||
)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R4))
|
||||
assertEquals(0, targets.size)
|
||||
|
||||
@Test def rookFullFileClear(): Unit =
|
||||
val board = boardOf(sq(File.A, Rank.R4) -> Piece.WhiteRook)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.A, Rank.R4))
|
||||
assertEquals(14, targets.size) // 7 squares up and down, 7 left and right, minus itself
|
||||
|
||||
@Test def rookFullRankClear(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R1) -> Piece.WhiteRook)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R1))
|
||||
assertEquals(14, targets.size)
|
||||
|
||||
@Test def rookStoppedByOwnPieceOnFile(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.D, Rank.R1) -> Piece.WhiteRook,
|
||||
sq(File.D, Rank.R4) -> Piece.WhitePawn
|
||||
)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R1))
|
||||
assertFalse(targets.contains(sq(File.D, Rank.R4)))
|
||||
assertFalse(targets.contains(sq(File.D, Rank.R8)))
|
||||
assertTrue(targets.contains(sq(File.D, Rank.R3)))
|
||||
|
||||
@Test def rookStoppedByOwnPieceOnRank(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.D, Rank.R1) -> Piece.WhiteRook,
|
||||
sq(File.F, Rank.R1) -> Piece.WhitePawn
|
||||
)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R1))
|
||||
assertFalse(targets.contains(sq(File.F, Rank.R1)))
|
||||
assertFalse(targets.contains(sq(File.H, Rank.R1)))
|
||||
assertTrue(targets.contains(sq(File.E, Rank.R1)))
|
||||
|
||||
// ── Queen comprehensive ────────────────────────────────────────────────
|
||||
|
||||
@Test def queenHasMoreMovesthanBishopOrRook(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.D, Rank.R4) -> Piece.WhiteQueen,
|
||||
sq(File.E, Rank.R4) -> Piece.BlackPawn
|
||||
)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R4))
|
||||
assertTrue(targets.size > 8) // Should have plenty of moves
|
||||
|
||||
@Test def queenBlockedByOwnPieceBothWays(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.D, Rank.R4) -> Piece.WhiteQueen,
|
||||
sq(File.D, Rank.R6) -> Piece.WhitePawn,
|
||||
sq(File.E, Rank.R5) -> Piece.WhitePawn
|
||||
)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R4))
|
||||
assertFalse(targets.contains(sq(File.D, Rank.R6)))
|
||||
assertFalse(targets.contains(sq(File.D, Rank.R8)))
|
||||
assertFalse(targets.contains(sq(File.E, Rank.R5)))
|
||||
assertFalse(targets.contains(sq(File.F, Rank.R6)))
|
||||
|
||||
@Test def queenCanCaptureButNotBeyond(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.D, Rank.R4) -> Piece.WhiteQueen,
|
||||
sq(File.D, Rank.R7) -> Piece.BlackPawn,
|
||||
sq(File.D, Rank.R8) -> Piece.BlackPawn
|
||||
)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R4))
|
||||
assertTrue(targets.contains(sq(File.D, Rank.R7)))
|
||||
assertFalse(targets.contains(sq(File.D, Rank.R8)))
|
||||
|
||||
// ── King comprehensive ────────────────────────────────────────────────
|
||||
|
||||
@Test def kingMovesOnlyOneSquare(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R4) -> Piece.WhiteKing)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R4))
|
||||
assertEquals(8, targets.size)
|
||||
|
||||
@Test def kingInCornerHasFewermoves(): Unit =
|
||||
val board = boardOf(sq(File.A, Rank.R1) -> Piece.WhiteKing)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.A, Rank.R1))
|
||||
assertEquals(3, targets.size)
|
||||
|
||||
@Test def kingEdgeHasFewerMoves(): Unit =
|
||||
val board = boardOf(sq(File.A, Rank.R4) -> Piece.WhiteKing)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.A, Rank.R4))
|
||||
assertEquals(5, targets.size)
|
||||
|
||||
@Test def kingCannotMoveMultipleSquares(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R4) -> Piece.WhiteKing)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.D, Rank.R4), sq(File.D, Rank.R6)))
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.D, Rank.R4), sq(File.F, Rank.R4)))
|
||||
|
||||
// ── legalTargets returns Set ──────────────────────────────────────────
|
||||
|
||||
@Test def legalTargetsReturnsSet(): Unit =
|
||||
val board = Board.initial
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.E, Rank.R2))
|
||||
assertTrue(targets.isInstanceOf[Set[?]])
|
||||
|
||||
@Test def legalTargetsForWhitePawnE2On32(): Unit =
|
||||
val targets = MoveValidator.legalTargets(Board.initial, sq(File.E, Rank.R2))
|
||||
assertEquals(2, targets.size) // Can move to e3 or e4
|
||||
|
||||
@Test def legalTargetsForWhiteKnightG1(): Unit =
|
||||
val targets = MoveValidator.legalTargets(Board.initial, sq(File.G, Rank.R1))
|
||||
assertEquals(2, targets.size) // Can move to f3 or h3
|
||||
|
||||
// ── isLegal returns consistent results ──────────────────────────────
|
||||
|
||||
@Test def isLegalConsistentWithLegalTargets(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R4) -> Piece.WhiteKnight)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R4))
|
||||
for target <- targets do
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.D, Rank.R4), target))
|
||||
|
||||
@Test def isLegalReturnsFalseForNonTargetSquares(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R4) -> Piece.WhiteKnight)
|
||||
val targets = MoveValidator.legalTargets(board, sq(File.D, Rank.R4))
|
||||
val allSquares = for
|
||||
file <- File.values
|
||||
rank <- Rank.values
|
||||
yield Square(file, rank)
|
||||
for square <- allSquares do
|
||||
if !targets.contains(square) then
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.D, Rank.R4), square))
|
||||
@@ -1,198 +0,0 @@
|
||||
package de.nowchess.chess.model
|
||||
|
||||
import de.nowchess.api.board.{Board, Color, File, Piece, PieceType, Rank, Square}
|
||||
import de.nowchess.chess.logic.MoveValidator
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.Assertions.*
|
||||
|
||||
class MoveValidatorTest:
|
||||
|
||||
// ── helpers ────────────────────────────────────────────────────────────────
|
||||
|
||||
private def sq(file: File, rank: Rank): Square = Square(file, rank)
|
||||
|
||||
/** Build a board with exactly the given pieces. */
|
||||
private def boardOf(pieces: (Square, Piece)*): Board =
|
||||
Board(pieces.toMap)
|
||||
|
||||
// ── Pawn ───────────────────────────────────────────────────────────────────
|
||||
|
||||
@Test def whitePawnForwardOneSquare(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.E, Rank.R2), sq(File.E, Rank.R3)))
|
||||
|
||||
@Test def whitePawnDoublePushFromStartingRank(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.E, Rank.R2), sq(File.E, Rank.R4)))
|
||||
|
||||
@Test def whitePawnBlockedDoublePush(): Unit =
|
||||
// Piece on e3 blocks the double push
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R2) -> Piece.WhitePawn,
|
||||
sq(File.E, Rank.R3) -> Piece.BlackPawn
|
||||
)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R2), sq(File.E, Rank.R4)))
|
||||
|
||||
@Test def whitePawnCannotPushForwardOntoOccupiedSquare(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R2) -> Piece.WhitePawn,
|
||||
sq(File.E, Rank.R3) -> Piece.BlackPawn
|
||||
)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R2), sq(File.E, Rank.R3)))
|
||||
|
||||
@Test def whitePawnDiagonalCaptureEnemy(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R4) -> Piece.WhitePawn,
|
||||
sq(File.D, Rank.R5) -> Piece.BlackPawn
|
||||
)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.E, Rank.R4), sq(File.D, Rank.R5)))
|
||||
|
||||
@Test def whitePawnCannotCaptureDiagonallyWithoutEnemy(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R4) -> Piece.WhitePawn)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R4), sq(File.D, Rank.R5)))
|
||||
|
||||
@Test def whitePawnCannotCaptureDiagonalOwnPiece(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R4) -> Piece.WhitePawn,
|
||||
sq(File.D, Rank.R5) -> Piece.WhiteKnight
|
||||
)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R4), sq(File.D, Rank.R5)))
|
||||
|
||||
@Test def blackPawnForwardOneSquare(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R7) -> Piece.BlackPawn)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.E, Rank.R7), sq(File.E, Rank.R6)))
|
||||
|
||||
@Test def blackPawnDoublePushFromStartingRank(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R7) -> Piece.BlackPawn)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.E, Rank.R7), sq(File.E, Rank.R5)))
|
||||
|
||||
// ── Knight ─────────────────────────────────────────────────────────────────
|
||||
|
||||
@Test def knightValidLShape(): Unit =
|
||||
val board = boardOf(sq(File.G, Rank.R1) -> Piece.WhiteKnight)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.G, Rank.R1), sq(File.F, Rank.R3)))
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.G, Rank.R1), sq(File.H, Rank.R3)))
|
||||
|
||||
@Test def knightJumpsOverPieces(): Unit =
|
||||
// Surround the knight with own pieces — it should still reach its L-targets
|
||||
val board = boardOf(
|
||||
sq(File.G, Rank.R1) -> Piece.WhiteKnight,
|
||||
sq(File.G, Rank.R2) -> Piece.WhitePawn,
|
||||
sq(File.F, Rank.R1) -> Piece.WhitePawn,
|
||||
sq(File.H, Rank.R1) -> Piece.WhitePawn,
|
||||
sq(File.F, Rank.R2) -> Piece.WhitePawn,
|
||||
sq(File.H, Rank.R2) -> Piece.WhitePawn
|
||||
)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.G, Rank.R1), sq(File.F, Rank.R3)))
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.G, Rank.R1), sq(File.H, Rank.R3)))
|
||||
|
||||
@Test def knightCannotLandOnOwnPiece(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.G, Rank.R1) -> Piece.WhiteKnight,
|
||||
sq(File.F, Rank.R3) -> Piece.WhitePawn
|
||||
)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.G, Rank.R1), sq(File.F, Rank.R3)))
|
||||
|
||||
@Test def knightCanCaptureEnemy(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.G, Rank.R1) -> Piece.WhiteKnight,
|
||||
sq(File.F, Rank.R3) -> Piece.BlackPawn
|
||||
)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.G, Rank.R1), sq(File.F, Rank.R3)))
|
||||
|
||||
// ── Bishop ─────────────────────────────────────────────────────────────────
|
||||
|
||||
@Test def bishopDiagonalSlide(): Unit =
|
||||
val board = boardOf(sq(File.C, Rank.R1) -> Piece.WhiteBishop)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.C, Rank.R1), sq(File.F, Rank.R4)))
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.C, Rank.R1), sq(File.A, Rank.R3)))
|
||||
|
||||
@Test def bishopBlockedByOwnPiece(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.C, Rank.R1) -> Piece.WhiteBishop,
|
||||
sq(File.E, Rank.R3) -> Piece.WhitePawn
|
||||
)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.C, Rank.R1), sq(File.F, Rank.R4)))
|
||||
|
||||
@Test def bishopCapturesFirstEnemy(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.C, Rank.R1) -> Piece.WhiteBishop,
|
||||
sq(File.E, Rank.R3) -> Piece.BlackPawn
|
||||
)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.C, Rank.R1), sq(File.E, Rank.R3)))
|
||||
// Cannot reach beyond the captured piece
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.C, Rank.R1), sq(File.F, Rank.R4)))
|
||||
|
||||
// ── Rook ───────────────────────────────────────────────────────────────────
|
||||
|
||||
@Test def rookOrthogonalSlide(): Unit =
|
||||
val board = boardOf(sq(File.A, Rank.R1) -> Piece.WhiteRook)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.A, Rank.R1), sq(File.A, Rank.R8)))
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.A, Rank.R1), sq(File.H, Rank.R1)))
|
||||
|
||||
@Test def rookBlockedByOwnPiece(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.A, Rank.R1) -> Piece.WhiteRook,
|
||||
sq(File.A, Rank.R4) -> Piece.WhitePawn
|
||||
)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.A, Rank.R1), sq(File.A, Rank.R8)))
|
||||
// Can still reach squares before the blocker
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.A, Rank.R1), sq(File.A, Rank.R3)))
|
||||
|
||||
@Test def rookCapturesFirstEnemy(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.A, Rank.R1) -> Piece.WhiteRook,
|
||||
sq(File.A, Rank.R4) -> Piece.BlackPawn
|
||||
)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.A, Rank.R1), sq(File.A, Rank.R4)))
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.A, Rank.R1), sq(File.A, Rank.R8)))
|
||||
|
||||
// ── Queen ──────────────────────────────────────────────────────────────────
|
||||
|
||||
@Test def queenCombinesRookAndBishop(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R4) -> Piece.WhiteQueen)
|
||||
// Orthogonal
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.D, Rank.R4), sq(File.D, Rank.R8)))
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.D, Rank.R4), sq(File.H, Rank.R4)))
|
||||
// Diagonal
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.D, Rank.R4), sq(File.G, Rank.R7)))
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.D, Rank.R4), sq(File.A, Rank.R1)))
|
||||
|
||||
@Test def queenBlockedByOwnPiece(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.D, Rank.R4) -> Piece.WhiteQueen,
|
||||
sq(File.D, Rank.R6) -> Piece.WhitePawn
|
||||
)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.D, Rank.R4), sq(File.D, Rank.R8)))
|
||||
|
||||
// ── King ───────────────────────────────────────────────────────────────────
|
||||
|
||||
@Test def kingMovesOneSquareInEachDirection(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R4) -> Piece.WhiteKing)
|
||||
val expected = Set(
|
||||
sq(File.E, Rank.R5), sq(File.E, Rank.R3),
|
||||
sq(File.D, Rank.R4), sq(File.F, Rank.R4),
|
||||
sq(File.D, Rank.R5), sq(File.F, Rank.R5),
|
||||
sq(File.D, Rank.R3), sq(File.F, Rank.R3)
|
||||
)
|
||||
assertEquals(expected, MoveValidator.legalTargets(board, sq(File.E, Rank.R4)))
|
||||
|
||||
@Test def kingCannotLandOnOwnPiece(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R1) -> Piece.WhiteKing,
|
||||
sq(File.E, Rank.R2) -> Piece.WhitePawn
|
||||
)
|
||||
assertFalse(MoveValidator.isLegal(board, sq(File.E, Rank.R1), sq(File.E, Rank.R2)))
|
||||
|
||||
@Test def kingCanCaptureEnemy(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R1) -> Piece.WhiteKing,
|
||||
sq(File.E, Rank.R2) -> Piece.BlackPawn
|
||||
)
|
||||
assertTrue(MoveValidator.isLegal(board, sq(File.E, Rank.R1), sq(File.E, Rank.R2)))
|
||||
|
||||
// ── Empty square ───────────────────────────────────────────────────────────
|
||||
|
||||
@Test def noLegalTargetsForEmptySquare(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R4) -> Piece.WhitePawn)
|
||||
assertEquals(Set.empty, MoveValidator.legalTargets(board, sq(File.A, Rank.R1)))
|
||||
@@ -1,115 +0,0 @@
|
||||
package de.nowchess.chess.view
|
||||
|
||||
import de.nowchess.api.board.{Color, Piece, PieceType}
|
||||
import de.nowchess.chess.view.unicode
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.Assertions.*
|
||||
|
||||
class PieceUnicodeTest:
|
||||
|
||||
// ── White pieces ───────────────────────────────────────────────────────
|
||||
|
||||
@Test def whiteKingUnicode(): Unit =
|
||||
val piece = Piece(Color.White, PieceType.King)
|
||||
assertEquals("\u2654", piece.unicode)
|
||||
|
||||
@Test def whiteQueenUnicode(): Unit =
|
||||
val piece = Piece(Color.White, PieceType.Queen)
|
||||
assertEquals("\u2655", piece.unicode)
|
||||
|
||||
@Test def whiteRookUnicode(): Unit =
|
||||
val piece = Piece(Color.White, PieceType.Rook)
|
||||
assertEquals("\u2656", piece.unicode)
|
||||
|
||||
@Test def whiteBishopUnicode(): Unit =
|
||||
val piece = Piece(Color.White, PieceType.Bishop)
|
||||
assertEquals("\u2657", piece.unicode)
|
||||
|
||||
@Test def whiteKnightUnicode(): Unit =
|
||||
val piece = Piece(Color.White, PieceType.Knight)
|
||||
assertEquals("\u2658", piece.unicode)
|
||||
|
||||
@Test def whitePawnUnicode(): Unit =
|
||||
val piece = Piece(Color.White, PieceType.Pawn)
|
||||
assertEquals("\u2659", piece.unicode)
|
||||
|
||||
// ── Black pieces ───────────────────────────────────────────────────────
|
||||
|
||||
@Test def blackKingUnicode(): Unit =
|
||||
val piece = Piece(Color.Black, PieceType.King)
|
||||
assertEquals("\u265A", piece.unicode)
|
||||
|
||||
@Test def blackQueenUnicode(): Unit =
|
||||
val piece = Piece(Color.Black, PieceType.Queen)
|
||||
assertEquals("\u265B", piece.unicode)
|
||||
|
||||
@Test def blackRookUnicode(): Unit =
|
||||
val piece = Piece(Color.Black, PieceType.Rook)
|
||||
assertEquals("\u265C", piece.unicode)
|
||||
|
||||
@Test def blackBishopUnicode(): Unit =
|
||||
val piece = Piece(Color.Black, PieceType.Bishop)
|
||||
assertEquals("\u265D", piece.unicode)
|
||||
|
||||
@Test def blackKnightUnicode(): Unit =
|
||||
val piece = Piece(Color.Black, PieceType.Knight)
|
||||
assertEquals("\u265E", piece.unicode)
|
||||
|
||||
@Test def blackPawnUnicode(): Unit =
|
||||
val piece = Piece(Color.Black, PieceType.Pawn)
|
||||
assertEquals("\u265F", piece.unicode)
|
||||
|
||||
// ── Unicode lengths ───────────────────────────────────────────────────
|
||||
|
||||
@Test def eachUnicodeCharacterIsNonEmpty(): Unit =
|
||||
val pieces = Seq(
|
||||
Piece.WhiteKing, Piece.WhiteQueen, Piece.WhiteRook,
|
||||
Piece.WhiteBishop, Piece.WhiteKnight, Piece.WhitePawn,
|
||||
Piece.BlackKing, Piece.BlackQueen, Piece.BlackRook,
|
||||
Piece.BlackBishop, Piece.BlackKnight, Piece.BlackPawn
|
||||
)
|
||||
for piece <- pieces do
|
||||
assertFalse(piece.unicode.isEmpty)
|
||||
|
||||
@Test def unicodeCharactersAreDistinct(): Unit =
|
||||
val unicodes = Set(
|
||||
Piece.WhiteKing.unicode, Piece.WhiteQueen.unicode, Piece.WhiteRook.unicode,
|
||||
Piece.WhiteBishop.unicode, Piece.WhiteKnight.unicode, Piece.WhitePawn.unicode,
|
||||
Piece.BlackKing.unicode, Piece.BlackQueen.unicode, Piece.BlackRook.unicode,
|
||||
Piece.BlackBishop.unicode, Piece.BlackKnight.unicode, Piece.BlackPawn.unicode
|
||||
)
|
||||
assertEquals(12, unicodes.size)
|
||||
|
||||
// ── Convenience constructors ───────────────────────────────────────────
|
||||
|
||||
@Test def pieceConvenienceConstructorsReturnCorrectUnicode(): Unit =
|
||||
assertEquals("\u2654", Piece.WhiteKing.unicode)
|
||||
assertEquals("\u2655", Piece.WhiteQueen.unicode)
|
||||
assertEquals("\u2656", Piece.WhiteRook.unicode)
|
||||
assertEquals("\u2657", Piece.WhiteBishop.unicode)
|
||||
assertEquals("\u2658", Piece.WhiteKnight.unicode)
|
||||
assertEquals("\u2659", Piece.WhitePawn.unicode)
|
||||
assertEquals("\u265A", Piece.BlackKing.unicode)
|
||||
assertEquals("\u265B", Piece.BlackQueen.unicode)
|
||||
assertEquals("\u265C", Piece.BlackRook.unicode)
|
||||
assertEquals("\u265D", Piece.BlackBishop.unicode)
|
||||
assertEquals("\u265E", Piece.BlackKnight.unicode)
|
||||
assertEquals("\u265F", Piece.BlackPawn.unicode)
|
||||
|
||||
// ── Unicode roundtrip ──────────────────────────────────────────────────
|
||||
|
||||
@Test def createPieceAndGetUnicodeConsistently(): Unit =
|
||||
val whiteKing = Piece(Color.White, PieceType.King)
|
||||
val unicode1 = whiteKing.unicode
|
||||
val unicode2 = whiteKing.unicode
|
||||
assertEquals(unicode1, unicode2)
|
||||
|
||||
@Test def differentPiecesHaveDifferentUnicodes(): Unit =
|
||||
val king = Piece.WhiteKing
|
||||
val queen = Piece.WhiteQueen
|
||||
assertNotEquals(king.unicode, queen.unicode)
|
||||
|
||||
@Test def sameTypeDifferentColorHaveDifferentUnicodes(): Unit =
|
||||
val whitePawn = Piece.WhitePawn
|
||||
val blackPawn = Piece.BlackPawn
|
||||
assertNotEquals(whitePawn.unicode, blackPawn.unicode)
|
||||
@@ -1,187 +0,0 @@
|
||||
package de.nowchess.chess.view
|
||||
|
||||
import de.nowchess.api.board.{Board, Color, File, Piece, PieceType, Rank, Square}
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.Assertions.*
|
||||
|
||||
class RendererExtendedTest:
|
||||
|
||||
private def boardOf(pieces: (Square, Piece)*): Board = Board(pieces.toMap)
|
||||
private def sq(file: File, rank: Rank): Square = Square(file, rank)
|
||||
|
||||
// ── Empty board ────────────────────────────────────────────────────────
|
||||
|
||||
@Test def renderEmptyBoardContainsBoardFrame(): Unit =
|
||||
val emptyBoard = boardOf()
|
||||
val output = Renderer.render(emptyBoard)
|
||||
assertTrue(output.contains("a"), "Should contain file 'a'")
|
||||
assertTrue(output.contains("h"), "Should contain file 'h'")
|
||||
assertTrue(output.contains("1"), "Should contain rank '1'")
|
||||
assertTrue(output.contains("8"), "Should contain rank '8'")
|
||||
|
||||
@Test def renderEmptyBoardIsNotEmpty(): Unit =
|
||||
val emptyBoard = boardOf()
|
||||
val output = Renderer.render(emptyBoard)
|
||||
assertTrue(output.nonEmpty)
|
||||
|
||||
@Test def renderEmptyBoardContainsAnsiColors(): Unit =
|
||||
val emptyBoard = boardOf()
|
||||
val output = Renderer.render(emptyBoard)
|
||||
assertTrue(output.contains("\u001b[48;5;223m") || output.contains("\u001b[48;5;130m"))
|
||||
|
||||
// ── Single piece placement ─────────────────────────────────────────────
|
||||
|
||||
@Test def renderBoardWithSingleWhitePawn(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R2) -> Piece.WhitePawn)
|
||||
val output = Renderer.render(board)
|
||||
assertTrue(output.contains("\u2659"), "Should contain white pawn unicode")
|
||||
|
||||
@Test def renderBoardWithSingleBlackKing(): Unit =
|
||||
val board = boardOf(sq(File.E, Rank.R8) -> Piece.BlackKing)
|
||||
val output = Renderer.render(board)
|
||||
assertTrue(output.contains("\u265A"), "Should contain black king unicode")
|
||||
|
||||
@Test def renderBoardWithMultiplePieces(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R1) -> Piece.WhiteKing,
|
||||
sq(File.D, Rank.R8) -> Piece.BlackQueen,
|
||||
sq(File.A, Rank.R1) -> Piece.WhiteRook
|
||||
)
|
||||
val output = Renderer.render(board)
|
||||
assertTrue(output.contains("\u2654")) // white king
|
||||
assertTrue(output.contains("\u265B")) // black queen
|
||||
assertTrue(output.contains("\u2656")) // white rook
|
||||
|
||||
// ── All pieces on board ────────────────────────────────────────────────
|
||||
|
||||
@Test def renderInitialBoardHasAllPieceTypes(): Unit =
|
||||
val output = Renderer.render(Board.initial)
|
||||
// White pieces
|
||||
assertTrue(output.contains("\u2654"), "white king")
|
||||
assertTrue(output.contains("\u2655"), "white queen")
|
||||
assertTrue(output.contains("\u2656"), "white rook")
|
||||
assertTrue(output.contains("\u2657"), "white bishop")
|
||||
assertTrue(output.contains("\u2658"), "white knight")
|
||||
assertTrue(output.contains("\u2659"), "white pawn")
|
||||
// Black pieces
|
||||
assertTrue(output.contains("\u265A"), "black king")
|
||||
assertTrue(output.contains("\u265B"), "black queen")
|
||||
assertTrue(output.contains("\u265C"), "black rook")
|
||||
assertTrue(output.contains("\u265D"), "black bishop")
|
||||
assertTrue(output.contains("\u265E"), "black knight")
|
||||
assertTrue(output.contains("\u265F"), "black pawn")
|
||||
|
||||
// ── Board dimensions ──────────────────────────────────────────────────
|
||||
|
||||
@Test def renderIncludesAllFileLabels(): Unit =
|
||||
val output = Renderer.render(Board.initial)
|
||||
for file <- Seq("a", "b", "c", "d", "e", "f", "g", "h") do
|
||||
assertTrue(output.contains(file))
|
||||
|
||||
@Test def renderIncludesAllRankLabels(): Unit =
|
||||
val output = Renderer.render(Board.initial)
|
||||
for rank <- 1 to 8 do
|
||||
assertTrue(output.contains(rank.toString))
|
||||
|
||||
// ── Piece placement accuracy ───────────────────────────────────────────
|
||||
|
||||
@Test def renderCornerPiecesAreIncluded(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.A, Rank.R1) -> Piece.WhiteRook,
|
||||
sq(File.H, Rank.R1) -> Piece.WhiteRook,
|
||||
sq(File.A, Rank.R8) -> Piece.BlackRook,
|
||||
sq(File.H, Rank.R8) -> Piece.BlackRook
|
||||
)
|
||||
val output = Renderer.render(board)
|
||||
val rookCount = output.count(_ == '\u2656') + output.count(_ == '\u265C')
|
||||
assertEquals(4, rookCount)
|
||||
|
||||
// ── ANSI codes ─────────────────────────────────────────────────────────
|
||||
|
||||
@Test def renderContainsResetCode(): Unit =
|
||||
val output = Renderer.render(Board.initial)
|
||||
assertTrue(output.contains("\u001b[0m"))
|
||||
|
||||
@Test def renderContainsBackgroundColors(): Unit =
|
||||
val output = Renderer.render(Board.initial)
|
||||
assertTrue(output.contains("\u001b[48;5;223m") || output.contains("\u001b[48;5;130m"))
|
||||
|
||||
@Test def renderContainsForegroundColors(): Unit =
|
||||
val board = Board.initial
|
||||
val output = Renderer.render(board)
|
||||
// Should have some white text or black text for pieces
|
||||
assertTrue(output.contains("\u001b[97m") || output.contains("\u001b[30m"))
|
||||
|
||||
// ── Output consistency ─────────────────────────────────────────────────
|
||||
|
||||
@Test def renderingSameBoardProducesSameOutput(): Unit =
|
||||
val board = Board.initial
|
||||
val output1 = Renderer.render(board)
|
||||
val output2 = Renderer.render(board)
|
||||
assertEquals(output1, output2)
|
||||
|
||||
@Test def renderingDifferentBoardsProduceDifferentOutput(): Unit =
|
||||
val board1 = Board.initial
|
||||
val board2 = boardOf(sq(File.E, Rank.R4) -> Piece.WhitePawn)
|
||||
val output1 = Renderer.render(board1)
|
||||
val output2 = Renderer.render(board2)
|
||||
assertNotEquals(output1, output2)
|
||||
|
||||
// ── Large outputs ──────────────────────────────────────────────────────
|
||||
|
||||
@Test def renderInitialBoardProducesReasonablyLargeOutput(): Unit =
|
||||
val output = Renderer.render(Board.initial)
|
||||
// Should have multiple lines (8 ranks + labels)
|
||||
val lineCount = output.count(_ == '\n')
|
||||
assertTrue(lineCount > 8)
|
||||
|
||||
@Test def renderOutputContainsNewlines(): Unit =
|
||||
val output = Renderer.render(Board.initial)
|
||||
assertTrue(output.contains("\n"))
|
||||
|
||||
// ── Piece color in output ──────────────────────────────────────────────
|
||||
|
||||
@Test def renderBoardWithWhiteAndBlackPieces(): Unit =
|
||||
val board = boardOf(
|
||||
sq(File.E, Rank.R1) -> Piece.WhiteKing,
|
||||
sq(File.E, Rank.R8) -> Piece.BlackKing
|
||||
)
|
||||
val output = Renderer.render(board)
|
||||
assertTrue(output.contains("\u2654")) // white king
|
||||
assertTrue(output.contains("\u265A")) // black king
|
||||
|
||||
// ── Pawn positions ────────────────────────────────────────────────────
|
||||
|
||||
@Test def renderBoardWithAllWhitePawns(): Unit =
|
||||
val pawns = (0 until 8).map(fileIdx =>
|
||||
sq(File.values(fileIdx), Rank.R2) -> Piece.WhitePawn
|
||||
)
|
||||
val board = boardOf(pawns*)
|
||||
val output = Renderer.render(board)
|
||||
val pawnCount = output.count(_ == '\u2659')
|
||||
assertEquals(8, pawnCount)
|
||||
|
||||
@Test def renderBoardWithAllBlackPawns(): Unit =
|
||||
val pawns = (0 until 8).map(fileIdx =>
|
||||
sq(File.values(fileIdx), Rank.R7) -> Piece.BlackPawn
|
||||
)
|
||||
val board = boardOf(pawns*)
|
||||
val output = Renderer.render(board)
|
||||
val pawnCount = output.count(_ == '\u265F')
|
||||
assertEquals(8, pawnCount)
|
||||
|
||||
// ── Center of board ───────────────────────────────────────────────────
|
||||
|
||||
@Test def renderBoardWithCenterPiece(): Unit =
|
||||
val board = boardOf(sq(File.D, Rank.R4) -> Piece.WhiteQueen)
|
||||
val output = Renderer.render(board)
|
||||
assertTrue(output.contains("\u2655"))
|
||||
|
||||
// ── Board doesn't mutate ──────────────────────────────────────────────
|
||||
|
||||
@Test def renderingBoardDoesNotMutateIt(): Unit =
|
||||
val board = Board.initial
|
||||
val pieceBefore = board.pieceAt(sq(File.E, Rank.R1))
|
||||
val _ = Renderer.render(board)
|
||||
val pieceAfter = board.pieceAt(sq(File.E, Rank.R1))
|
||||
assertEquals(pieceBefore, pieceAfter)
|
||||
Reference in New Issue
Block a user