crossmate

XDLimitsTests.swift (7292B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 /// Adversarial boundary coverage for the parser's pre-allocation budgets:
 /// grid geometry, clue count, per-clue text/metadata/answer lengths, accepted
 /// answers, and rebus expansions. Each limit is tested from both sides — the
 /// hostile case fails closed, the maximum legitimate case still parses.
 @Suite("XD parsing limits")
 struct XDLimitsTests {
 
     /// Parses the source, returning the ParseError it threw (nil on success
     /// or on a non-ParseError failure).
     private func parseError(from source: String) -> XD.ParseError? {
         do {
             _ = try XD.parse(source)
             return nil
         } catch let error as XD.ParseError {
             return error
         } catch {
             return nil
         }
     }
 
     // MARK: - Grid geometry
 
     @Test("A grid wider than the maximum is rejected before allocation")
     func gridWiderThanMaximumIsRejected() {
         let row = String(repeating: "A", count: XD.maxGridDimension + 1)
         let source = """
         Title: Wide
 
 
         \(row)
 
 
         A1. Never reached
         """
 
         guard case .some(.gridTooLarge) = parseError(from: source) else {
             Issue.record("expected gridTooLarge")
             return
         }
     }
 
     @Test("A grid taller than the maximum is rejected before allocation")
     func gridTallerThanMaximumIsRejected() {
         let rows = Array(repeating: "A", count: XD.maxGridDimension + 1).joined(separator: "\n")
         let source = """
         Title: Tall
 
 
         \(rows)
 
 
         D1. Never reached
         """
 
         guard case .some(.gridTooLarge) = parseError(from: source) else {
             Issue.record("expected gridTooLarge")
             return
         }
     }
 
     @Test("A grid at the maximum width still parses")
     func gridAtMaximumWidthParses() throws {
         let row = String(repeating: "A", count: XD.maxGridDimension)
         let source = """
         Title: Widest
 
 
         \(row)
 
 
         A1. All As
         """
 
         let xd = try XD.parse(source)
         #expect(xd.width == XD.maxGridDimension)
         #expect(xd.height == 1)
     }
 
     @Test("A grid at the maximum height still parses")
     func gridAtMaximumHeightParses() throws {
         let rows = Array(repeating: "A", count: XD.maxGridDimension).joined(separator: "\n")
         let source = """
         Title: Tallest
 
 
         \(rows)
 
 
         D1. All As
         """
 
         let xd = try XD.parse(source)
         #expect(xd.width == 1)
         #expect(xd.height == XD.maxGridDimension)
     }
 
     @Test("A maximum-width all-open row with an answer-less clue fails closed")
     func answerlessOpenRowFailsClosed() {
         // The audit's quadratic shape: one long open row whose only clue has
         // no answer. The word-scoped passes visit the row once and the missing
         // inferred solutions reject it promptly.
         let row = String(repeating: ".", count: XD.maxGridDimension)
         let source = """
         Title: Open Row
 
 
         \(row)
 
 
         A1. No answer given
         """
 
         guard case .some(.missingInferredSolution) = parseError(from: source) else {
             Issue.record("expected missingInferredSolution")
             return
         }
     }
 
     // MARK: - Clue budgets
 
     @Test("More distinct clues than the maximum are rejected")
     func tooManyDistinctCluesAreRejected() {
         let clues = (1...(XD.maxClueCount + 1))
             .map { "A\($0). x" }
             .joined(separator: "\n")
         let source = """
         Title: Cluepocalypse
 
 
         A
 
 
         \(clues)
         """
 
         guard case .some(.tooManyClues) = parseError(from: source) else {
             Issue.record("expected tooManyClues")
             return
         }
     }
 
     @Test("A clue count at the maximum still parses")
     func clueCountAtMaximumParses() throws {
         let clues = (1...XD.maxClueCount)
             .map { "A\($0). x" }
             .joined(separator: "\n")
         let source = """
         Title: Many Clues
 
 
         A
 
 
         \(clues)
         """
 
         let xd = try XD.parse(source)
         #expect(xd.acrossClues.count == XD.maxClueCount)
     }
 
     @Test("An over-long clue metadata value is rejected")
     func overLongClueMetadataValueIsRejected() {
         let value = String(repeating: "x", count: XD.maxClueTextLength + 1)
         let source = """
         Title: Long Metadata
 
 
         A
 
 
         A1. Letter ~ A
         A1 ^Note: \(value)
         """
 
         guard case .some(.malformedClue) = parseError(from: source) else {
             Issue.record("expected malformedClue")
             return
         }
     }
 
     @Test("An over-long answer reading is rejected")
     func overLongAnswerReadingIsRejected() {
         let answer = String(repeating: "A", count: XD.maxClueTextLength + 1)
         let source = """
         Title: Long Answer
 
 
         A
 
 
         A1. Letter ~ \(answer)
         """
 
         guard case .some(.malformedClue) = parseError(from: source) else {
             Issue.record("expected malformedClue")
             return
         }
     }
 
     @Test("More accepted answers than the maximum are rejected")
     func tooManyAcceptedAnswersAreRejected() {
         let tokens = (1...(XD.maxAcceptedAnswersPerClue + 1))
             .map { "B\($0)" }
             .joined(separator: " ")
         let source = """
         Title: Accepting
 
 
         A
 
 
         A1. Letter ~ A
         A1 ^Accept: \(tokens)
         """
 
         guard case .some(.tooManyAcceptedAnswers) = parseError(from: source) else {
             Issue.record("expected tooManyAcceptedAnswers")
             return
         }
     }
 
     @Test("An accepted-answer count at the maximum still parses")
     func acceptedAnswersAtMaximumParse() throws {
         let tokens = (1...XD.maxAcceptedAnswersPerClue)
             .map { "B\($0)" }
             .joined(separator: " ")
         let source = """
         Title: Accepting
 
 
         A
 
 
         A1. Letter ~ A
         A1 ^Accept: \(tokens)
         """
 
         let xd = try XD.parse(source)
         #expect(xd.acrossClues.first?.acceptedAnswers.count == XD.maxAcceptedAnswersPerClue)
     }
 
     // MARK: - Rebus budget
 
     @Test("An over-long rebus expansion fails closed at its grid cell")
     func overLongRebusValueFailsClosed() {
         let value = String(repeating: "A", count: XD.maxRebusValueLength + 1)
         let source = """
         Title: Big Rebus
         Rebus: 1=\(value)
 
 
         1
 
 
         A1. Never reached
         """
 
         guard case .some(.unknownGridCharacter) = parseError(from: source) else {
             Issue.record("expected unknownGridCharacter")
             return
         }
     }
 
     @Test("A rebus expansion at the maximum length still parses")
     func rebusValueAtMaximumParses() throws {
         let value = String(repeating: "A", count: XD.maxRebusValueLength)
         let source = """
         Title: Big Rebus
         Rebus: 1=\(value)
 
 
         1
 
 
         A1. Long fill ~ \(value)
         """
 
         let xd = try XD.parse(source)
         guard case .open(let solution?, _, _) = xd.cells[0][0] else {
             Issue.record("expected an open cell with a solution")
             return
         }
         #expect(solution.count == XD.maxRebusValueLength)
     }
 }