crossmate

XDAcceptTests.swift (17837B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("XD Accept metadata")
 @MainActor
 struct XDAcceptTests {
     @Test("Missing converter version defaults to one")
     func missingConverterVersionDefaultsToOne() throws {
         let xd = try XD.parse("""
         Title: Versionless
 
 
         A
 
 
         A1. Letter ~ A
         D1. Letter ~ A
         """)
 
         #expect(xd.converterVersion == 1)
     }
 
     @Test("Explicit positive ConVer is parsed")
     func explicitConVerIsParsed() throws {
         let xd = try XD.parse("""
         Title: Versioned
         ConVer: 3
 
 
         A
 
 
         A1. Letter ~ A
         D1. Letter ~ A
         """)
 
         #expect(xd.converterVersion == 3)
     }
 
     @Test("Legacy CmVer header still parses as the converter version")
     func legacyCmVerHeaderParses() throws {
         let xd = try XD.parse("""
         Title: Legacy
         CmVer: 3
 
 
         A
 
 
         A1. Letter ~ A
         D1. Letter ~ A
         """)
 
         #expect(xd.converterVersion == 3)
     }
 
     @Test("ConVer takes precedence over a legacy CmVer when both are present")
     func conVerWinsOverLegacyCmVer() throws {
         let xd = try XD.parse("""
         Title: Both
         ConVer: 8
         CmVer: 3
 
 
         A
 
 
         A1. Letter ~ A
         D1. Letter ~ A
         """)
 
         #expect(xd.converterVersion == 8)
     }
 
     @Test("settingConverterVersionHeader rewrites an existing ConVer in place")
     func stampRewritesExistingConVer() throws {
         let source = """
         Title: Versioned
         ConVer: 3
 
 
         A
 
 
         A1. Letter ~ A
         D1. Letter ~ A
         """
         let stamped = XD.settingConverterVersionHeader(in: source, to: 8)
 
         #expect(!stamped.contains("ConVer: 3"))
         #expect(try XD.parse(stamped).converterVersion == 8)
         #expect(try XD.parse(stamped).width == 1) // grid untouched
     }
 
     @Test("settingConverterVersionHeader upgrades a legacy CmVer to ConVer")
     func stampUpgradesLegacyCmVer() throws {
         let source = """
         Title: Legacy
         CmVer: 3
 
 
         A
 
 
         A1. Letter ~ A
         D1. Letter ~ A
         """
         let stamped = XD.settingConverterVersionHeader(in: source, to: 8)
 
         #expect(stamped.contains("ConVer: 8"))
         #expect(!stamped.contains("CmVer:"))
         #expect(try XD.parse(stamped).converterVersion == 8)
     }
 
     @Test("settingConverterVersionHeader inserts a header when none is present")
     func stampInsertsWhenAbsent() throws {
         let source = """
         Title: Versionless
 
 
         A
 
 
         A1. Letter ~ A
         D1. Letter ~ A
         """
         let stamped = XD.settingConverterVersionHeader(in: source, to: 8)
         let xd = try XD.parse(stamped)
 
         #expect(xd.converterVersion == 8)
         #expect(xd.title == "Versionless") // metadata + grid intact
     }
 
     @Test("Rebus value escapes decode: \\space to a blank, \\\\ to a backslash")
     func rebusValueEscapesDecode() throws {
         // `\space` lets a gap cell's blank fill survive the whitespace-split
         // Rebus header; `\\` is the defensive literal-backslash escape. Grid
         // "A1B2": cell 1 is the space fill, cell 2 a backslash-bearing fill.
         let puzzle = Puzzle(xd: try XD.parse(#"""
         Title: Gaps
         CmVer: 5
         Rebus: 1=\space 2=C\\D
 
 
         A1B2
 
 
         A1. Row ~ A BC\D
         """#))
 
         #expect(puzzle.cells[0][0].solution == "A")
         #expect(puzzle.cells[0][1].solution == " ")
         #expect(puzzle.cells[0][2].solution == "B")
         #expect(puzzle.cells[0][3].solution == "C\\D")
     }
 
     @Test("A gap cell is solved by leaving it blank")
     func gapCellSolvedWhenBlank() throws {
         // "TO BE" with the gap at col 2 (the space fill). The gap is correct
         // when empty and needs no fill for completion; a stray letter in it is
         // wrong.
         let source = #"""
         Title: Gap
         CmVer: 5
         Rebus: 1=\space
 
 
         TO1BE
 
 
         A1. Repeated part of a soliloquy ~ TO BE
         """#
         let puzzle = Puzzle(xd: try XD.parse(source))
 
         let gap = puzzle.cells[0][2]
         #expect(gap.expectsBlank)
         #expect(gap.accepts(""))        // blank is the correct state
         #expect(!gap.accepts("B"))      // a letter is not
         #expect(!puzzle.cells[0][0].accepts(""))  // ordinary cells still need a fill
 
         let game = Game(puzzle: Puzzle(xd: try XD.parse(source)))
         game.setLetter("T", atRow: 0, atCol: 0, pencil: false)
         game.setLetter("O", atRow: 0, atCol: 1, pencil: false)
         game.setLetter("B", atRow: 0, atCol: 3, pencil: false)
         game.setLetter("E", atRow: 0, atCol: 4, pencil: false)
         // The gap at col 2 is left empty.
         #expect(game.completionState == .solved)
 
         // A stray letter in the gap surfaces as an error rather than completion.
         game.setLetter("X", atRow: 0, atCol: 2, pencil: false)
         #expect(game.completionState == .filledWithErrors)
     }
 
     @Test("Special symbols parse per cell")
     func specialSymbolsParsePerCell() throws {
         let puzzle = Puzzle(xd: try XD.parse("""
         Title: Specials
         CmVer: 3
         Specials: @=circle *=shaded
 
 
         @B@
         D**
 
 
         A1. Row 1 ~ ABC
         A4. Row 2 ~ DEF
         D1. Col 1 ~ AD
         D2. Col 2 ~ BE
         D3. Col 3 ~ CF
         """))
 
         #expect(puzzle.cells[0][0].special == .circled)
         #expect(puzzle.cells[0][2].special == .circled)
         #expect(puzzle.cells[1][1].special == .shaded)
         #expect(puzzle.cells[1][2].special == .shaded)
         #expect(puzzle.cells[0][1].special == nil)
         #expect(puzzle.cells[0][0].solution == "A")
         #expect(puzzle.cells[1][1].solution == "E")
     }
 
     @Test("A rebus placeholder can also mark a special cell")
     func rebusPlaceholderCanAlsoMarkSpecialCell() throws {
         let puzzle = Puzzle(xd: try XD.parse("""
         Title: Shaded Rebus
         Rebus: 1=HEART
         Specials: 1=shaded
 
 
         1
 
 
         A1. Rebus ~ HEART
         """))
 
         #expect(puzzle.cells[0][0].solution == "HEART")
         #expect(puzzle.cells[0][0].special == .shaded)
     }
 
     @Test("Conflicting inferred special symbols fail parsing")
     func conflictingInferredSpecialSymbolsFailParsing() throws {
         #expect(throws: XD.ParseError.self) {
             try XD.parse("""
             Title: Conflicting Specials
             CmVer: 3
             Specials: @=circle
 
 
             @BC
             DEF
 
 
             A1. Row 1 ~ ABC
             A4. Row 2 ~ DEF
             D1. Col 1 ~ ZD
             D2. Col 2 ~ BE
             D3. Col 3 ~ CF
             """)
         }
     }
 
     @Test("Unfilled special symbols fail parsing")
     func unfilledSpecialSymbolsFailParsing() throws {
         #expect(throws: XD.ParseError.self) {
             try XD.parse("""
             Title: Unfilled Specials
             CmVer: 3
             Specials: @=circle
 
 
             @
 
 
             """)
         }
     }
 
     @Test("Ambiguous inferred special symbols fail parsing")
     func ambiguousInferredSpecialSymbolsFailParsing() throws {
         #expect(throws: XD.ParseError.self) {
             try XD.parse("""
             Title: Ambiguous Specials
             CmVer: 3
             Specials: @=circle
 
 
             @B@
 
 
             A1. Row 1 ~ ABBBC
             D1. Col 1 ~ A
             D2. Col 2 ~ B
             D3. Col 3 ~ C
             """)
         }
     }
 
     @Test("Standard XD Special header marks lowercase cells")
     func standardXDSpecialHeaderMarksLowercaseCells() throws {
         let puzzle = Puzzle(xd: try XD.parse("""
         Title: Standard Special
         CmVer: 3
         Special: circle
 
 
         aBC
 
 
         A1. Row ~ ABC
         D1. Col 1 ~ A
         D2. Col 2 ~ B
         D3. Col 3 ~ C
         """))
 
         #expect(puzzle.cells[0][0].special == .circled)
         #expect(puzzle.cells[0][1].special == nil)
     }
 
     @Test("Clue metadata is parsed generically")
     func clueMetadataParsesGenerically() throws {
         let source = """
         Title: Metadata Test
 
 
         ABC
 
 
         A1. Gardener's concerns. ~ ABC
         A1 ^Refs: A2 D4
         A1 ^Note: first value
         A1 ^Note: second value
         """
 
         let xd = try XD.parse(source)
         let clue = try #require(xd.acrossClues.first)
 
         #expect(clue.text == "Gardener's concerns.")
         #expect(clue.answer == "ABC")
         #expect(clue.metadata["Refs"] == ["A2 D4"])
         #expect(clue.metadata["Note"] == ["first value", "second value"])
     }
 
     @Test("Accept metadata parses escaped tokens onto matching rebus cells")
     func acceptMetadataParsesEscapedTokens() throws {
         let source = """
         Title: Accept Test
         Rebus: 1=PHI
 
 
         1A
 
 
         A1. Greek letter represented in the puzzle. ~ PHI
         A1 ^Accept: IO OI I/O NEW\\ YORK A\\|B BACK\\\\SLASH
         """
 
         let puzzle = Puzzle(xd: try XD.parse(source))
         let acceptClue = try #require(try XD.parse(source).acrossClues.first)
         let cell = puzzle.cells[0][0]
 
         #expect(acceptClue.metadata["Accept"] == ["IO OI I/O NEW\\ YORK A\\|B BACK\\\\SLASH"])
         #expect(acceptClue.acceptedAnswers == ["IO", "OI", "I/O", "NEW YORK", "A|B", "BACK\\SLASH"])
         #expect(cell.accepts("PHI"))
         #expect(cell.accepts("io"))
         #expect(cell.accepts("NEW YORK"))
         #expect(cell.accepts("A|B"))
         #expect(cell.accepts("BACK\\SLASH"))
         #expect(!cell.accepts("NYC"))
     }
 
     @Test("Accepted answers are case-insensitive")
     func acceptedAnswersNormalizeCaseForCompletion() throws {
         let source = """
         Title: Normalize Test
         Rebus: 1=PHI
 
 
         1A
 
 
         A1. Greek letter represented in the puzzle. ~ PHI
         A1 ^Accept: PHI
         """
 
         let game = Game(puzzle: Puzzle(xd: try XD.parse(source)))
         game.setLetter("phi", atRow: 0, atCol: 0, pencil: false)
 
         #expect(game.completionState == .solved)
     }
 
     @Test("Non-ASCII clue prose is allowed")
     func nonASCIIClueProseIsAllowed() throws {
         let puzzle = Puzzle(xd: try XD.parse("""
         Title: Clue Emoji
 
 
         A
 
 
         A1. Emoji clue is fine 🔥 ~ A
         D1. Accented clue is fine café ~ A
         """))
 
         #expect(puzzle.acrossClues[0].text == "Emoji clue is fine 🔥")
         #expect(puzzle.downClues[0].text == "Accented clue is fine café")
         #expect(puzzle.cells[0][0].solution == "A")
     }
 
     @Test("Non-ASCII answer content is rejected without an ASCII alternative")
     func nonASCIIAnswerContentIsRejectedWithoutASCIIAlternative() {
         #expect(throws: XD.ParseError.self) {
             try XD.parse("""
             Title: Emoji Answer
             Rebus: 1=🔥
 
 
             1A
             BA
 
 
             A1. Hot stuff ~ 🔥A
             D1. Hot stuff ~ 🔥B
             """)
         }
 
         #expect(throws: XD.ParseError.self) {
             try XD.parse("""
             Title: Unicode Grid
 
 
             ΦA
             BA
 
 
             A1. Greek letter ~ ΦA
             D1. Greek letter ~ ΦB
             """)
         }
     }
 
     @Test("Non-ASCII answer content is allowed with an ASCII alternative")
     func nonASCIIAnswerContentIsAllowedWithASCIIAlternative() throws {
         let emojiPuzzle = Puzzle(xd: try XD.parse("""
         Title: Emoji Answer
         Rebus: 1=🔥
 
 
         1A
         BA
 
 
         A1. Hot stuff ~ 🔥A
         A1 ^Accept: FIREA
         D1. Hot stuff ~ 🔥B
         D1 ^Accept: FIREB
         """))
 
         let emojiCell = emojiPuzzle.cells[0][0]
         #expect(emojiCell.solution == "🔥")
         #expect(emojiCell.accepts("FIRE"))
 
         let greekPuzzle = Puzzle(xd: try XD.parse("""
         Title: Unicode Grid
 
 
         ΦA
         BA
 
 
         A1. Greek letter ~ ΦA
         A1 ^Accept: PHIA
         D1. Greek letter ~ ΦB
         D1 ^Accept: PHIB
         """))
 
         let greekCell = greekPuzzle.cells[0][0]
         #expect(greekCell.solution == "Φ")
         #expect(greekCell.accepts("PHI"))
     }
 
     @Test("Whole-clue accepted answers project onto changed cells")
     func acceptedClueAnswersProjectOntoCells() throws {
         let source = """
         Title: Projection Test
         Rebus: 1=IO
 
 
         P1NG
 
 
         A1. Paddle sport starter. ~ PIONG
         A1 ^Accept: PPHING PI/ONG
         """
 
         let puzzle = Puzzle(xd: try XD.parse(source))
         let cell = puzzle.cells[0][1]
 
         #expect(cell.solution == "IO")
         #expect(cell.accepts("PHI"))
         #expect(cell.accepts("I/O"))
         #expect(!puzzle.cells[0][0].accepts("PHI"))
     }
 
     @Test("Slash ~ field accepts a single magic-square alternate")
     func slashFieldAcceptsMagicSquare() throws {
         let source = """
         Title: Magic Square
         CmVer: 3
 
 
         ABC
 
 
         A1. Three letters ~ ABC / ADC
         """
 
         let xd = try XD.parse(source)
         let clue = try #require(xd.acrossClues.first)
 
         #expect(clue.answer == "ABC")
         #expect(clue.alternativeAnswers == ["ADC"])
         #expect(clue.acceptedAnswers == ["ADC"])
 
         let puzzle = Puzzle(xd: xd)
         #expect(puzzle.cells[0][1].solution == "B")
         #expect(puzzle.cells[0][1].accepts("D"))
         #expect(!puzzle.cells[0][0].accepts("D"))
         #expect(!puzzle.cells[0][2].accepts("D"))
     }
 
     @Test("Slash ~ field accepts a whole-word alternate where every cell differs")
     func slashFieldAcceptsWholeWordAlternate() throws {
         let source = """
         Title: Whole Word
         CmVer: 3
 
 
         CIGAR
 
 
         A1. Cigar, to a Freudian ~ CIGAR / PENIS
         """
 
         let xd = try XD.parse(source)
         let clue = try #require(xd.acrossClues.first)
 
         #expect(clue.answer == "CIGAR")
         #expect(clue.alternativeAnswers == ["PENIS"])
 
         let puzzle = Puzzle(xd: xd)
         let canonical = Array("CIGAR")
         let alternate = Array("PENIS")
         for column in 0..<5 {
             #expect(puzzle.cells[0][column].solution == String(canonical[column]))
             #expect(puzzle.cells[0][column].accepts(String(alternate[column])))
         }
     }
 
     @Test("Free cells receive a unique answer segmentation")
     func freeCellsReceiveUniqueSegmentation() throws {
         // A '.' cell has no known solution, so the clue answer must be
         // distributed across it. "XYB" over `.B` has exactly one valid split:
         // the free cell takes "XY" and the fixed 'B' cell matches "B".
         let puzzle = Puzzle(xd: try XD.parse("""
         Title: Segmentation
         CmVer: 3
 
 
         .B
 
 
         A1. Two cells ~ XYB
         """))
 
         #expect(puzzle.cells[0][0].solution == "XY")
         #expect(puzzle.cells[0][1].solution == "B")
     }
 
     @Test("Unsegmentable answer over many free cells fails fast")
     func unsegmentableAnswerOverManyFreeCellsFailsFast() throws {
         // 30 free cells followed by a fixed 'Z', with a 61-char answer that
         // does not end in Z. No valid segmentation exists, so the naive
         // recursion would explore every one of C(59, 29) ≈ 10^16 compositions
         // before failing — effectively forever. The memoized word-break DP
         // collapses this to O(cells × answer), so parsing returns promptly with
         // a mismatch. If this test hangs, the memoization has regressed.
         let grid = String(repeating: ".", count: 30) + "Z"
         let answer = String(repeating: "A", count: 61)
         let source = """
         Title: DoS
         CmVer: 3
 
 
         \(grid)
 
 
         A1. Crafted ~ \(answer)
         """
 
         #expect(throws: XD.ParseError.self) {
             try XD.parse(source)
         }
     }
 
     @Test("Oversized source is rejected before parsing")
     func oversizedSourceIsRejected() throws {
         let source = String(repeating: "A", count: XD.maxSourceBytes + 1)
 
         do {
             _ = try XD.parse(source)
             Issue.record("expected parse to throw sourceTooLarge")
         } catch let error as XD.ParseError {
             guard case .sourceTooLarge = error else {
                 Issue.record("expected sourceTooLarge, got \(error)")
                 return
             }
         }
     }
 
     @Test("A source at the size limit still parses")
     func sourceAtLimitParses() throws {
         // A well-formed minimal puzzle padded with comment-free filler in the
         // metadata section up to exactly the cap must still parse — the bound is
         // inclusive and far above any real puzzle.
         let base = """
         Title: Padded
 
 
         A
 
 
         A1. Letter ~ A
         D1. Letter ~ A
         """
         let padding = String(repeating: " ", count: XD.maxSourceBytes - base.utf8.count)
         let source = base + padding
 
         #expect(source.utf8.count == XD.maxSourceBytes)
         #expect(throws: Never.self) {
             try XD.parse(source)
         }
     }
 
     @Test("Over-long clue text is rejected")
     func overLongClueTextIsRejected() throws {
         let longText = String(repeating: "x", count: XD.maxClueTextLength + 1)
         let source = """
         Title: Long Clue
 
 
         AB
 
 
         A1. \(longText) ~ AB
         """
 
         #expect(throws: XD.ParseError.self) {
             try XD.parse(source)
         }
     }
 
     @Test("Check accepts alternate entries")
     func checkAcceptsAlternateEntries() throws {
         let source = """
         Title: Check Test
         Rebus: 1=PHI
 
 
         1A
 
 
         A1. Greek letter represented in the puzzle. ~ PHI
         A1 ^Accept: IO
         """
 
         let game = Game(puzzle: Puzzle(xd: try XD.parse(source)))
         game.setLetter("IO", atRow: 0, atCol: 0, pencil: false)
         game.checkCells([game.puzzle.cells[0][0]])
 
         #expect(game.squares[0][0].mark == .pen(checked: .right))
     }
 }