crossmate

XDAcceptTests.swift (10071B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("XD Accept metadata")
 @MainActor
 struct XDAcceptTests {
     @Test("Missing CmVer defaults to one")
     func missingCmVerDefaultsToOne() throws {
         let xd = try XD.parse("""
         Title: Versionless
 
 
         A
 
 
         A1. Letter ~ A
         D1. Letter ~ A
         """)
 
         #expect(xd.cmVersion == 1)
     }
 
     @Test("Explicit positive CmVer is parsed")
     func explicitCmVerIsParsed() throws {
         let xd = try XD.parse("""
         Title: Versioned
         CmVer: 3
 
 
         A
 
 
         A1. Letter ~ A
         D1. Letter ~ A
         """)
 
         #expect(xd.cmVersion == 3)
     }
 
     @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("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 and NFC-normalized")
     func acceptedAnswersNormalizeForCompletion() throws {
         let source = """
         Title: Normalize Test
         Rebus: 1=PHI
 
 
         1A
 
 
         A1. Greek letter represented in the puzzle. ~ PHI
         A1 ^Accept: CAF\\É
         """
 
         let game = Game(puzzle: Puzzle(xd: try XD.parse(source)))
         game.setLetter("cafe\u{301}", atRow: 0, atCol: 0, pencil: false)
 
         #expect(game.completionState == .solved)
     }
 
     @Test("Whole-clue accepted answers project onto changed cells")
     func acceptedClueAnswersProjectOntoCells() throws {
         let source = """
         Title: Projection Test
         Rebus: 1=Φ
 
 
         P1NG
 
 
         A1. Paddle sport starter. ~ PΦNG
         A1 ^Accept: PPHING PI/ONG
         """
 
         let puzzle = Puzzle(xd: try XD.parse(source))
         let cell = puzzle.cells[0][1]
 
         #expect(cell.solution == "Φ")
         #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("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))
     }
 }