crossmate

PUZToXDConverterTests.swift (14294B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("PUZToXDConverter")
 struct PUZToXDConverterTests {
     @Test("Across Lite binary converts to XD and parses")
     func basicPuzzleConvertsAndParses() throws {
         let data = try puzData(
             width: 3,
             height: 3,
             solution: "ABCDEFGHI",
             title: "Mini PUZ",
             author: "Tester",
             copyright: "\u{00A9}2026",
             clues: [
                 "Across 1",
                 "Down 1",
                 "Down 2",
                 "Down 3",
                 "Across 4",
                 "Across 5"
             ]
         )
 
         let source = try PUZToXDConverter.convert(puzData: data)
         let xd = try XD.parse(source)
         let puzzle = Puzzle(xd: xd)
 
         #expect(puzzle.title == "Mini PUZ")
         #expect(puzzle.author == "Tester")
         #expect(xd.copyright == "\u{00A9}2026")
         #expect(puzzle.width == 3)
         #expect(puzzle.height == 3)
         #expect(puzzle.acrossClues.map(\.number) == [1, 4, 5])
         #expect(puzzle.downClues.map(\.number) == [1, 2, 3])
         #expect(xd.acrossClues.first?.answer == "ABC")
         #expect(xd.downClues.first?.answer == "ADG")
     }
 
     @Test("Blocks are translated to XD blocks")
     func blocksConvert() throws {
         let data = try puzData(
             width: 3,
             height: 3,
             solution: "ABC.D.EFG",
             title: "Blocks",
             author: "",
             copyright: "",
             clues: [
                 "Across 1",
                 "Down 2",
                 "Across 4"
             ]
         )
 
         let source = try PUZToXDConverter.convert(puzData: data)
         #expect(source.contains("ABC\n#D#\nEFG"))
 
         let puzzle = Puzzle(xd: try XD.parse(source))
         #expect(puzzle.cells[1][0].isBlock)
         #expect(puzzle.cells[1][2].isBlock)
     }
 
     @Test("All-uppercase PUZ title is displayed in title case")
     func uppercaseTitleIsTitleCased() throws {
         let data = try puzData(
             width: 3,
             height: 3,
             solution: "ABCDEFGHI",
             title: "THEMELESS MONDAY #875",
             author: "",
             copyright: "",
             clues: [
                 "Across 1",
                 "Down 1",
                 "Down 2",
                 "Down 3",
                 "Across 4",
                 "Across 5"
             ]
         )
 
         let puzzle = Puzzle(xd: try XD.parse(try PUZToXDConverter.convert(puzData: data)))
         #expect(puzzle.title == "Themeless Monday #875")
     }
 
     @Test("Mixed-case PUZ title is preserved")
     func mixedCaseTitleIsPreserved() throws {
         let data = try puzData(
             width: 3,
             height: 3,
             solution: "ABCDEFGHI",
             title: "Mini PUZ",
             author: "",
             copyright: "",
             clues: [
                 "Across 1",
                 "Down 1",
                 "Down 2",
                 "Down 3",
                 "Across 4",
                 "Across 5"
             ]
         )
 
         let puzzle = Puzzle(xd: try XD.parse(try PUZToXDConverter.convert(puzData: data)))
         #expect(puzzle.title == "Mini PUZ")
     }
 
     @Test("Circled cells emit a decorations section and keep their letters")
     func circledCellsEmitDecorationsSection() throws {
         let data = try puzData(
             width: 3,
             height: 3,
             solution: "ABCDEFGHI",
             title: "Circles",
             author: "",
             copyright: "",
             clues: [
                 "Across 1",
                 "Down 1",
                 "Down 2",
                 "Down 3",
                 "Across 4",
                 "Across 5"
             ],
             circledCells: [0, 4]
         )
 
         let source = try PUZToXDConverter.convert(puzData: data)
         #expect(!source.contains("Specials:"))
         #expect(source.contains("\nABC\nDEF\nGHI\n"))
         #expect(source.contains("## Decorations"))
         #expect(source.contains("\nO..\n.O.\n...\n"))
         #expect(source.contains("O. mark=circle"))
 
         let puzzle = Puzzle(xd: try XD.parse(source))
         #expect(puzzle.cells[0][0].special == .circled)
         #expect(puzzle.cells[1][1].special == .circled)
         #expect(puzzle.cells[0][0].solution == "A")
         #expect(puzzle.cells[1][1].solution == "E")
     }
 
     @Test("Rebus fills convert, dedupe by value, and round-trip")
     func rebusFillsConvertAndDedupe() throws {
         // Cells 0 and 8 share the fill CAT; cell 4 is DOG. The two CAT cells
         // must collapse to a single Rebus header entry and reuse one grid
         // placeholder — keying by cell index (the old bug) would mint three.
         let data = try puzData(
             width: 3,
             height: 3,
             solution: "ABCDEFGHI",
             title: "Rebus",
             author: "",
             copyright: "",
             clues: [
                 "Across 1",
                 "Down 1",
                 "Down 2",
                 "Down 3",
                 "Across 4",
                 "Across 5"
             ],
             rebusGrid: [0: 0, 4: 1, 8: 0],
             rebusTable: [0: "CAT", 1: "DOG"]
         )
 
         let source = try PUZToXDConverter.convert(puzData: data)
         #expect(header("Rebus", in: source) == "1=CAT 2=DOG")
         #expect(source.contains("\n1BC\nD2F\nGH1\n"))
 
         let puzzle = Puzzle(xd: try XD.parse(source))
         #expect(puzzle.cells[0][0].solution == "CAT")
         #expect(puzzle.cells[1][1].solution == "DOG")
         #expect(puzzle.cells[2][2].solution == "CAT")
     }
 
     @Test("A single rebus value at RTBL key 0 decodes rather than vanishing")
     func singleRebusValueDecodes() throws {
         // The common case: one rebus fill, `RTBL` key 0, so the `GRBS` byte is 1.
         // Reading the grid byte directly as the table key (the off-by-one bug)
         // looked up the absent key 1, silently dropping the rebus and leaving the
         // cell's raw solution letter behind.
         let data = try puzData(
             width: 3,
             height: 3,
             solution: "ABCDEFGHI",
             title: "Rebus",
             author: "",
             copyright: "",
             clues: [
                 "Across 1",
                 "Down 1",
                 "Down 2",
                 "Down 3",
                 "Across 4",
                 "Across 5"
             ],
             rebusGrid: [4: 0],
             rebusTable: [0: "HEART"]
         )
 
         let source = try PUZToXDConverter.convert(puzData: data)
         #expect(header("Rebus", in: source) == "1=HEART")
 
         let puzzle = Puzzle(xd: try XD.parse(source))
         #expect(puzzle.cells[1][1].solution == "HEART")
     }
 
     @Test("A cell both circled and rebus keeps its fill and circle")
     func circledRebusCellKeepsFillAndCircle() throws {
         let data = try puzData(
             width: 3,
             height: 3,
             solution: "ABCDEFGHI",
             title: "Both",
             author: "",
             copyright: "",
             clues: [
                 "Across 1",
                 "Down 1",
                 "Down 2",
                 "Down 3",
                 "Across 4",
                 "Across 5"
             ],
             circledCells: [0, 4],
             rebusGrid: [4: 0],
             rebusTable: [0: "HEART"]
         )
 
         let source = try PUZToXDConverter.convert(puzData: data)
         #expect(header("Rebus", in: source) == "1=HEART")
         #expect(header("Specials", in: source) == nil)
         #expect(source.contains("\nABC\nD1F\nGHI\n"))
         #expect(source.contains("\nO..\n.O.\n...\n"))
         #expect(source.contains("O. mark=circle"))
 
         let puzzle = Puzzle(xd: try XD.parse(source))
         #expect(puzzle.cells[1][1].solution == "HEART")
         #expect(puzzle.cells[0][0].special == .circled)
         #expect(puzzle.cells[1][1].special == .circled)
     }
 
     @Test("Many distinct rebus fills never collide with reserved grid syntax")
     func manyRebusFillsAvoidReservedKeys() throws {
         // Keying placeholders by cell index used to reach '=' (the Rebus header
         // delimiter) on the 13th rebus cell and '@' (the circle marker) on the
         // 16th, and to trap on UInt8 overflow past ~207. Twenty distinct fills
         // must all draw from the curated placeholder set and steer clear of
         // every reserved grid/header character.
         var grid: [Int: Int] = [:]
         var table: [Int: String] = [:]
         let values = (0..<20).map { "R\($0)X" }
         for (offset, value) in values.enumerated() {
             grid[offset] = offset
             table[offset] = value
         }
 
         let data = try puzData(
             width: 5,
             height: 5,
             solution: String(repeating: "A", count: 25),
             title: "Rebus",
             author: "",
             copyright: "",
             clues: Array(repeating: "Clue", count: 10),
             rebusGrid: grid,
             rebusTable: table
         )
 
         let source = try PUZToXDConverter.convert(puzData: data)
         let rebus = try #require(header("Rebus", in: source))
         for entry in rebus.split(separator: " ") {
             let key = try #require(entry.first)
             #expect(!["#", "_", ".", "@", "*", "="].contains(key))
         }
 
         // The whole puzzle now parses rather than throwing, with each distinct
         // fill landing as its own multi-letter rebus solution.
         let puzzle = Puzzle(xd: try XD.parse(source))
         #expect(puzzle.cells[0][0].solution == "R0X")
         #expect(puzzle.cells[3][4].solution == "R19X")
     }
 
     @Test("A Data slice with a non-zero start index converts identically")
     func sliceWithNonZeroStartIndexConverts() throws {
         let data = try puzData(
             width: 3,
             height: 3,
             solution: "ABCDEFGHI",
             title: "Sliced",
             author: "Tester",
             copyright: "",
             clues: [
                 "Across 1",
                 "Down 1",
                 "Down 2",
                 "Down 3",
                 "Across 4",
                 "Across 5"
             ]
         )
 
         var padded = Data([0xFF, 0xFF, 0xFF, 0xFF])
         padded.append(data)
         let slice = padded[4...]
         #expect(slice.startIndex != 0)
 
         let source = try PUZToXDConverter.convert(puzData: slice)
         #expect(source == (try PUZToXDConverter.convert(puzData: data)))
     }
 
     @Test("A valid small grid with a tail past the raw cap is rejected")
     func oversizedRawDataIsRejected() throws {
         var data = try puzData(
             width: 3,
             height: 3,
             solution: "ABCDEFGHI",
             title: "Big Tail",
             author: "",
             copyright: "",
             clues: [
                 "Across 1",
                 "Down 1",
                 "Down 2",
                 "Down 3",
                 "Across 4",
                 "Across 5"
             ]
         )
         data.append(Data(count: PUZToXDConverter.maxSourceBytes + 1 - data.count))
 
         #expect(throws: PUZToXDConverter.ConversionError.self) {
             _ = try PUZToXDConverter.convert(puzData: data)
         }
     }
 
     private func puzData(
         width: UInt8,
         height: UInt8,
         solution: String,
         title: String,
         author: String,
         copyright: String,
         clues: [String],
         notes: String = "",
         circledCells: Set<Int> = [],
         rebusGrid: [Int: Int] = [:],
         rebusTable: [Int: String] = [:]
     ) throws -> Data {
         let cellCount = Int(width) * Int(height)
         let solutionBytes = Array(solution.utf8)
         #expect(solutionBytes.count == cellCount)
 
         var data = Data(repeating: 0, count: 0x34)
         for (offset, byte) in "ACROSS&DOWN".utf8.enumerated() {
             data[0x02 + offset] = byte
         }
         data[0x18] = UInt8(ascii: "1")
         data[0x19] = UInt8(ascii: ".")
         data[0x1A] = UInt8(ascii: "3")
         data[0x2C] = width
         data[0x2D] = height
         data[0x2E] = UInt8(clues.count & 0xFF)
         data[0x2F] = UInt8((clues.count >> 8) & 0xFF)
 
         data.append(contentsOf: solutionBytes)
         data.append(contentsOf: Array(repeating: UInt8(ascii: "-"), count: cellCount))
 
         for string in [title, author, copyright] + clues + [notes] {
             data.append(try cp1252Data(string))
             data.append(0)
         }
         if !circledCells.isEmpty {
             var payload = Data(repeating: 0, count: cellCount)
             for index in circledCells where index >= 0 && index < cellCount {
                 payload[index] = 0x80
             }
             appendExtension("GEXT", payload: payload, into: &data)
         }
         // Rebus grid (`GRBS`) + table (`RTBL`) follow the real .puz convention:
         // `rebusGrid` maps a cell to its 0-based `RTBL` key, and the grid byte is
         // stored 1-indexed (`key + 1`), reserving 0 for "no rebus".
         if !rebusGrid.isEmpty {
             var payload = Data(repeating: 0, count: cellCount)
             for (index, key) in rebusGrid where index >= 0 && index < cellCount {
                 payload[index] = UInt8(key + 1)
             }
             appendExtension("GRBS", payload: payload, into: &data)
 
             let table = rebusTable
                 .sorted { $0.key < $1.key }
                 .map { " \($0.key):\($0.value);" }
                 .joined()
             appendExtension("RTBL", payload: try cp1252Data(table), into: &data)
         }
         return data
     }
 
     private func appendExtension(_ code: String, payload: Data, into data: inout Data) {
         data.append(contentsOf: code.utf8)
         data.append(UInt8(payload.count & 0xFF))
         data.append(UInt8((payload.count >> 8) & 0xFF))
         data.append(0)
         data.append(0)
         data.append(payload)
         data.append(0)
     }
 
     private func cp1252Data(_ string: String) throws -> Data {
         try #require(string.data(using: .windowsCP1252))
     }
 
     private func header(_ name: String, in xd: String) -> String? {
         let prefix = "\(name): "
         return xd.split(separator: "\n")
             .first { $0.hasPrefix(prefix) }
             .map { String($0.dropFirst(prefix.count)) }
     }
 }