refactor(core): integrate Rule module and update GameContext handling
This commit is contained in:
@@ -6,9 +6,9 @@ import de.nowchess.api.game.GameContext
|
||||
import de.nowchess.chess.controller.Parser
|
||||
import de.nowchess.chess.observer.*
|
||||
import de.nowchess.chess.command.{CommandInvoker, MoveCommand, MoveResult}
|
||||
import de.nowchess.chess.notation.{PgnExporter, PgnParser}
|
||||
import de.nowchess.io.pgn.PgnParser
|
||||
import de.nowchess.rules.RuleSet
|
||||
import de.nowchess.rules.sets.StandardRules
|
||||
import de.nowchess.rules.sets.DefaultRules
|
||||
|
||||
/** Pure game engine that manages game state and notifies observers of state changes.
|
||||
* All rule queries delegate to the injected RuleSet.
|
||||
@@ -16,7 +16,7 @@ import de.nowchess.rules.sets.StandardRules
|
||||
*/
|
||||
class GameEngine(
|
||||
initialContext: GameContext = GameContext.initial,
|
||||
ruleSet: RuleSet = StandardRules
|
||||
ruleSet: RuleSet = DefaultRules
|
||||
) extends Observable:
|
||||
private var currentContext: GameContext = initialContext
|
||||
private val invoker = new CommandInvoker()
|
||||
@@ -146,25 +146,16 @@ class GameEngine(
|
||||
invoker.clear()
|
||||
|
||||
var error: Option[String] = None
|
||||
import scala.util.control.Breaks._
|
||||
breakable {
|
||||
game.moves.foreach { histMove =>
|
||||
handleParsedMove(histMove.from, histMove.to)
|
||||
histMove.promotionPiece.foreach(completePromotion)
|
||||
// $COVERAGE-OFF$ unreachable: PgnParser.validatePgn ensures promotion annotation is present
|
||||
game.moves.foreach: histMove =>
|
||||
handleParsedMove(histMove.from, histMove.to)
|
||||
histMove.promotionPiece.foreach(completePromotion)
|
||||
if pendingPromotion.isDefined && histMove.promotionPiece.isEmpty then
|
||||
error = Some(s"Promotion required for move ${histMove.from}${histMove.to}")
|
||||
break()
|
||||
// $COVERAGE-ON$
|
||||
}
|
||||
}
|
||||
error = Some(s"Promotion required for move ${histMove.from}${histMove.to}")
|
||||
|
||||
error match
|
||||
// $COVERAGE-OFF$ unreachable: error is only set in the unreachable block above
|
||||
case Some(err) =>
|
||||
currentContext = savedContext
|
||||
Left(err)
|
||||
// $COVERAGE-ON$
|
||||
case None =>
|
||||
notifyObservers(PgnLoadedEvent(currentContext))
|
||||
Right(())
|
||||
|
||||
@@ -1,60 +0,0 @@
|
||||
package de.nowchess.chess.notation
|
||||
|
||||
import de.nowchess.api.board.*
|
||||
import de.nowchess.api.game.GameContext
|
||||
|
||||
object FenExporter:
|
||||
|
||||
/** Convert a Board to FEN piece-placement string (rank 8 to rank 1, separated by '/'). */
|
||||
def boardToFen(board: Board): String =
|
||||
Rank.values.reverse
|
||||
.map(rank => buildRankString(board, rank))
|
||||
.mkString("/")
|
||||
|
||||
/** Build the FEN representation for a single rank. */
|
||||
private def buildRankString(board: Board, rank: Rank): String =
|
||||
val rankSquares = File.values.map(file => Square(file, rank))
|
||||
val rankChars = scala.collection.mutable.ListBuffer[Char]()
|
||||
var emptyCount = 0
|
||||
|
||||
for square <- rankSquares do
|
||||
board.pieceAt(square) match
|
||||
case Some(piece) =>
|
||||
if emptyCount > 0 then
|
||||
rankChars += emptyCount.toString.charAt(0)
|
||||
emptyCount = 0
|
||||
rankChars += pieceToPgnChar(piece)
|
||||
case None =>
|
||||
emptyCount += 1
|
||||
|
||||
if emptyCount > 0 then rankChars += emptyCount.toString.charAt(0)
|
||||
rankChars.mkString
|
||||
|
||||
/** Convert a GameContext to a complete FEN string. */
|
||||
def gameContextToFen(context: GameContext): String =
|
||||
val piecePlacement = boardToFen(context.board)
|
||||
val activeColor = if context.turn == Color.White then "w" else "b"
|
||||
val castling = castlingString(context.castlingRights)
|
||||
val enPassant = context.enPassantSquare.map(_.toString).getOrElse("-")
|
||||
val fullMoveNumber = 1 + (context.moves.length / 2)
|
||||
s"$piecePlacement $activeColor $castling $enPassant ${context.halfMoveClock} $fullMoveNumber"
|
||||
|
||||
/** Convert castling rights to FEN notation. */
|
||||
private def castlingString(rights: CastlingRights): String =
|
||||
val wk = if rights.whiteKingSide then "K" else ""
|
||||
val wq = if rights.whiteQueenSide then "Q" else ""
|
||||
val bk = if rights.blackKingSide then "k" else ""
|
||||
val bq = if rights.blackQueenSide then "q" else ""
|
||||
val result = s"$wk$wq$bk$bq"
|
||||
if result.isEmpty then "-" else result
|
||||
|
||||
/** Convert a Piece to its FEN character (uppercase = White, lowercase = Black). */
|
||||
private def pieceToPgnChar(piece: Piece): Char =
|
||||
val base = piece.pieceType match
|
||||
case PieceType.Pawn => 'p'
|
||||
case PieceType.Knight => 'n'
|
||||
case PieceType.Bishop => 'b'
|
||||
case PieceType.Rook => 'r'
|
||||
case PieceType.Queen => 'q'
|
||||
case PieceType.King => 'k'
|
||||
if piece.color == Color.White then base.toUpper else base
|
||||
@@ -1,104 +0,0 @@
|
||||
package de.nowchess.chess.notation
|
||||
|
||||
import de.nowchess.api.board.*
|
||||
import de.nowchess.api.game.GameContext
|
||||
|
||||
object FenParser:
|
||||
|
||||
/** Parse a complete FEN string into a GameContext.
|
||||
* Returns None if the format is invalid. */
|
||||
def parseFen(fen: String): Option[GameContext] =
|
||||
val parts = fen.trim.split("\\s+")
|
||||
Option.when(parts.length == 6)(parts).flatMap: parts =>
|
||||
for
|
||||
board <- parseBoard(parts(0))
|
||||
activeColor <- parseColor(parts(1))
|
||||
castlingRights <- parseCastling(parts(2))
|
||||
enPassant <- parseEnPassant(parts(3))
|
||||
halfMoveClock <- parts(4).toIntOption
|
||||
fullMoveNumber <- parts(5).toIntOption
|
||||
if halfMoveClock >= 0 && fullMoveNumber >= 1
|
||||
yield GameContext(
|
||||
board = board,
|
||||
turn = activeColor,
|
||||
castlingRights = castlingRights,
|
||||
enPassantSquare = enPassant,
|
||||
halfMoveClock = halfMoveClock,
|
||||
moves = List.empty
|
||||
)
|
||||
|
||||
/** Parse active color ("w" or "b"). */
|
||||
private def parseColor(s: String): Option[Color] =
|
||||
if s == "w" then Some(Color.White)
|
||||
else if s == "b" then Some(Color.Black)
|
||||
else None
|
||||
|
||||
/** Parse castling rights string (e.g. "KQkq", "K", "-") into unified castling rights. */
|
||||
private def parseCastling(s: String): Option[CastlingRights] =
|
||||
if s == "-" then
|
||||
Some(CastlingRights.None)
|
||||
else if s.length <= 4 && s.forall(c => "KQkq".contains(c)) then
|
||||
Some(CastlingRights(
|
||||
whiteKingSide = s.contains('K'),
|
||||
whiteQueenSide = s.contains('Q'),
|
||||
blackKingSide = s.contains('k'),
|
||||
blackQueenSide = s.contains('q')
|
||||
))
|
||||
else
|
||||
None
|
||||
|
||||
/** Parse en passant target square ("-" for none, or algebraic like "e3"). */
|
||||
private def parseEnPassant(s: String): Option[Option[Square]] =
|
||||
if s == "-" then Some(None)
|
||||
else Square.fromAlgebraic(s).map(Some(_))
|
||||
|
||||
/** Parses a FEN piece-placement string (rank 8 to rank 1, separated by '/') into a Board.
|
||||
* Returns None if the format is invalid. */
|
||||
def parseBoard(fen: String): Option[Board] =
|
||||
val rankStrings = fen.split("/", -1)
|
||||
if rankStrings.length != 8 then None
|
||||
else
|
||||
// Parse each rank, collecting all (Square, Piece) pairs or failing on the first error
|
||||
val parsedRanks: Option[List[List[(Square, Piece)]]] =
|
||||
rankStrings.zipWithIndex.foldLeft(Option(List.empty[List[(Square, Piece)]])):
|
||||
case (None, _) => None
|
||||
case (Some(acc), (rankStr, rankIdx)) =>
|
||||
val rank = Rank.values(7 - rankIdx) // ranks go 8→1, so reverse
|
||||
parsePieceRank(rankStr, rank).map(squares => acc :+ squares)
|
||||
parsedRanks.map(ranks => Board(ranks.flatten.toMap))
|
||||
|
||||
/** Parse a single rank string (e.g. "rnbqkbnr" or "p3p3") into a list of (Square, Piece) pairs.
|
||||
* Returns None if the rank string contains invalid characters or the wrong number of files. */
|
||||
private def parsePieceRank(rankStr: String, rank: Rank): Option[List[(Square, Piece)]] =
|
||||
var fileIdx = 0
|
||||
val squares = scala.collection.mutable.ListBuffer[(Square, Piece)]()
|
||||
var failed = false
|
||||
|
||||
for c <- rankStr if !failed do
|
||||
if fileIdx > 7 then
|
||||
failed = true
|
||||
else if c.isDigit then
|
||||
fileIdx += c.asDigit
|
||||
else
|
||||
charToPiece(c) match
|
||||
case None => failed = true
|
||||
case Some(piece) =>
|
||||
val file = File.values(fileIdx)
|
||||
squares += (Square(file, rank) -> piece)
|
||||
fileIdx += 1
|
||||
|
||||
if failed || fileIdx != 8 then None
|
||||
else Some(squares.toList)
|
||||
|
||||
/** Convert a FEN piece character to a Piece. Uppercase = White, lowercase = Black. */
|
||||
private def charToPiece(c: Char): Option[Piece] =
|
||||
val color = if Character.isUpperCase(c) then Color.White else Color.Black
|
||||
val pieceTypeOpt = c.toLower match
|
||||
case 'p' => Some(PieceType.Pawn)
|
||||
case 'n' => Some(PieceType.Knight)
|
||||
case 'b' => Some(PieceType.Bishop)
|
||||
case 'r' => Some(PieceType.Rook)
|
||||
case 'q' => Some(PieceType.Queen)
|
||||
case 'k' => Some(PieceType.King)
|
||||
case _ => None
|
||||
pieceTypeOpt.map(pt => Piece(color, pt))
|
||||
@@ -1,54 +0,0 @@
|
||||
package de.nowchess.chess.notation
|
||||
|
||||
import de.nowchess.api.board.{PieceType, *}
|
||||
import de.nowchess.api.move.PromotionPiece
|
||||
import de.nowchess.api.game.{GameHistory, HistoryMove}
|
||||
|
||||
object PgnExporter:
|
||||
|
||||
/** Export a game with headers and history to PGN format. */
|
||||
def exportGame(headers: Map[String, String], history: GameHistory): String =
|
||||
val headerLines = headers.map { case (key, value) =>
|
||||
s"""[$key "$value"]"""
|
||||
}.mkString("\n")
|
||||
|
||||
val moveText = if history.moves.isEmpty then ""
|
||||
else
|
||||
val groupedMoves = history.moves.zipWithIndex.groupBy(_._2 / 2)
|
||||
val moveLines = for (moveNumber, movePairs) <- groupedMoves.toList.sortBy(_._1) yield
|
||||
val moveNum = moveNumber + 1
|
||||
val whiteMoveStr = movePairs.find(_._2 % 2 == 0).map(p => moveToAlgebraic(p._1)).getOrElse("")
|
||||
val blackMoveStr = movePairs.find(_._2 % 2 == 1).map(p => moveToAlgebraic(p._1)).getOrElse("")
|
||||
if blackMoveStr.isEmpty then s"$moveNum. $whiteMoveStr"
|
||||
else s"$moveNum. $whiteMoveStr $blackMoveStr"
|
||||
|
||||
val termination = headers.getOrElse("Result", "*")
|
||||
moveLines.mkString(" ") + s" $termination"
|
||||
|
||||
if headerLines.isEmpty then moveText
|
||||
else if moveText.isEmpty then headerLines
|
||||
else s"$headerLines\n\n$moveText"
|
||||
|
||||
/** Convert a HistoryMove to Standard Algebraic Notation. */
|
||||
def moveToAlgebraic(move: HistoryMove): String =
|
||||
move.castleSide match
|
||||
case Some("Kingside") => "O-O"
|
||||
case Some("Queenside") => "O-O-O"
|
||||
case Some(_) | None =>
|
||||
val dest = move.to.toString
|
||||
val capStr = if move.isCapture then "x" else ""
|
||||
val promSuffix = move.promotionPiece match
|
||||
case Some(PromotionPiece.Queen) => "=Q"
|
||||
case Some(PromotionPiece.Rook) => "=R"
|
||||
case Some(PromotionPiece.Bishop) => "=B"
|
||||
case Some(PromotionPiece.Knight) => "=N"
|
||||
case None => ""
|
||||
move.pieceType match
|
||||
case PieceType.Pawn =>
|
||||
if move.isCapture then s"${move.from.file.toString.toLowerCase}x$dest$promSuffix"
|
||||
else s"$dest$promSuffix"
|
||||
case PieceType.Knight => s"N$capStr$dest$promSuffix"
|
||||
case PieceType.Bishop => s"B$capStr$dest$promSuffix"
|
||||
case PieceType.Rook => s"R$capStr$dest$promSuffix"
|
||||
case PieceType.Queen => s"Q$capStr$dest$promSuffix"
|
||||
case PieceType.King => s"K$capStr$dest$promSuffix"
|
||||
@@ -1,187 +0,0 @@
|
||||
package de.nowchess.chess.notation
|
||||
|
||||
import de.nowchess.api.board.*
|
||||
import de.nowchess.api.move.{Move, MoveType, PromotionPiece}
|
||||
import de.nowchess.api.game.{GameContext, HistoryMove}
|
||||
import de.nowchess.rules.sets.StandardRules
|
||||
|
||||
/** A parsed PGN game containing headers and the resolved move list. */
|
||||
case class PgnGame(
|
||||
headers: Map[String, String],
|
||||
moves: List[HistoryMove]
|
||||
)
|
||||
|
||||
object PgnParser:
|
||||
|
||||
/** Strictly validate a PGN text.
|
||||
* Returns Right(PgnGame) if every move token is a legal move in the evolving position.
|
||||
* Returns Left(error message) on the first illegal or impossible move, or any unrecognised token. */
|
||||
def validatePgn(pgn: String): Either[String, PgnGame] =
|
||||
val lines = pgn.split("\n").map(_.trim)
|
||||
val (headerLines, rest) = lines.span(_.startsWith("["))
|
||||
val headers = parseHeaders(headerLines)
|
||||
val moveText = rest.mkString(" ")
|
||||
validateMovesText(moveText).map(moves => PgnGame(headers, moves))
|
||||
|
||||
/** Parse a complete PGN text into a PgnGame with headers and moves.
|
||||
* Always succeeds (returns Some); malformed tokens are silently skipped. */
|
||||
def parsePgn(pgn: String): Option[PgnGame] =
|
||||
val lines = pgn.split("\n").map(_.trim)
|
||||
val (headerLines, rest) = lines.span(_.startsWith("["))
|
||||
val headers = parseHeaders(headerLines)
|
||||
val moveText = rest.mkString(" ")
|
||||
val moves = parseMovesText(moveText)
|
||||
Some(PgnGame(headers, moves))
|
||||
|
||||
/** Parse PGN header lines of the form [Key "Value"]. */
|
||||
private def parseHeaders(lines: Array[String]): Map[String, String] =
|
||||
val pattern = """^\[(\w+)\s+"([^"]*)"\s*\]$""".r
|
||||
lines.flatMap(line => pattern.findFirstMatchIn(line).map(m => m.group(1) -> m.group(2))).toMap
|
||||
|
||||
/** Parse the move-text section (e.g. "1. e4 e5 2. Nf3") into resolved HistoryMoves. */
|
||||
private def parseMovesText(moveText: String): List[HistoryMove] =
|
||||
val tokens = moveText.split("\\s+").filter(_.nonEmpty)
|
||||
val (_, _, moves) = tokens.foldLeft(
|
||||
(GameContext.initial, Color.White, List.empty[HistoryMove])
|
||||
):
|
||||
case (state @ (ctx, color, acc), token) =>
|
||||
if isMoveNumberOrResult(token) then state
|
||||
else
|
||||
parseAlgebraicMove(token, ctx, color) match
|
||||
case None => state
|
||||
case Some(move) =>
|
||||
val histMove = toHistoryMove(move, ctx, color)
|
||||
val nextCtx = StandardRules.applyMove(ctx, move)
|
||||
(nextCtx, color.opposite, acc :+ histMove)
|
||||
moves
|
||||
|
||||
/** Convert an api.move.Move to a HistoryMove given the board context before the move. */
|
||||
private def toHistoryMove(move: Move, ctx: GameContext, color: Color): HistoryMove =
|
||||
val castleSide = move.moveType match
|
||||
case MoveType.CastleKingside => Some("Kingside")
|
||||
case MoveType.CastleQueenside => Some("Queenside")
|
||||
case _ => None
|
||||
val promotionPiece = move.moveType match
|
||||
case MoveType.Promotion(pp) => Some(pp)
|
||||
case _ => None
|
||||
val pieceType = ctx.board.pieceAt(move.from).map(_.pieceType).getOrElse(PieceType.Pawn)
|
||||
val isCapture = ctx.board.pieceAt(move.to).isDefined || move.moveType == MoveType.EnPassant
|
||||
HistoryMove(move.from, move.to, castleSide, promotionPiece, pieceType, isCapture)
|
||||
|
||||
/** True for move-number tokens ("1.", "12.") and PGN result tokens. */
|
||||
private def isMoveNumberOrResult(token: String): Boolean =
|
||||
token.matches("""\d+\.""") ||
|
||||
token == "*" ||
|
||||
token == "1-0" ||
|
||||
token == "0-1" ||
|
||||
token == "1/2-1/2"
|
||||
|
||||
/** Parse a single algebraic notation token into a Move, given the current game context. */
|
||||
def parseAlgebraicMove(notation: String, ctx: GameContext, color: Color): Option[Move] =
|
||||
notation match
|
||||
case "O-O" | "O-O+" | "O-O#" =>
|
||||
val rank = if color == Color.White then Rank.R1 else Rank.R8
|
||||
val move = Move(Square(File.E, rank), Square(File.G, rank), MoveType.CastleKingside)
|
||||
Option.when(StandardRules.legalMoves(ctx, Square(File.E, rank)).contains(move))(move)
|
||||
|
||||
case "O-O-O" | "O-O-O+" | "O-O-O#" =>
|
||||
val rank = if color == Color.White then Rank.R1 else Rank.R8
|
||||
val move = Move(Square(File.E, rank), Square(File.C, rank), MoveType.CastleQueenside)
|
||||
Option.when(StandardRules.legalMoves(ctx, Square(File.E, rank)).contains(move))(move)
|
||||
|
||||
case _ =>
|
||||
parseRegularMove(notation, ctx, color)
|
||||
|
||||
/** Parse regular algebraic notation (pawn moves, piece moves, captures, disambiguation). */
|
||||
private def parseRegularMove(notation: String, ctx: GameContext, color: Color): Option[Move] =
|
||||
val clean = notation
|
||||
.replace("+", "")
|
||||
.replace("#", "")
|
||||
.replace("x", "")
|
||||
.replaceAll("=[NBRQ]$", "")
|
||||
|
||||
if clean.length < 2 then None
|
||||
else
|
||||
val destStr = clean.takeRight(2)
|
||||
Square.fromAlgebraic(destStr).flatMap: toSquare =>
|
||||
val disambig = clean.dropRight(2)
|
||||
|
||||
val requiredPieceType: Option[PieceType] =
|
||||
if disambig.nonEmpty && disambig.head.isUpper then charToPieceType(disambig.head)
|
||||
else if clean.head.isUpper then charToPieceType(clean.head)
|
||||
else Some(PieceType.Pawn)
|
||||
|
||||
val hint =
|
||||
if disambig.nonEmpty && disambig.head.isUpper then disambig.tail
|
||||
else disambig
|
||||
|
||||
val promotion = extractPromotion(notation)
|
||||
|
||||
// Get all legal moves for this color that reach toSquare
|
||||
val allLegal = StandardRules.allLegalMoves(ctx)
|
||||
val candidates = allLegal.filter { move =>
|
||||
move.to == toSquare &&
|
||||
ctx.board.pieceAt(move.from).exists(p =>
|
||||
p.color == color &&
|
||||
requiredPieceType.forall(_ == p.pieceType)
|
||||
) &&
|
||||
(hint.isEmpty || matchesHint(move.from, hint)) &&
|
||||
promotionMatches(move, promotion)
|
||||
}
|
||||
|
||||
candidates.headOption
|
||||
|
||||
/** True if `sq` matches a disambiguation hint (file letter, rank digit, or both). */
|
||||
private def matchesHint(sq: Square, hint: String): Boolean =
|
||||
hint.forall(c =>
|
||||
if c >= 'a' && c <= 'h' then sq.file.toString.equalsIgnoreCase(c.toString)
|
||||
else if c >= '1' && c <= '8' then sq.rank.ordinal == (c - '1')
|
||||
else true
|
||||
)
|
||||
|
||||
private def promotionMatches(move: Move, promotion: Option[PromotionPiece]): Boolean =
|
||||
promotion match
|
||||
case None => move.moveType == MoveType.Normal || move.moveType == MoveType.EnPassant ||
|
||||
move.moveType == MoveType.CastleKingside || move.moveType == MoveType.CastleQueenside
|
||||
case Some(pp) => move.moveType == MoveType.Promotion(pp)
|
||||
|
||||
/** Extract a promotion piece from a notation string containing =Q/=R/=B/=N. */
|
||||
private[notation] def extractPromotion(notation: String): Option[PromotionPiece] =
|
||||
val promotionPattern = """=([A-Z])""".r
|
||||
promotionPattern.findFirstMatchIn(notation).flatMap { m =>
|
||||
m.group(1) match
|
||||
case "Q" => Some(PromotionPiece.Queen)
|
||||
case "R" => Some(PromotionPiece.Rook)
|
||||
case "B" => Some(PromotionPiece.Bishop)
|
||||
case "N" => Some(PromotionPiece.Knight)
|
||||
case _ => None
|
||||
}
|
||||
|
||||
/** Convert a piece-letter character to a PieceType. */
|
||||
private def charToPieceType(c: Char): Option[PieceType] =
|
||||
c match
|
||||
case 'N' => Some(PieceType.Knight)
|
||||
case 'B' => Some(PieceType.Bishop)
|
||||
case 'R' => Some(PieceType.Rook)
|
||||
case 'Q' => Some(PieceType.Queen)
|
||||
case 'K' => Some(PieceType.King)
|
||||
case _ => None
|
||||
|
||||
// ── Strict validation helpers ─────────────────────────────────────────────
|
||||
|
||||
/** Walk all move tokens, failing immediately on any unresolvable or illegal move. */
|
||||
private def validateMovesText(moveText: String): Either[String, List[HistoryMove]] =
|
||||
val tokens = moveText.split("\\s+").filter(_.nonEmpty)
|
||||
tokens.foldLeft(Right((GameContext.initial, Color.White, List.empty[HistoryMove])): Either[String, (GameContext, Color, List[HistoryMove])]) {
|
||||
case (acc, token) =>
|
||||
acc.flatMap { case (ctx, color, moves) =>
|
||||
if isMoveNumberOrResult(token) then Right((ctx, color, moves))
|
||||
else
|
||||
parseAlgebraicMove(token, ctx, color) match
|
||||
case None => Left(s"Illegal or impossible move: '$token'")
|
||||
case Some(move) =>
|
||||
val histMove = toHistoryMove(move, ctx, color)
|
||||
val nextCtx = StandardRules.applyMove(ctx, move)
|
||||
Right((nextCtx, color.opposite, moves :+ histMove))
|
||||
}
|
||||
}.map(_._3)
|
||||
@@ -151,7 +151,7 @@ class GameEngineLoadPgnTest extends AnyFunSuite with Matchers:
|
||||
test("loadPosition: fires BoardResetEvent and updates context"):
|
||||
import de.nowchess.api.board.{Board, Color}
|
||||
import de.nowchess.api.game.GameContext
|
||||
import de.nowchess.chess.notation.FenParser
|
||||
import de.nowchess.io.fen.FenParser
|
||||
|
||||
val engine = new GameEngine()
|
||||
val cap = new EventCapture()
|
||||
|
||||
@@ -3,7 +3,7 @@ package de.nowchess.chess.engine
|
||||
import de.nowchess.api.board.{Board, Color, File, Rank, Square}
|
||||
import de.nowchess.api.game.GameContext
|
||||
import de.nowchess.api.move.PromotionPiece
|
||||
import de.nowchess.chess.notation.FenParser
|
||||
import de.nowchess.io.fen.FenParser
|
||||
import de.nowchess.chess.observer.*
|
||||
import org.scalatest.funsuite.AnyFunSuite
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
|
||||
+11
-11
@@ -3,10 +3,10 @@ package de.nowchess.chess.engine
|
||||
import de.nowchess.api.board.{Board, Color, File, Piece, PieceType, Rank, Square}
|
||||
import de.nowchess.api.game.GameContext
|
||||
import de.nowchess.api.move.{Move, MoveType, PromotionPiece}
|
||||
import de.nowchess.chess.notation.FenParser
|
||||
import de.nowchess.io.fen.FenParser
|
||||
import de.nowchess.chess.observer.*
|
||||
import de.nowchess.rules.RuleSet
|
||||
import de.nowchess.rules.sets.StandardRules
|
||||
import de.nowchess.rules.sets.DefaultRules
|
||||
import org.scalatest.funsuite.AnyFunSuite
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
|
||||
@@ -154,27 +154,27 @@ class GameEnginePromotionTest extends AnyFunSuite with Matchers:
|
||||
// triggering the "Error completing promotion." branch.
|
||||
val delegatingRuleSet: RuleSet = new RuleSet:
|
||||
def candidateMoves(context: GameContext, square: Square): List[Move] =
|
||||
StandardRules.candidateMoves(context, square)
|
||||
DefaultRules.candidateMoves(context, square)
|
||||
def legalMoves(context: GameContext, square: Square): List[Move] =
|
||||
StandardRules.legalMoves(context, square).map { m =>
|
||||
DefaultRules.legalMoves(context, square).map { m =>
|
||||
m.moveType match
|
||||
case MoveType.Promotion(_) => Move(m.from, m.to, MoveType.Normal)
|
||||
case _ => m
|
||||
}
|
||||
def allLegalMoves(context: GameContext): List[Move] =
|
||||
StandardRules.allLegalMoves(context)
|
||||
DefaultRules.allLegalMoves(context)
|
||||
def isCheck(context: GameContext): Boolean =
|
||||
StandardRules.isCheck(context)
|
||||
DefaultRules.isCheck(context)
|
||||
def isCheckmate(context: GameContext): Boolean =
|
||||
StandardRules.isCheckmate(context)
|
||||
DefaultRules.isCheckmate(context)
|
||||
def isStalemate(context: GameContext): Boolean =
|
||||
StandardRules.isStalemate(context)
|
||||
DefaultRules.isStalemate(context)
|
||||
def isInsufficientMaterial(context: GameContext): Boolean =
|
||||
StandardRules.isInsufficientMaterial(context)
|
||||
DefaultRules.isInsufficientMaterial(context)
|
||||
def isFiftyMoveRule(context: GameContext): Boolean =
|
||||
StandardRules.isFiftyMoveRule(context)
|
||||
DefaultRules.isFiftyMoveRule(context)
|
||||
def applyMove(context: GameContext, move: Move): GameContext =
|
||||
StandardRules.applyMove(context, move)
|
||||
DefaultRules.applyMove(context, move)
|
||||
|
||||
val promotionBoard = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
|
||||
val initialCtx = GameContext.initial.withBoard(promotionBoard).withTurn(Color.White)
|
||||
|
||||
@@ -1,101 +0,0 @@
|
||||
package de.nowchess.chess.notation
|
||||
|
||||
import de.nowchess.api.board.*
|
||||
import de.nowchess.api.game.GameContext
|
||||
import de.nowchess.api.move.Move
|
||||
import org.scalatest.funsuite.AnyFunSuite
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
|
||||
class FenExporterTest extends AnyFunSuite with Matchers:
|
||||
|
||||
private def context(
|
||||
piecePlacement: String,
|
||||
turn: Color,
|
||||
castlingRights: CastlingRights,
|
||||
enPassantSquare: Option[Square],
|
||||
halfMoveClock: Int,
|
||||
moveCount: Int
|
||||
): GameContext =
|
||||
val board = FenParser.parseBoard(piecePlacement).getOrElse(
|
||||
fail(s"Invalid test board FEN: $piecePlacement")
|
||||
)
|
||||
val dummyMove = Move(Square(File.A, Rank.R2), Square(File.A, Rank.R3))
|
||||
GameContext(
|
||||
board = board,
|
||||
turn = turn,
|
||||
castlingRights = castlingRights,
|
||||
enPassantSquare = enPassantSquare,
|
||||
halfMoveClock = halfMoveClock,
|
||||
moves = List.fill(moveCount)(dummyMove)
|
||||
)
|
||||
|
||||
test("export initial position to FEN"):
|
||||
val fen = FenExporter.gameContextToFen(GameContext.initial)
|
||||
fen shouldBe "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
|
||||
|
||||
test("export position after e4"):
|
||||
val gameContext = context(
|
||||
piecePlacement = "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR",
|
||||
turn = Color.Black,
|
||||
castlingRights = CastlingRights.All,
|
||||
enPassantSquare = Some(Square(File.E, Rank.R3)),
|
||||
halfMoveClock = 0,
|
||||
moveCount = 0
|
||||
)
|
||||
val fen = FenExporter.gameContextToFen(gameContext)
|
||||
fen shouldBe "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1"
|
||||
|
||||
test("export position with no castling"):
|
||||
val gameContext = context(
|
||||
piecePlacement = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR",
|
||||
turn = Color.White,
|
||||
castlingRights = CastlingRights.None,
|
||||
enPassantSquare = None,
|
||||
halfMoveClock = 0,
|
||||
moveCount = 0
|
||||
)
|
||||
val fen = FenExporter.gameContextToFen(gameContext)
|
||||
fen shouldBe "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w - - 0 1"
|
||||
|
||||
test("export position with partial castling"):
|
||||
val gameContext = context(
|
||||
piecePlacement = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR",
|
||||
turn = Color.White,
|
||||
castlingRights = CastlingRights(
|
||||
whiteKingSide = true,
|
||||
whiteQueenSide = false,
|
||||
blackKingSide = false,
|
||||
blackQueenSide = true
|
||||
),
|
||||
enPassantSquare = None,
|
||||
halfMoveClock = 5,
|
||||
moveCount = 4
|
||||
)
|
||||
val fen = FenExporter.gameContextToFen(gameContext)
|
||||
fen shouldBe "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w Kq - 5 3"
|
||||
|
||||
test("export position with en passant and move counts"):
|
||||
val gameContext = context(
|
||||
piecePlacement = "rnbqkbnr/pp1ppppp/8/2pP4/8/8/PPPP1PPP/RNBQKBNR",
|
||||
turn = Color.White,
|
||||
castlingRights = CastlingRights.All,
|
||||
enPassantSquare = Some(Square(File.C, Rank.R6)),
|
||||
halfMoveClock = 2,
|
||||
moveCount = 4
|
||||
)
|
||||
val fen = FenExporter.gameContextToFen(gameContext)
|
||||
fen shouldBe "rnbqkbnr/pp1ppppp/8/2pP4/8/8/PPPP1PPP/RNBQKBNR w KQkq c6 2 3"
|
||||
|
||||
test("halfMoveClock round-trips through FEN export and import"):
|
||||
val gameContext = GameContext(
|
||||
board = Board.initial,
|
||||
turn = Color.White,
|
||||
castlingRights = CastlingRights.All,
|
||||
enPassantSquare = None,
|
||||
halfMoveClock = 42,
|
||||
moves = List.empty
|
||||
)
|
||||
val fen = FenExporter.gameContextToFen(gameContext)
|
||||
FenParser.parseFen(fen) match
|
||||
case Some(ctx) => ctx.halfMoveClock shouldBe 42
|
||||
case None => fail("FEN parsing failed")
|
||||
@@ -1,132 +0,0 @@
|
||||
package de.nowchess.chess.notation
|
||||
|
||||
import de.nowchess.api.board.*
|
||||
import org.scalatest.funsuite.AnyFunSuite
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
|
||||
class FenParserTest extends AnyFunSuite with Matchers:
|
||||
|
||||
test("parseBoard: initial position places pieces on correct squares"):
|
||||
val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
|
||||
val board = FenParser.parseBoard(fen)
|
||||
|
||||
board.map(_.pieceAt(Square(File.E, Rank.R2))) shouldBe Some(Some(Piece.WhitePawn))
|
||||
board.map(_.pieceAt(Square(File.E, Rank.R7))) shouldBe Some(Some(Piece.BlackPawn))
|
||||
board.map(_.pieceAt(Square(File.E, Rank.R1))) shouldBe Some(Some(Piece.WhiteKing))
|
||||
board.map(_.pieceAt(Square(File.E, Rank.R8))) shouldBe Some(Some(Piece.BlackKing))
|
||||
|
||||
test("parseBoard: empty board has no pieces"):
|
||||
val fen = "8/8/8/8/8/8/8/8"
|
||||
val board = FenParser.parseBoard(fen)
|
||||
|
||||
board shouldBe defined
|
||||
board.get.pieces.size shouldBe 0
|
||||
|
||||
test("parseBoard: returns None for missing rank (only 7 ranks)"):
|
||||
val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP"
|
||||
val board = FenParser.parseBoard(fen)
|
||||
|
||||
board shouldBe empty
|
||||
|
||||
test("parseBoard: returns None for invalid piece character"):
|
||||
val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNX"
|
||||
val board = FenParser.parseBoard(fen)
|
||||
|
||||
board shouldBe empty
|
||||
|
||||
test("parseBoard: partial position with two kings placed correctly"):
|
||||
val fen = "8/8/4k3/8/4K3/8/8/8"
|
||||
val board = FenParser.parseBoard(fen)
|
||||
|
||||
board.map(_.pieceAt(Square(File.E, Rank.R6))) shouldBe Some(Some(Piece.BlackKing))
|
||||
board.map(_.pieceAt(Square(File.E, Rank.R4))) shouldBe Some(Some(Piece.WhiteKing))
|
||||
|
||||
test("testRoundTripInitialPosition"):
|
||||
val originalFen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
|
||||
val board = FenParser.parseBoard(originalFen)
|
||||
val exportedFen = board.map(FenExporter.boardToFen)
|
||||
|
||||
exportedFen shouldBe Some(originalFen)
|
||||
|
||||
test("testRoundTripEmptyBoard"):
|
||||
val originalFen = "8/8/8/8/8/8/8/8"
|
||||
val board = FenParser.parseBoard(originalFen)
|
||||
val exportedFen = board.map(FenExporter.boardToFen)
|
||||
|
||||
exportedFen shouldBe Some(originalFen)
|
||||
|
||||
test("testRoundTripPartialPosition"):
|
||||
val originalFen = "8/8/4k3/8/4K3/8/8/8"
|
||||
val board = FenParser.parseBoard(originalFen)
|
||||
val exportedFen = board.map(FenExporter.boardToFen)
|
||||
|
||||
exportedFen shouldBe Some(originalFen)
|
||||
|
||||
test("parse full FEN - initial position"):
|
||||
val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
|
||||
val context = FenParser.parseFen(fen)
|
||||
|
||||
context.isDefined shouldBe true
|
||||
context.get.turn shouldBe Color.White
|
||||
context.get.castlingRights.whiteKingSide shouldBe true
|
||||
context.get.castlingRights.whiteQueenSide shouldBe true
|
||||
context.get.castlingRights.blackKingSide shouldBe true
|
||||
context.get.castlingRights.blackQueenSide shouldBe true
|
||||
context.get.enPassantSquare shouldBe None
|
||||
context.get.halfMoveClock shouldBe 0
|
||||
|
||||
test("parse full FEN - after e4"):
|
||||
val fen = "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1"
|
||||
val context = FenParser.parseFen(fen)
|
||||
|
||||
context.get.turn shouldBe Color.Black
|
||||
context.get.enPassantSquare shouldBe Some(Square(File.E, Rank.R3))
|
||||
|
||||
test("parse full FEN - invalid parts count"):
|
||||
val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq"
|
||||
val context = FenParser.parseFen(fen)
|
||||
|
||||
context.isDefined shouldBe false
|
||||
|
||||
test("parse full FEN - invalid color"):
|
||||
val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR x KQkq - 0 1"
|
||||
val context = FenParser.parseFen(fen)
|
||||
|
||||
context.isDefined shouldBe false
|
||||
|
||||
test("parse full FEN - invalid castling"):
|
||||
val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w XYZ - 0 1"
|
||||
val context = FenParser.parseFen(fen)
|
||||
|
||||
context.isDefined shouldBe false
|
||||
|
||||
test("parseFen: castling '-' produces no castling rights"):
|
||||
val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w - - 0 1"
|
||||
val context = FenParser.parseFen(fen)
|
||||
|
||||
context.isDefined shouldBe true
|
||||
context.get.castlingRights.whiteKingSide shouldBe false
|
||||
context.get.castlingRights.whiteQueenSide shouldBe false
|
||||
context.get.castlingRights.blackKingSide shouldBe false
|
||||
context.get.castlingRights.blackQueenSide shouldBe false
|
||||
|
||||
test("parseBoard: returns None when a rank has too many files (overflow beyond 8)"):
|
||||
// "9" alone would advance fileIdx to 9, exceeding 8 → None
|
||||
val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBN9"
|
||||
val board = FenParser.parseBoard(fen)
|
||||
|
||||
board shouldBe empty
|
||||
|
||||
test("parseBoard: returns None when a rank fails to parse (invalid middle rank)"):
|
||||
// Invalid character 'X' in rank 4 should cause failure
|
||||
val fen = "rnbqkbnr/pppppppp/8/8/XXXXXXXX/8/PPPPPPPP/RNBQKBNR"
|
||||
val board = FenParser.parseBoard(fen)
|
||||
|
||||
board shouldBe empty
|
||||
|
||||
test("parseBoard: returns None when a rank has 9 piece characters (fileIdx > 7)"):
|
||||
// 9 pawns in one rank triggers fileIdx > 7 guard (line 78)
|
||||
val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/PPPPPPPPP"
|
||||
val board = FenParser.parseBoard(fen)
|
||||
|
||||
board shouldBe empty
|
||||
@@ -1,114 +0,0 @@
|
||||
package de.nowchess.chess.notation
|
||||
|
||||
import de.nowchess.api.board.{PieceType, *}
|
||||
import de.nowchess.api.move.PromotionPiece
|
||||
import de.nowchess.api.game.{GameHistory, HistoryMove}
|
||||
import org.scalatest.funsuite.AnyFunSuite
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
|
||||
class PgnExporterTest extends AnyFunSuite with Matchers:
|
||||
|
||||
test("export empty game") {
|
||||
val headers = Map("Event" -> "Test", "White" -> "A", "Black" -> "B")
|
||||
val history = GameHistory.empty
|
||||
val pgn = PgnExporter.exportGame(headers, history)
|
||||
|
||||
pgn.contains("[Event \"Test\"]") shouldBe true
|
||||
pgn.contains("[White \"A\"]") shouldBe true
|
||||
pgn.contains("[Black \"B\"]") shouldBe true
|
||||
}
|
||||
|
||||
test("export single move") {
|
||||
val headers = Map("Event" -> "Test", "White" -> "A", "Black" -> "B")
|
||||
val history = GameHistory()
|
||||
.addMove(HistoryMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4), None))
|
||||
val pgn = PgnExporter.exportGame(headers, history)
|
||||
|
||||
pgn.contains("1. e4") shouldBe true
|
||||
}
|
||||
|
||||
test("export castling") {
|
||||
val headers = Map("Event" -> "Test")
|
||||
val history = GameHistory()
|
||||
.addMove(HistoryMove(Square(File.E, Rank.R1), Square(File.G, Rank.R1), Some("Kingside")))
|
||||
val pgn = PgnExporter.exportGame(headers, history)
|
||||
|
||||
pgn.contains("O-O") shouldBe true
|
||||
}
|
||||
|
||||
test("export game sequence") {
|
||||
val headers = Map("Event" -> "Test", "White" -> "A", "Black" -> "B", "Result" -> "1-0")
|
||||
val history = GameHistory()
|
||||
.addMove(HistoryMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4), None))
|
||||
.addMove(HistoryMove(Square(File.C, Rank.R7), Square(File.C, Rank.R5), None))
|
||||
.addMove(HistoryMove(Square(File.G, Rank.R1), Square(File.F, Rank.R3), None, pieceType = PieceType.Knight))
|
||||
val pgn = PgnExporter.exportGame(headers, history)
|
||||
|
||||
pgn.contains("1. e4 c5") shouldBe true
|
||||
pgn.contains("2. Nf3") shouldBe true
|
||||
}
|
||||
|
||||
test("export game with no headers returns only move text") {
|
||||
val history = GameHistory()
|
||||
.addMove(HistoryMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4), None))
|
||||
val pgn = PgnExporter.exportGame(Map.empty, history)
|
||||
|
||||
pgn shouldBe "1. e4 *"
|
||||
}
|
||||
|
||||
test("export queenside castling") {
|
||||
val headers = Map("Event" -> "Test")
|
||||
val history = GameHistory()
|
||||
.addMove(HistoryMove(Square(File.E, Rank.R1), Square(File.C, Rank.R1), Some("Queenside")))
|
||||
val pgn = PgnExporter.exportGame(headers, history)
|
||||
|
||||
pgn.contains("O-O-O") shouldBe true
|
||||
}
|
||||
|
||||
test("exportGame encodes promotion to Queen as =Q suffix") {
|
||||
val history = GameHistory()
|
||||
.addMove(HistoryMove(Square(File.E, Rank.R7), Square(File.E, Rank.R8), None, Some(PromotionPiece.Queen)))
|
||||
val pgn = PgnExporter.exportGame(Map.empty, history)
|
||||
pgn should include ("e8=Q")
|
||||
}
|
||||
|
||||
test("exportGame encodes promotion to Rook as =R suffix") {
|
||||
val history = GameHistory()
|
||||
.addMove(HistoryMove(Square(File.E, Rank.R7), Square(File.E, Rank.R8), None, Some(PromotionPiece.Rook)))
|
||||
val pgn = PgnExporter.exportGame(Map.empty, history)
|
||||
pgn should include ("e8=R")
|
||||
}
|
||||
|
||||
test("exportGame encodes promotion to Bishop as =B suffix") {
|
||||
val history = GameHistory()
|
||||
.addMove(HistoryMove(Square(File.E, Rank.R7), Square(File.E, Rank.R8), None, Some(PromotionPiece.Bishop)))
|
||||
val pgn = PgnExporter.exportGame(Map.empty, history)
|
||||
pgn should include ("e8=B")
|
||||
}
|
||||
|
||||
test("exportGame encodes promotion to Knight as =N suffix") {
|
||||
val history = GameHistory()
|
||||
.addMove(HistoryMove(Square(File.E, Rank.R7), Square(File.E, Rank.R8), None, Some(PromotionPiece.Knight)))
|
||||
val pgn = PgnExporter.exportGame(Map.empty, history)
|
||||
pgn should include ("e8=N")
|
||||
}
|
||||
|
||||
test("exportGame does not add suffix for normal moves") {
|
||||
val history = GameHistory()
|
||||
.addMove(HistoryMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4), None, None))
|
||||
val pgn = PgnExporter.exportGame(Map.empty, history)
|
||||
pgn should include ("e4")
|
||||
pgn should not include ("=")
|
||||
}
|
||||
|
||||
test("exportGame uses Result header as termination marker"):
|
||||
val history = GameHistory()
|
||||
.addMove(HistoryMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4), None))
|
||||
val pgn = PgnExporter.exportGame(Map("Result" -> "1/2-1/2"), history)
|
||||
pgn should endWith("1/2-1/2")
|
||||
|
||||
test("exportGame with no Result header still uses * as default"):
|
||||
val history = GameHistory()
|
||||
.addMove(HistoryMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4), None))
|
||||
val pgn = PgnExporter.exportGame(Map.empty, history)
|
||||
pgn shouldBe "1. e4 *"
|
||||
@@ -1,439 +0,0 @@
|
||||
package de.nowchess.chess.notation
|
||||
|
||||
import de.nowchess.api.board.*
|
||||
import de.nowchess.api.move.{MoveType, PromotionPiece}
|
||||
import de.nowchess.api.game.GameContext
|
||||
import de.nowchess.chess.notation.FenParser
|
||||
import org.scalatest.funsuite.AnyFunSuite
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
|
||||
class PgnParserTest extends AnyFunSuite with Matchers:
|
||||
|
||||
test("parse PGN headers only") {
|
||||
val pgn = """[Event "Test Game"]
|
||||
[Site "Earth"]
|
||||
[Date "2026.03.28"]
|
||||
[White "Alice"]
|
||||
[Black "Bob"]
|
||||
[Result "1-0"]"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
|
||||
game.isDefined shouldBe true
|
||||
game.get.headers("Event") shouldBe "Test Game"
|
||||
game.get.headers("White") shouldBe "Alice"
|
||||
game.get.headers("Result") shouldBe "1-0"
|
||||
game.get.moves shouldBe List()
|
||||
}
|
||||
|
||||
test("parse PGN simple game") {
|
||||
val pgn = """[Event "Test"]
|
||||
[Site "?"]
|
||||
[Date "2026.03.28"]
|
||||
[White "A"]
|
||||
[Black "B"]
|
||||
[Result "*"]
|
||||
|
||||
1. e4 e5 2. Nf3 Nc6 3. Bb5 a6
|
||||
"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
|
||||
game.isDefined shouldBe true
|
||||
game.get.moves.length shouldBe 6
|
||||
// e4: e2-e4
|
||||
game.get.moves(0).from shouldBe Square(File.E, Rank.R2)
|
||||
game.get.moves(0).to shouldBe Square(File.E, Rank.R4)
|
||||
}
|
||||
|
||||
test("parse PGN move with capture") {
|
||||
val pgn = """[Event "Test"]
|
||||
[White "A"]
|
||||
[Black "B"]
|
||||
|
||||
1. Nf3 e5 2. Nxe5
|
||||
"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
|
||||
game.isDefined shouldBe true
|
||||
game.get.moves.length shouldBe 3
|
||||
// Nxe5: knight on f3 captures pawn on e5
|
||||
game.get.moves(2).to shouldBe Square(File.E, Rank.R5)
|
||||
}
|
||||
|
||||
test("parse PGN castling") {
|
||||
val pgn = """[Event "Test"]
|
||||
[White "A"]
|
||||
[Black "B"]
|
||||
|
||||
1. e4 e5 2. Nf3 Nc6 3. Bc4 Bc5 4. O-O
|
||||
"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
|
||||
game.isDefined shouldBe true
|
||||
// O-O is kingside castling: king e1-g1
|
||||
val lastMove = game.get.moves.last
|
||||
lastMove.from shouldBe Square(File.E, Rank.R1)
|
||||
lastMove.to shouldBe Square(File.G, Rank.R1)
|
||||
lastMove.castleSide.isDefined shouldBe true
|
||||
}
|
||||
|
||||
test("parse PGN empty moves") {
|
||||
val pgn = """[Event "Test"]
|
||||
[White "A"]
|
||||
[Black "B"]
|
||||
[Result "1-0"]
|
||||
"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
|
||||
game.isDefined shouldBe true
|
||||
game.get.moves.length shouldBe 0
|
||||
}
|
||||
|
||||
test("parse PGN black kingside castling O-O") {
|
||||
// After e4 e5 Nf3 Nf6 Bc4 Be7, both sides have cleared kingside for castling
|
||||
val pgn = """[Event "Test"]
|
||||
|
||||
1. e4 e5 2. Nf3 Nf6 3. Bc4 Be7 4. O-O O-O
|
||||
"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
|
||||
game.isDefined shouldBe true
|
||||
val blackCastle = game.get.moves.last
|
||||
blackCastle.castleSide shouldBe Some("Kingside")
|
||||
blackCastle.from shouldBe Square(File.E, Rank.R8)
|
||||
blackCastle.to shouldBe Square(File.G, Rank.R8)
|
||||
}
|
||||
|
||||
test("parse PGN result tokens are skipped") {
|
||||
// Result tokens like 1-0, 0-1, 1/2-1/2, * should be silently skipped
|
||||
val pgn = """[Event "Test"]
|
||||
|
||||
1. e4 e5 1-0
|
||||
"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
|
||||
game.isDefined shouldBe true
|
||||
game.get.moves.length shouldBe 2
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove: unrecognised token returns None and is skipped") {
|
||||
val board = Board.initial
|
||||
// "zzz" is not valid algebraic notation
|
||||
val result = PgnParser.parseAlgebraicMove("zzz", GameContext.initial.withBoard(board), Color.White)
|
||||
result shouldBe None
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove: piece moves use charToPieceType for N B R Q K") {
|
||||
// Test that piece type characters are recognised
|
||||
val board = Board.initial
|
||||
|
||||
// Nf3 - knight move
|
||||
val nMove = PgnParser.parseAlgebraicMove("Nf3", GameContext.initial.withBoard(board), Color.White)
|
||||
nMove.isDefined shouldBe true
|
||||
nMove.get.to shouldBe Square(File.F, Rank.R3)
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove: single char that is too short returns None") {
|
||||
val board = Board.initial
|
||||
// Single char that is not castling and cleaned length < 2
|
||||
val result = PgnParser.parseAlgebraicMove("e", GameContext.initial.withBoard(board), Color.White)
|
||||
result shouldBe None
|
||||
}
|
||||
|
||||
test("parse PGN with file disambiguation hint") {
|
||||
// Use a position where two rooks can reach the same square to test file hint
|
||||
// Rooks on a1 and h1, destination d1 - "Rad1" uses file 'a' to disambiguate
|
||||
import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
|
||||
val pieces: Map[Square, Piece] = Map(
|
||||
Square(File.A, Rank.R1) -> Piece(Color.White, PieceType.Rook),
|
||||
Square(File.H, Rank.R1) -> Piece(Color.White, PieceType.Rook),
|
||||
Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
|
||||
Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
|
||||
)
|
||||
val board = Board(pieces)
|
||||
|
||||
val result = PgnParser.parseAlgebraicMove("Rad1", GameContext.initial.withBoard(board), Color.White)
|
||||
result.isDefined shouldBe true
|
||||
result.get.from shouldBe Square(File.A, Rank.R1)
|
||||
result.get.to shouldBe Square(File.D, Rank.R1)
|
||||
}
|
||||
|
||||
test("parse PGN with rank disambiguation hint") {
|
||||
// Two rooks on a1 and a4 can reach a3 - "R1a3" uses rank '1' to disambiguate
|
||||
import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
|
||||
val pieces: Map[Square, Piece] = Map(
|
||||
Square(File.A, Rank.R1) -> Piece(Color.White, PieceType.Rook),
|
||||
Square(File.A, Rank.R4) -> Piece(Color.White, PieceType.Rook),
|
||||
Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
|
||||
Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
|
||||
)
|
||||
val board = Board(pieces)
|
||||
|
||||
val result = PgnParser.parseAlgebraicMove("R1a3", GameContext.initial.withBoard(board), Color.White)
|
||||
result.isDefined shouldBe true
|
||||
result.get.from shouldBe Square(File.A, Rank.R1)
|
||||
result.get.to shouldBe Square(File.A, Rank.R3)
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove: charToPieceType covers all piece letters including B R Q K") {
|
||||
import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
|
||||
// Bishop move
|
||||
val piecesForBishop: Map[Square, Piece] = Map(
|
||||
Square(File.C, Rank.R1) -> Piece(Color.White, PieceType.Bishop),
|
||||
Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
|
||||
Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
|
||||
)
|
||||
val boardBishop = Board(piecesForBishop)
|
||||
val bResult = PgnParser.parseAlgebraicMove("Bd2", GameContext.initial.withBoard(boardBishop), Color.White)
|
||||
bResult.isDefined shouldBe true
|
||||
|
||||
// Rook move
|
||||
val piecesForRook: Map[Square, Piece] = Map(
|
||||
Square(File.A, Rank.R1) -> Piece(Color.White, PieceType.Rook),
|
||||
Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
|
||||
Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
|
||||
)
|
||||
val boardRook = Board(piecesForRook)
|
||||
val rResult = PgnParser.parseAlgebraicMove("Ra4", GameContext.initial.withBoard(boardRook), Color.White)
|
||||
rResult.isDefined shouldBe true
|
||||
|
||||
// Queen move
|
||||
val piecesForQueen: Map[Square, Piece] = Map(
|
||||
Square(File.D, Rank.R1) -> Piece(Color.White, PieceType.Queen),
|
||||
Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
|
||||
Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
|
||||
)
|
||||
val boardQueen = Board(piecesForQueen)
|
||||
val qResult = PgnParser.parseAlgebraicMove("Qd4", GameContext.initial.withBoard(boardQueen), Color.White)
|
||||
qResult.isDefined shouldBe true
|
||||
|
||||
// King move
|
||||
val piecesForKing: Map[Square, Piece] = Map(
|
||||
Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
|
||||
Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
|
||||
)
|
||||
val boardKing = Board(piecesForKing)
|
||||
val kResult = PgnParser.parseAlgebraicMove("Ke2", GameContext.initial.withBoard(boardKing), Color.White)
|
||||
kResult.isDefined shouldBe true
|
||||
}
|
||||
|
||||
test("parse PGN queenside castling O-O-O") {
|
||||
val pgn = """[Event "Test"]
|
||||
|
||||
1. d4 d5 2. Nc3 Nc6 3. Bf4 Bf5 4. Qd2 Qd7 5. O-O-O
|
||||
"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
|
||||
game.isDefined shouldBe true
|
||||
val lastMove = game.get.moves.last
|
||||
lastMove.castleSide shouldBe Some("Queenside")
|
||||
lastMove.from shouldBe Square(File.E, Rank.R1)
|
||||
lastMove.to shouldBe Square(File.C, Rank.R1)
|
||||
}
|
||||
|
||||
test("parse PGN black queenside castling O-O-O") {
|
||||
// After sufficient moves, black castles queenside
|
||||
val pgn = """[Event "Test"]
|
||||
|
||||
1. d4 d5 2. Nc3 Nc6 3. Bf4 Bf5 4. Qd2 Qd7 5. O-O-O O-O-O
|
||||
"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
|
||||
game.isDefined shouldBe true
|
||||
val lastMove = game.get.moves.last
|
||||
lastMove.castleSide shouldBe Some("Queenside")
|
||||
lastMove.from shouldBe Square(File.E, Rank.R8)
|
||||
lastMove.to shouldBe Square(File.C, Rank.R8)
|
||||
}
|
||||
|
||||
test("parse PGN with unrecognised token in move text is silently skipped") {
|
||||
// "INVALID" is not valid PGN; it should be skipped and remaining moves parsed
|
||||
val pgn = """[Event "Test"]
|
||||
|
||||
1. e4 INVALID e5
|
||||
"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
|
||||
game.isDefined shouldBe true
|
||||
// e4 parsed, INVALID skipped, e5 parsed
|
||||
game.get.moves.length shouldBe 2
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove: file+rank disambiguation with piece letter") {
|
||||
// "Rae1" notation: piece R, disambig "a" -> hint is "a", piece letter is uppercase first char of disambig
|
||||
// But since disambig="a" which is not uppercase, the piece letter comes from clean.head
|
||||
// Test "Rae1" style: R is clean.head uppercase, disambig "a" is the hint
|
||||
import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
|
||||
val pieces: Map[Square, Piece] = Map(
|
||||
Square(File.A, Rank.R4) -> Piece(Color.White, PieceType.Rook),
|
||||
Square(File.H, Rank.R4) -> Piece(Color.White, PieceType.Rook),
|
||||
Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
|
||||
Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
|
||||
)
|
||||
val board = Board(pieces)
|
||||
|
||||
// "Rae4" - Rook from a-file to e4; disambig = "a", clean.head = 'R' uppercase
|
||||
val result = PgnParser.parseAlgebraicMove("Rae4", GameContext.initial.withBoard(board), Color.White)
|
||||
result.isDefined shouldBe true
|
||||
result.get.from shouldBe Square(File.A, Rank.R4)
|
||||
result.get.to shouldBe Square(File.E, Rank.R4)
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove: charToPieceType returns None for unknown character") {
|
||||
// 'Z' is not a valid piece letter - the regex clean should return None
|
||||
import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
|
||||
val board = Board.initial
|
||||
|
||||
// "Ze4" - Z is not a valid piece, charToPieceType('Z') returns None
|
||||
// The result will be None because requiredPieceType is None and filtering by None.forall = true
|
||||
// so it finds any piece that can reach e4, but since clean="Ze4" -> destStr="e4", disambig="Z"
|
||||
// disambig.head.isUpper so charToPieceType('Z') is called
|
||||
val result = PgnParser.parseAlgebraicMove("Ze4", GameContext.initial.withBoard(board), Color.White)
|
||||
// With None piece type, forall(pt => ...) is vacuously true so any piece reaching e4 is candidate
|
||||
// But there's no piece named Z so requiredPieceType=None, meaning any piece can match
|
||||
// This tests that charToPieceType('Z') returns None without crashing
|
||||
result shouldBe defined // will find a pawn or whatever reaches e4
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove: uppercase dest-only notation hits clean.head.isUpper and charToPieceType unknown char") {
|
||||
// "E4" - clean = "E4", disambig = "", clean.head = 'E' is upper, charToPieceType('E') returns None
|
||||
// This exercises line 97 (else if clean.head.isUpper) and line 152 (case _ => None)
|
||||
import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
|
||||
val board = Board.initial
|
||||
// 'E' is not a valid piece type but we still get a result since requiredPieceType is None
|
||||
val result = PgnParser.parseAlgebraicMove("E4", GameContext.initial.withBoard(board), Color.White)
|
||||
// Result may be defined (pawn that can reach e4) or None; main goal is no crash and line coverage
|
||||
result should not be null // just verifies code path executes without exception
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove: rank disambiguation with digit outside 1-8 hits matchesHint else-true branch") {
|
||||
// Build a board with a Rook that can be targeted with a disambiguation hint containing '9'
|
||||
// hint = "9" → c = '9', not in a-h, not in 1-8, triggers else true
|
||||
import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
|
||||
val pieces: Map[Square, Piece] = Map(
|
||||
Square(File.A, Rank.R1) -> Piece(Color.White, PieceType.Rook),
|
||||
Square(File.H, Rank.R1) -> Piece(Color.White, PieceType.Rook),
|
||||
Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
|
||||
Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
|
||||
)
|
||||
val board = Board(pieces)
|
||||
|
||||
// "R9d1" - clean = "R9d1", destStr = "d1", disambig = "R9"
|
||||
// disambig.head = 'R' is upper -> charToPieceType('R') = Rook, hint = "9"
|
||||
// matchesHint called with hint "9" -> '9' not in a-h, not in 1-8 -> else true
|
||||
val result = PgnParser.parseAlgebraicMove("R9d1", GameContext.initial.withBoard(board), Color.White)
|
||||
// Should find a rook (hint "9" matches everything)
|
||||
result.isDefined shouldBe true
|
||||
result.get.to shouldBe Square(File.D, Rank.R1)
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove preserves promotion to Queen in HistoryMove") {
|
||||
val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
|
||||
val result = PgnParser.parseAlgebraicMove("e7e8=Q", GameContext.initial.withBoard(board), Color.White)
|
||||
result.isDefined should be (true)
|
||||
result.get.moveType shouldBe MoveType.Promotion(PromotionPiece.Queen)
|
||||
result.get.to should be (Square(File.E, Rank.R8))
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove preserves promotion to Rook") {
|
||||
val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
|
||||
val result = PgnParser.parseAlgebraicMove("e7e8=R", GameContext.initial.withBoard(board), Color.White)
|
||||
result.get.moveType shouldBe MoveType.Promotion(PromotionPiece.Rook)
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove preserves promotion to Bishop") {
|
||||
val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
|
||||
val result = PgnParser.parseAlgebraicMove("e7e8=B", GameContext.initial.withBoard(board), Color.White)
|
||||
result.get.moveType shouldBe MoveType.Promotion(PromotionPiece.Bishop)
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove preserves promotion to Knight") {
|
||||
val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
|
||||
val result = PgnParser.parseAlgebraicMove("e7e8=N", GameContext.initial.withBoard(board), Color.White)
|
||||
result.get.moveType shouldBe MoveType.Promotion(PromotionPiece.Knight)
|
||||
}
|
||||
|
||||
test("parsePgn applies promoted piece to board for subsequent moves") {
|
||||
// Build a board with a white pawn on e7 plus the two kings
|
||||
import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
|
||||
val pieces: Map[Square, Piece] = Map(
|
||||
Square(File.E, Rank.R7) -> Piece(Color.White, PieceType.Pawn),
|
||||
Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
|
||||
Square(File.H, Rank.R1) -> Piece(Color.Black, PieceType.King)
|
||||
)
|
||||
val board = Board(pieces)
|
||||
val move = PgnParser.parseAlgebraicMove("e7e8=Q", GameContext.initial.withBoard(board), Color.White)
|
||||
move.isDefined should be (true)
|
||||
move.get.moveType shouldBe MoveType.Promotion(PromotionPiece.Queen)
|
||||
// After applying the promotion the square e8 should hold a White Queen
|
||||
val (boardAfterPawnMove, _) = board.withMove(move.get.from, move.get.to)
|
||||
val promotedBoard = boardAfterPawnMove.updated(move.get.to, Piece(Color.White, PieceType.Queen))
|
||||
promotedBoard.pieceAt(Square(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Queen)))
|
||||
}
|
||||
|
||||
test("parsePgn with all four promotion piece types (Queen, Rook, Bishop, Knight) in sequence") {
|
||||
// Exercises the promotion piece type branches in PgnParser.parseMovesText / toHistoryMove
|
||||
// White pawn advances via capture chain (a4xb5, b5xc6 e.p., c6-c7, c7xd8) and promotes
|
||||
val baseSequence = "1. a2a4 b7b5 2. a4b5 c7c5 3. b5c6 d7d5 4. c6c7 d5d4 5. c7d8="
|
||||
for (piece, expected) <- List(
|
||||
"Q" -> PromotionPiece.Queen,
|
||||
"R" -> PromotionPiece.Rook,
|
||||
"B" -> PromotionPiece.Bishop,
|
||||
"N" -> PromotionPiece.Knight
|
||||
) do
|
||||
val pgn = s"""[Event "Promotion Test"]\n\n${baseSequence}$piece\n"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
game.isDefined shouldBe true
|
||||
game.get.moves should not be empty
|
||||
game.get.moves.last.promotionPiece shouldBe Some(expected)
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove promotion with Rook through full PGN parse") {
|
||||
// White pawn advances via capture chain and promotes by capturing black queen on d8
|
||||
val pgn = """[Event "Test"]
|
||||
[White "A"]
|
||||
[Black "B"]
|
||||
|
||||
1. a2a4 b7b5 2. a4b5 c7c5 3. b5c6 d7d5 4. c6c7 d5d4 5. c7d8=R
|
||||
"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
game.isDefined shouldBe true
|
||||
val lastMove = game.get.moves.last
|
||||
lastMove.promotionPiece shouldBe Some(PromotionPiece.Rook)
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove promotion with Bishop through full PGN parse") {
|
||||
val pgn = """[Event "Test"]
|
||||
[White "A"]
|
||||
[Black "B"]
|
||||
|
||||
1. a2a4 b7b5 2. a4b5 c7c5 3. b5c6 d7d5 4. c6c7 d5d4 5. c7d8=B
|
||||
"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
game.isDefined shouldBe true
|
||||
val lastMove = game.get.moves.last
|
||||
lastMove.promotionPiece shouldBe Some(PromotionPiece.Bishop)
|
||||
}
|
||||
|
||||
test("parseAlgebraicMove promotion with Knight through full PGN parse") {
|
||||
val pgn = """[Event "Test"]
|
||||
[White "A"]
|
||||
[Black "B"]
|
||||
|
||||
1. a2a4 b7b5 2. a4b5 c7c5 3. b5c6 d7d5 4. c6c7 d5d4 5. c7d8=N
|
||||
"""
|
||||
val game = PgnParser.parsePgn(pgn)
|
||||
game.isDefined shouldBe true
|
||||
val lastMove = game.get.moves.last
|
||||
lastMove.promotionPiece shouldBe Some(PromotionPiece.Knight)
|
||||
}
|
||||
|
||||
test("extractPromotion returns None for invalid promotion letter") {
|
||||
// Regex =([A-Z]) now captures any uppercase letter, so =X is matched but case _ => None fires
|
||||
val result = PgnParser.extractPromotion("e7e8=X")
|
||||
result shouldBe None
|
||||
}
|
||||
|
||||
test("extractPromotion returns None when no promotion in notation") {
|
||||
val result = PgnParser.extractPromotion("e7e8")
|
||||
result shouldBe None
|
||||
}
|
||||
@@ -1,119 +0,0 @@
|
||||
package de.nowchess.chess.notation
|
||||
|
||||
import de.nowchess.api.board.*
|
||||
import de.nowchess.api.move.PromotionPiece
|
||||
import de.nowchess.api.game.{GameHistory, HistoryMove}
|
||||
import org.scalatest.funsuite.AnyFunSuite
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
|
||||
class PgnValidatorTest extends AnyFunSuite with Matchers:
|
||||
|
||||
test("validatePgn: valid simple game returns Right with correct moves"):
|
||||
val pgn =
|
||||
"""[Event "Test"]
|
||||
[White "A"]
|
||||
[Black "B"]
|
||||
|
||||
1. e4 e5 2. Nf3 Nc6
|
||||
"""
|
||||
PgnParser.validatePgn(pgn) match
|
||||
case Right(game) =>
|
||||
game.moves.length shouldBe 4
|
||||
game.headers("Event") shouldBe "Test"
|
||||
game.moves(0).from shouldBe Square(File.E, Rank.R2)
|
||||
game.moves(0).to shouldBe Square(File.E, Rank.R4)
|
||||
case Left(err) => fail(s"Expected Right but got Left($err)")
|
||||
|
||||
test("validatePgn: empty move text returns Right with no moves"):
|
||||
val pgn = "[Event \"Test\"]\n[White \"A\"]\n[Black \"B\"]\n"
|
||||
PgnParser.validatePgn(pgn) match
|
||||
case Right(game) => game.moves shouldBe empty
|
||||
case Left(err) => fail(s"Expected Right but got Left($err)")
|
||||
|
||||
test("validatePgn: impossible position returns Left"):
|
||||
// "Nf6" without any preceding moves — there is no knight that can reach f6 from f3 yet
|
||||
// but e4 e5 Nf3 is OK; then Nd4 — knight on f3 can go to d4
|
||||
// Let's use a clearly impossible move: "Qd4" from the initial position (queen can't move)
|
||||
val pgn =
|
||||
"""[Event "Test"]
|
||||
|
||||
1. Qd4
|
||||
"""
|
||||
PgnParser.validatePgn(pgn) match
|
||||
case Left(_) => succeed
|
||||
case Right(g) => fail(s"Expected Left but got Right with ${g.moves.length} moves")
|
||||
|
||||
test("validatePgn: unrecognised token returns Left"):
|
||||
val pgn =
|
||||
"""[Event "Test"]
|
||||
|
||||
1. e4 GARBAGE e5
|
||||
"""
|
||||
PgnParser.validatePgn(pgn) match
|
||||
case Left(_) => succeed
|
||||
case Right(g) => fail(s"Expected Left but got Right with ${g.moves.length} moves")
|
||||
|
||||
test("validatePgn: result tokens are skipped (not treated as errors)"):
|
||||
val pgn =
|
||||
"""[Event "Test"]
|
||||
|
||||
1. e4 e5 1-0
|
||||
"""
|
||||
PgnParser.validatePgn(pgn) match
|
||||
case Right(game) => game.moves.length shouldBe 2
|
||||
case Left(err) => fail(s"Expected Right but got Left($err)")
|
||||
|
||||
test("validatePgn: valid kingside castling is accepted"):
|
||||
val pgn =
|
||||
"""[Event "Test"]
|
||||
|
||||
1. e4 e5 2. Nf3 Nc6 3. Bc4 Bc5 4. O-O
|
||||
"""
|
||||
PgnParser.validatePgn(pgn) match
|
||||
case Right(game) =>
|
||||
game.moves.last.castleSide shouldBe Some("Kingside")
|
||||
case Left(err) => fail(s"Expected Right but got Left($err)")
|
||||
|
||||
test("validatePgn: castling when not legal returns Left"):
|
||||
// Try to castle on move 1 — impossible from initial position (pieces in the way)
|
||||
val pgn =
|
||||
"""[Event "Test"]
|
||||
|
||||
1. O-O
|
||||
"""
|
||||
PgnParser.validatePgn(pgn) match
|
||||
case Left(_) => succeed
|
||||
case Right(g) => fail(s"Expected Left but got Right with ${g.moves.length} moves")
|
||||
|
||||
test("validatePgn: valid queenside castling is accepted"):
|
||||
val pgn =
|
||||
"""[Event "Test"]
|
||||
|
||||
1. d4 d5 2. Nc3 Nc6 3. Bf4 Bf5 4. Qd2 Qd7 5. O-O-O
|
||||
"""
|
||||
PgnParser.validatePgn(pgn) match
|
||||
case Right(game) =>
|
||||
game.moves.last.castleSide shouldBe Some("Queenside")
|
||||
case Left(err) => fail(s"Expected Right but got Left($err)")
|
||||
|
||||
test("validatePgn: disambiguation with two rooks is accepted"):
|
||||
val pieces: Map[Square, Piece] = Map(
|
||||
Square(File.A, Rank.R1) -> Piece(Color.White, PieceType.Rook),
|
||||
Square(File.H, Rank.R1) -> Piece(Color.White, PieceType.Rook),
|
||||
Square(File.E, Rank.R4) -> Piece(Color.White, PieceType.King),
|
||||
Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
|
||||
)
|
||||
// Build PGN from this custom board is hard, so test strictParseAlgebraicMove directly
|
||||
val board = Board(pieces)
|
||||
// Both rooks can reach d1 — "Rad1" should pick the a-file rook
|
||||
val result = PgnParser.validatePgn("[Event \"T\"]\n\n1. e4")
|
||||
// This tests the main flow; below we test disambiguation in isolation
|
||||
result.isRight shouldBe true
|
||||
|
||||
test("validatePgn: ambiguous move without disambiguation returns Left"):
|
||||
// Set up a position where two identical pieces can reach the same square
|
||||
// We can test this via the strict path: two rooks, target square, no disambiguation hint
|
||||
// Build it through a sequence that leads to two rooks on same file targeting same square
|
||||
// This is hard to construct via PGN alone; verify via a known impossible disambiguation
|
||||
val pgn = "[Event \"T\"]\n\n1. e4"
|
||||
PgnParser.validatePgn(pgn).isRight shouldBe true
|
||||
Reference in New Issue
Block a user