crossmate

XDDecorationTests.swift (12436B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("XD Decorations section")
 @MainActor
 struct XDDecorationTests {
     /// A 3x3 puzzle whose grid and clues stay fixed across these tests so each
     /// case varies only the `## Decorations` section under examination.
     private static func source(decorations: String?) -> String {
         let base = """
         Title: Decorations
 
 
         ABC
         DEF
         GHI
 
 
         A1. Row 1 ~ ABC
         A4. Row 2 ~ DEF
         A7. Row 3 ~ GHI
         D1. Col 1 ~ ADG
         D2. Col 2 ~ BEH
         D3. Col 3 ~ CFI
         """
         guard let decorations else { return base }
         return base + "\n\n\n## Decorations\n\n" + decorations
     }
 
     // MARK: - Absence
 
     @Test("A source with no Decorations section parses with no decorations")
     func absentSectionYieldsNoDecorations() throws {
         let xd = try XD.parse(Self.source(decorations: nil))
         #expect(xd.decorations.isEmpty)
         #expect(Puzzle(xd: xd).decorations.isEmpty)
     }
 
     // MARK: - Marks and the Specials migration
 
     @Test("mark definitions populate Cell.special, replacing the Specials header")
     func markPopulatesCellSpecial() throws {
         let puzzle = Puzzle(xd: try XD.parse(Self.source(decorations: """
         O.S
         ...
         ..O
 
         O. mark=circle
         S. mark=shaded
         """)))
 
         #expect(puzzle.cells[0][0].special == .circled)
         #expect(puzzle.cells[0][2].special == .shaded)
         #expect(puzzle.cells[2][2].special == .circled)
         #expect(puzzle.cells[0][1].special == nil)
         #expect(puzzle.cells[1][1].special == nil)
         // The fill still comes from the grid, untouched by the decoration.
         #expect(puzzle.cells[0][0].solution == "A")
     }
 
     @Test("mark accepts both circle and circled")
     func markAcceptsBothCircleSpellings() throws {
         let puzzle = Puzzle(xd: try XD.parse(Self.source(decorations: """
         AB.
         ...
         ...
 
         A. mark=circle
         B. mark=circled
         """)))
 
         #expect(puzzle.cells[0][0].special == .circled)
         #expect(puzzle.cells[0][1].special == .circled)
     }
 
     @Test("An after-phase mark does not become a Cell.special")
     func afterPhaseMarkIsNotACellSpecial() throws {
         let xd = try XD.parse(Self.source(decorations: """
         O..
         ...
         ...
 
         O. mark=circle after
         """))
         let puzzle = Puzzle(xd: xd)
 
         // It is still carried as a decoration; it just isn't visible from the
         // start, so it must not feed the always-drawn `special` path.
         #expect(puzzle.cells[0][0].special == nil)
         #expect(puzzle.decorations[GridPosition(row: 0, col: 0)]?.count == 1)
     }
 
     // MARK: - Stacking
 
     @Test("Repeating a character stacks layers in definition order")
     func repeatedCharacterStacksLayers() throws {
         let xd = try XD.parse(Self.source(decorations: """
         4..
         ...
         ...
 
         4. text=🌈
         4. bg=#00AA00 after
         """))
 
         let layers = try #require(xd.decorations[GridPosition(row: 0, col: 0)])
         #expect(layers.count == 2)
         #expect(layers[0] == Puzzle.Decoration(content: .text("🌈"), phase: .before))
         #expect(layers[1] == Puzzle.Decoration(
             content: .color(layer: .background, light: "#00AA00", dark: nil),
             phase: .after
         ))
     }
 
     @Test("A stacked character applies every layer to each of its cells")
     func stackedCharacterAppliesToAllItsCells() throws {
         let xd = try XD.parse(Self.source(decorations: """
         X.X
         ...
         ...
 
         X. mark=shaded
         X. text=!
         """))
 
         #expect(xd.decorations[GridPosition(row: 0, col: 0)]?.count == 2)
         #expect(xd.decorations[GridPosition(row: 0, col: 2)]?.count == 2)
         #expect(xd.decorations[GridPosition(row: 0, col: 1)] == nil)
     }
 
     // MARK: - Phase
 
     @Test("Phase defaults to before when the keyword is omitted")
     func phaseDefaultsToBefore() throws {
         let xd = try XD.parse(Self.source(decorations: """
         A..
         ...
         ...
 
         A. text=x
         """))
         #expect(xd.decorations[GridPosition(row: 0, col: 0)]?.first?.phase == .before)
     }
 
     @Test("An explicit before keyword is accepted")
     func explicitBeforeIsAccepted() throws {
         let xd = try XD.parse(Self.source(decorations: """
         A..
         ...
         ...
 
         A. text=x before
         """))
         let layer = try #require(xd.decorations[GridPosition(row: 0, col: 0)]?.first)
         #expect(layer.phase == .before)
         #expect(layer.content == .text("x"))
     }
 
     // MARK: - Colours
 
     @Test("bg and fg carry their appearance variants in the value")
     func colorKindsCarryVariantsInTheValue() throws {
         let xd = try XD.parse(Self.source(decorations: """
         12.
         34.
         ...
 
         1. bg=#111111
         2. bg=#222222;#333333
         3. fg=#444444
         4. fg=#555555;#666666
         """))
 
         func content(_ row: Int, _ col: Int) throws -> Puzzle.Decoration.Content {
             try #require(xd.decorations[GridPosition(row: row, col: col)]?.first?.content)
         }
 
         // A lone colour applies to both appearances, so `dark` stays nil rather
         // than being filled in with a copy.
         #expect(try content(0, 0) == .color(layer: .background, light: "#111111", dark: nil))
         #expect(try content(0, 1) == .color(layer: .background, light: "#222222", dark: "#333333"))
         #expect(try content(1, 0) == .color(layer: .foreground, light: "#444444", dark: nil))
         #expect(try content(1, 1) == .color(layer: .foreground, light: "#555555", dark: "#666666"))
     }
 
     @Test("A colour value with the wrong number of parts is skipped")
     func malformedColorValueIsSkipped() throws {
         let xd = try XD.parse(Self.source(decorations: """
         12.
         3..
         ...
 
         1. bg=#111111;#222222;#333333
         2. bg=#111111;
         3. bg=;#222222
         """))
         // Structurally sound lines, so the section still parses and the design
         // characters still resolve — the layers themselves are just dropped.
         #expect(xd.decorations.isEmpty)
     }
 
     // MARK: - Text
 
     @Test("A text value keeps its internal spaces")
     func textValueKeepsInternalSpaces() throws {
         let xd = try XD.parse(Self.source(decorations: """
         A..
         ...
         ...
 
         A. text=NEW YORK after
         """))
         let layer = try #require(xd.decorations[GridPosition(row: 0, col: 0)]?.first)
         #expect(layer.content == .text("NEW YORK"))
         #expect(layer.phase == .after)
     }
 
     // MARK: - Data
 
     @Test("A data value splits into mime type, encoding and payload")
     func dataValueSplitsIntoParts() throws {
         let xd = try XD.parse(Self.source(decorations: """
         A..
         ...
         ...
 
         A. data=image/png;base64,iVBORw0KGgo= after
         """))
         let layer = try #require(xd.decorations[GridPosition(row: 0, col: 0)]?.first)
         #expect(layer.content == .data(
             mimeType: "image/png",
             encoding: "base64",
             payload: "iVBORw0KGgo="
         ))
         #expect(layer.phase == .after)
     }
 
     @Test("A data value with no encoding defaults to base64")
     func dataValueDefaultsToBase64() throws {
         let xd = try XD.parse(Self.source(decorations: """
         A..
         ...
         ...
 
         A. data=image/png,iVBORw0KGgo=
         """))
         #expect(xd.decorations[GridPosition(row: 0, col: 0)]?.first?.content == .data(
             mimeType: "image/png",
             encoding: "base64",
             payload: "iVBORw0KGgo="
         ))
     }
 
     @Test("Base64 padding does not confuse the key/value split")
     func base64PaddingSurvivesTheSplit() throws {
         // The value is split on the *first* `=`, so trailing padding stays in
         // the payload rather than being read as another key/value boundary.
         let xd = try XD.parse(Self.source(decorations: """
         A..
         ...
         ...
 
         A. data=image/png;base64,QUJDRA==
         """))
         guard case .data(_, _, let payload) =
             try #require(xd.decorations[GridPosition(row: 0, col: 0)]?.first?.content) else {
             Issue.record("expected a data decoration")
             return
         }
         #expect(payload == "QUJDRA==")
     }
 
     // MARK: - Forward compatibility
 
     @Test("An unrecognised kind is skipped without failing the section")
     func unrecognisedKindIsSkipped() throws {
         let xd = try XD.parse(Self.source(decorations: """
         AB.
         ...
         ...
 
         A. sparkle=magenta
         B. mark=shaded
         """))
 
         // The character is still 'defined', so its design-grid cell resolves
         // instead of throwing — a newer spec revision must not break the file.
         #expect(xd.decorations[GridPosition(row: 0, col: 0)] == nil)
         #expect(xd.decorations[GridPosition(row: 0, col: 1)]?.count == 1)
     }
 
     @Test("An unrecognised mark value is skipped without failing the section")
     func unrecognisedMarkValueIsSkipped() throws {
         let xd = try XD.parse(Self.source(decorations: """
         A..
         ...
         ...
 
         A. mark=hexagon
         """))
         #expect(xd.decorations.isEmpty)
     }
 
     // MARK: - Failures
 
     @Test("A design grid of the wrong size is rejected")
     func wrongSizedDesignGridIsRejected() throws {
         #expect(throws: XD.ParseError.self) {
             try XD.parse(Self.source(decorations: """
             A..
             ...
 
             A. mark=circle
             """))
         }
     }
 
     @Test("A design grid with a ragged row is rejected")
     func raggedDesignGridIsRejected() throws {
         #expect(throws: XD.ParseError.self) {
             try XD.parse(Self.source(decorations: """
             A..
             ....
             ...
 
             A. mark=circle
             """))
         }
     }
 
     @Test("A design character with no definition is rejected")
     func undefinedDesignCharacterIsRejected() throws {
         #expect(throws: XD.ParseError.self) {
             try XD.parse(Self.source(decorations: """
             A.Z
             ...
             ...
 
             A. mark=circle
             """))
         }
     }
 
     @Test("A definition line with no key/value pair is rejected")
     func definitionWithoutPairIsRejected() throws {
         #expect(throws: XD.ParseError.self) {
             try XD.parse(Self.source(decorations: """
             A..
             ...
             ...
 
             A. circle
             """))
         }
     }
 
     @Test("A definition line with a multi-character key is rejected")
     func multiCharacterKeyIsRejected() throws {
         #expect(throws: XD.ParseError.self) {
             try XD.parse(Self.source(decorations: """
             A..
             ...
             ...
 
             AB. mark=circle
             """))
         }
     }
 
     // MARK: - Section handling
 
     @Test("The grid may follow the definitions")
     func gridMayFollowDefinitions() throws {
         // Grid and definition lines are told apart by whitespace, not order.
         let xd = try XD.parse(Self.source(decorations: """
         A. mark=circle
 
         A..
         ...
         ...
         """))
         #expect(xd.decorations[GridPosition(row: 0, col: 0)]?.count == 1)
     }
 
     @Test("An unrecognised named section is ignored")
     func unrecognisedNamedSectionIsIgnored() throws {
         let source = Self.source(decorations: """
         A..
         ...
         ...
 
         A. mark=circle
         """) + "\n\n\n## Notes\n\nSome trailing prose."
 
         let xd = try XD.parse(source)
         #expect(xd.decorations[GridPosition(row: 0, col: 0)]?.count == 1)
         #expect(xd.acrossClues.count == 3)
     }
 
     @Test("An all-block grid row is not mistaken for a section header")
     func allBlockRowIsNotASectionHeader() throws {
         // `#` is the block character, so a row of blocks superficially looks
         // like a `##` section marker.
         let xd = try XD.parse("""
         Title: Blocks
 
 
         ABC
         ###
         DEF
 
 
         A1. Row 1 ~ ABC
         A4. Row 3 ~ DEF
         D1. Col 1 ~ A
         D2. Col 2 ~ B
         D3. Col 3 ~ C
         """)
         #expect(xd.height == 3)
         #expect(xd.width == 3)
     }
 }