Tests/Unit/XDAcceptTests.swift (17837B)
1import Foundation
2import Testing
3
4@testable import Crossmate
5
6@Suite("XD Accept metadata")
7@MainActor
8struct XDAcceptTests {
9 @Test("Missing converter version defaults to one")
10 func missingConverterVersionDefaultsToOne() throws {
11 let xd = try XD.parse("""
12 Title: Versionless
13
14
15 A
16
17
18 A1. Letter ~ A
19 D1. Letter ~ A
20 """)
21
22 #expect(xd.converterVersion == 1)
23 }
24
25 @Test("Explicit positive ConVer is parsed")
26 func explicitConVerIsParsed() throws {
27 let xd = try XD.parse("""
28 Title: Versioned
29 ConVer: 3
30
31
32 A
33
34
35 A1. Letter ~ A
36 D1. Letter ~ A
37 """)
38
39 #expect(xd.converterVersion == 3)
40 }
41
42 @Test("Legacy CmVer header still parses as the converter version")
43 func legacyCmVerHeaderParses() throws {
44 let xd = try XD.parse("""
45 Title: Legacy
46 CmVer: 3
47
48
49 A
50
51
52 A1. Letter ~ A
53 D1. Letter ~ A
54 """)
55
56 #expect(xd.converterVersion == 3)
57 }
58
59 @Test("ConVer takes precedence over a legacy CmVer when both are present")
60 func conVerWinsOverLegacyCmVer() throws {
61 let xd = try XD.parse("""
62 Title: Both
63 ConVer: 8
64 CmVer: 3
65
66
67 A
68
69
70 A1. Letter ~ A
71 D1. Letter ~ A
72 """)
73
74 #expect(xd.converterVersion == 8)
75 }
76
77 @Test("settingConverterVersionHeader rewrites an existing ConVer in place")
78 func stampRewritesExistingConVer() throws {
79 let source = """
80 Title: Versioned
81 ConVer: 3
82
83
84 A
85
86
87 A1. Letter ~ A
88 D1. Letter ~ A
89 """
90 let stamped = XD.settingConverterVersionHeader(in: source, to: 8)
91
92 #expect(!stamped.contains("ConVer: 3"))
93 #expect(try XD.parse(stamped).converterVersion == 8)
94 #expect(try XD.parse(stamped).width == 1)
95 }
96
97 @Test("settingConverterVersionHeader upgrades a legacy CmVer to ConVer")
98 func stampUpgradesLegacyCmVer() throws {
99 let source = """
100 Title: Legacy
101 CmVer: 3
102
103
104 A
105
106
107 A1. Letter ~ A
108 D1. Letter ~ A
109 """
110 let stamped = XD.settingConverterVersionHeader(in: source, to: 8)
111
112 #expect(stamped.contains("ConVer: 8"))
113 #expect(!stamped.contains("CmVer:"))
114 #expect(try XD.parse(stamped).converterVersion == 8)
115 }
116
117 @Test("settingConverterVersionHeader inserts a header when none is present")
118 func stampInsertsWhenAbsent() throws {
119 let source = """
120 Title: Versionless
121
122
123 A
124
125
126 A1. Letter ~ A
127 D1. Letter ~ A
128 """
129 let stamped = XD.settingConverterVersionHeader(in: source, to: 8)
130 let xd = try XD.parse(stamped)
131
132 #expect(xd.converterVersion == 8)
133 #expect(xd.title == "Versionless")
134 }
135
136 @Test("Rebus value escapes decode: \\space to a blank, \\\\ to a backslash")
137 func rebusValueEscapesDecode() throws {
138
139
140
141 let puzzle = Puzzle(xd: try XD.parse(#"""
142 Title: Gaps
143 CmVer: 5
144 Rebus: 1=\space 2=C\\D
145
146
147 A1B2
148
149
150 A1. Row ~ A BC\D
151 """#))
152
153 #expect(puzzle.cells[0][0].solution == "A")
154 #expect(puzzle.cells[0][1].solution == " ")
155 #expect(puzzle.cells[0][2].solution == "B")
156 #expect(puzzle.cells[0][3].solution == "C\\D")
157 }
158
159 @Test("A gap cell is solved by leaving it blank")
160 func gapCellSolvedWhenBlank() throws {
161
162
163
164 let source = #"""
165 Title: Gap
166 CmVer: 5
167 Rebus: 1=\space
168
169
170 TO1BE
171
172
173 A1. Repeated part of a soliloquy ~ TO BE
174 """#
175 let puzzle = Puzzle(xd: try XD.parse(source))
176
177 let gap = puzzle.cells[0][2]
178 #expect(gap.expectsBlank)
179 #expect(gap.accepts(""))
180 #expect(!gap.accepts("B"))
181 #expect(!puzzle.cells[0][0].accepts(""))
182
183 let game = Game(puzzle: Puzzle(xd: try XD.parse(source)))
184 game.setLetter("T", atRow: 0, atCol: 0, pencil: false)
185 game.setLetter("O", atRow: 0, atCol: 1, pencil: false)
186 game.setLetter("B", atRow: 0, atCol: 3, pencil: false)
187 game.setLetter("E", atRow: 0, atCol: 4, pencil: false)
188
189 #expect(game.completionState == .solved)
190
191
192 game.setLetter("X", atRow: 0, atCol: 2, pencil: false)
193 #expect(game.completionState == .filledWithErrors)
194 }
195
196 @Test("Special symbols parse per cell")
197 func specialSymbolsParsePerCell() throws {
198 let puzzle = Puzzle(xd: try XD.parse("""
199 Title: Specials
200 CmVer: 3
201 Specials: @=circle *=shaded
202
203
204 @B@
205 D**
206
207
208 A1. Row 1 ~ ABC
209 A4. Row 2 ~ DEF
210 D1. Col 1 ~ AD
211 D2. Col 2 ~ BE
212 D3. Col 3 ~ CF
213 """))
214
215 #expect(puzzle.cells[0][0].special == .circled)
216 #expect(puzzle.cells[0][2].special == .circled)
217 #expect(puzzle.cells[1][1].special == .shaded)
218 #expect(puzzle.cells[1][2].special == .shaded)
219 #expect(puzzle.cells[0][1].special == nil)
220 #expect(puzzle.cells[0][0].solution == "A")
221 #expect(puzzle.cells[1][1].solution == "E")
222 }
223
224 @Test("A rebus placeholder can also mark a special cell")
225 func rebusPlaceholderCanAlsoMarkSpecialCell() throws {
226 let puzzle = Puzzle(xd: try XD.parse("""
227 Title: Shaded Rebus
228 Rebus: 1=HEART
229 Specials: 1=shaded
230
231
232 1
233
234
235 A1. Rebus ~ HEART
236 """))
237
238 #expect(puzzle.cells[0][0].solution == "HEART")
239 #expect(puzzle.cells[0][0].special == .shaded)
240 }
241
242 @Test("Conflicting inferred special symbols fail parsing")
243 func conflictingInferredSpecialSymbolsFailParsing() throws {
244 #expect(throws: XD.ParseError.self) {
245 try XD.parse("""
246 Title: Conflicting Specials
247 CmVer: 3
248 Specials: @=circle
249
250
251 @BC
252 DEF
253
254
255 A1. Row 1 ~ ABC
256 A4. Row 2 ~ DEF
257 D1. Col 1 ~ ZD
258 D2. Col 2 ~ BE
259 D3. Col 3 ~ CF
260 """)
261 }
262 }
263
264 @Test("Unfilled special symbols fail parsing")
265 func unfilledSpecialSymbolsFailParsing() throws {
266 #expect(throws: XD.ParseError.self) {
267 try XD.parse("""
268 Title: Unfilled Specials
269 CmVer: 3
270 Specials: @=circle
271
272
273 @
274
275
276 """)
277 }
278 }
279
280 @Test("Ambiguous inferred special symbols fail parsing")
281 func ambiguousInferredSpecialSymbolsFailParsing() throws {
282 #expect(throws: XD.ParseError.self) {
283 try XD.parse("""
284 Title: Ambiguous Specials
285 CmVer: 3
286 Specials: @=circle
287
288
289 @B@
290
291
292 A1. Row 1 ~ ABBBC
293 D1. Col 1 ~ A
294 D2. Col 2 ~ B
295 D3. Col 3 ~ C
296 """)
297 }
298 }
299
300 @Test("Standard XD Special header marks lowercase cells")
301 func standardXDSpecialHeaderMarksLowercaseCells() throws {
302 let puzzle = Puzzle(xd: try XD.parse("""
303 Title: Standard Special
304 CmVer: 3
305 Special: circle
306
307
308 aBC
309
310
311 A1. Row ~ ABC
312 D1. Col 1 ~ A
313 D2. Col 2 ~ B
314 D3. Col 3 ~ C
315 """))
316
317 #expect(puzzle.cells[0][0].special == .circled)
318 #expect(puzzle.cells[0][1].special == nil)
319 }
320
321 @Test("Clue metadata is parsed generically")
322 func clueMetadataParsesGenerically() throws {
323 let source = """
324 Title: Metadata Test
325
326
327 ABC
328
329
330 A1. Gardener's concerns. ~ ABC
331 A1 ^Refs: A2 D4
332 A1 ^Note: first value
333 A1 ^Note: second value
334 """
335
336 let xd = try XD.parse(source)
337 let clue = try #require(xd.acrossClues.first)
338
339 #expect(clue.text == "Gardener's concerns.")
340 #expect(clue.answer == "ABC")
341 #expect(clue.metadata["Refs"] == ["A2 D4"])
342 #expect(clue.metadata["Note"] == ["first value", "second value"])
343 }
344
345 @Test("Accept metadata parses escaped tokens onto matching rebus cells")
346 func acceptMetadataParsesEscapedTokens() throws {
347 let source = """
348 Title: Accept Test
349 Rebus: 1=PHI
350
351
352 1A
353
354
355 A1. Greek letter represented in the puzzle. ~ PHI
356 A1 ^Accept: IO OI I/O NEW\\ YORK A\\|B BACK\\\\SLASH
357 """
358
359 let puzzle = Puzzle(xd: try XD.parse(source))
360 let acceptClue = try #require(try XD.parse(source).acrossClues.first)
361 let cell = puzzle.cells[0][0]
362
363 #expect(acceptClue.metadata["Accept"] == ["IO OI I/O NEW\\ YORK A\\|B BACK\\\\SLASH"])
364 #expect(acceptClue.acceptedAnswers == ["IO", "OI", "I/O", "NEW YORK", "A|B", "BACK\\SLASH"])
365 #expect(cell.accepts("PHI"))
366 #expect(cell.accepts("io"))
367 #expect(cell.accepts("NEW YORK"))
368 #expect(cell.accepts("A|B"))
369 #expect(cell.accepts("BACK\\SLASH"))
370 #expect(!cell.accepts("NYC"))
371 }
372
373 @Test("Accepted answers are case-insensitive")
374 func acceptedAnswersNormalizeCaseForCompletion() throws {
375 let source = """
376 Title: Normalize Test
377 Rebus: 1=PHI
378
379
380 1A
381
382
383 A1. Greek letter represented in the puzzle. ~ PHI
384 A1 ^Accept: PHI
385 """
386
387 let game = Game(puzzle: Puzzle(xd: try XD.parse(source)))
388 game.setLetter("phi", atRow: 0, atCol: 0, pencil: false)
389
390 #expect(game.completionState == .solved)
391 }
392
393 @Test("Non-ASCII clue prose is allowed")
394 func nonASCIIClueProseIsAllowed() throws {
395 let puzzle = Puzzle(xd: try XD.parse("""
396 Title: Clue Emoji
397
398
399 A
400
401
402 A1. Emoji clue is fine 🔥 ~ A
403 D1. Accented clue is fine café ~ A
404 """))
405
406 #expect(puzzle.acrossClues[0].text == "Emoji clue is fine 🔥")
407 #expect(puzzle.downClues[0].text == "Accented clue is fine café")
408 #expect(puzzle.cells[0][0].solution == "A")
409 }
410
411 @Test("Non-ASCII answer content is rejected without an ASCII alternative")
412 func nonASCIIAnswerContentIsRejectedWithoutASCIIAlternative() {
413 #expect(throws: XD.ParseError.self) {
414 try XD.parse("""
415 Title: Emoji Answer
416 Rebus: 1=🔥
417
418
419 1A
420 BA
421
422
423 A1. Hot stuff ~ 🔥A
424 D1. Hot stuff ~ 🔥B
425 """)
426 }
427
428 #expect(throws: XD.ParseError.self) {
429 try XD.parse("""
430 Title: Unicode Grid
431
432
433 ΦA
434 BA
435
436
437 A1. Greek letter ~ ΦA
438 D1. Greek letter ~ ΦB
439 """)
440 }
441 }
442
443 @Test("Non-ASCII answer content is allowed with an ASCII alternative")
444 func nonASCIIAnswerContentIsAllowedWithASCIIAlternative() throws {
445 let emojiPuzzle = Puzzle(xd: try XD.parse("""
446 Title: Emoji Answer
447 Rebus: 1=🔥
448
449
450 1A
451 BA
452
453
454 A1. Hot stuff ~ 🔥A
455 A1 ^Accept: FIREA
456 D1. Hot stuff ~ 🔥B
457 D1 ^Accept: FIREB
458 """))
459
460 let emojiCell = emojiPuzzle.cells[0][0]
461 #expect(emojiCell.solution == "🔥")
462 #expect(emojiCell.accepts("FIRE"))
463
464 let greekPuzzle = Puzzle(xd: try XD.parse("""
465 Title: Unicode Grid
466
467
468 ΦA
469 BA
470
471
472 A1. Greek letter ~ ΦA
473 A1 ^Accept: PHIA
474 D1. Greek letter ~ ΦB
475 D1 ^Accept: PHIB
476 """))
477
478 let greekCell = greekPuzzle.cells[0][0]
479 #expect(greekCell.solution == "Φ")
480 #expect(greekCell.accepts("PHI"))
481 }
482
483 @Test("Whole-clue accepted answers project onto changed cells")
484 func acceptedClueAnswersProjectOntoCells() throws {
485 let source = """
486 Title: Projection Test
487 Rebus: 1=IO
488
489
490 P1NG
491
492
493 A1. Paddle sport starter. ~ PIONG
494 A1 ^Accept: PPHING PI/ONG
495 """
496
497 let puzzle = Puzzle(xd: try XD.parse(source))
498 let cell = puzzle.cells[0][1]
499
500 #expect(cell.solution == "IO")
501 #expect(cell.accepts("PHI"))
502 #expect(cell.accepts("I/O"))
503 #expect(!puzzle.cells[0][0].accepts("PHI"))
504 }
505
506 @Test("Slash ~ field accepts a single magic-square alternate")
507 func slashFieldAcceptsMagicSquare() throws {
508 let source = """
509 Title: Magic Square
510 CmVer: 3
511
512
513 ABC
514
515
516 A1. Three letters ~ ABC / ADC
517 """
518
519 let xd = try XD.parse(source)
520 let clue = try #require(xd.acrossClues.first)
521
522 #expect(clue.answer == "ABC")
523 #expect(clue.alternativeAnswers == ["ADC"])
524 #expect(clue.acceptedAnswers == ["ADC"])
525
526 let puzzle = Puzzle(xd: xd)
527 #expect(puzzle.cells[0][1].solution == "B")
528 #expect(puzzle.cells[0][1].accepts("D"))
529 #expect(!puzzle.cells[0][0].accepts("D"))
530 #expect(!puzzle.cells[0][2].accepts("D"))
531 }
532
533 @Test("Slash ~ field accepts a whole-word alternate where every cell differs")
534 func slashFieldAcceptsWholeWordAlternate() throws {
535 let source = """
536 Title: Whole Word
537 CmVer: 3
538
539
540 CIGAR
541
542
543 A1. Cigar, to a Freudian ~ CIGAR / PENIS
544 """
545
546 let xd = try XD.parse(source)
547 let clue = try #require(xd.acrossClues.first)
548
549 #expect(clue.answer == "CIGAR")
550 #expect(clue.alternativeAnswers == ["PENIS"])
551
552 let puzzle = Puzzle(xd: xd)
553 let canonical = Array("CIGAR")
554 let alternate = Array("PENIS")
555 for column in 0..<5 {
556 #expect(puzzle.cells[0][column].solution == String(canonical[column]))
557 #expect(puzzle.cells[0][column].accepts(String(alternate[column])))
558 }
559 }
560
561 @Test("Free cells receive a unique answer segmentation")
562 func freeCellsReceiveUniqueSegmentation() throws {
563
564
565
566 let puzzle = Puzzle(xd: try XD.parse("""
567 Title: Segmentation
568 CmVer: 3
569
570
571 .B
572
573
574 A1. Two cells ~ XYB
575 """))
576
577 #expect(puzzle.cells[0][0].solution == "XY")
578 #expect(puzzle.cells[0][1].solution == "B")
579 }
580
581 @Test("Unsegmentable answer over many free cells fails fast")
582 func unsegmentableAnswerOverManyFreeCellsFailsFast() throws {
583
584
585
586
587
588
589 let grid = String(repeating: ".", count: 30) + "Z"
590 let answer = String(repeating: "A", count: 61)
591 let source = """
592 Title: DoS
593 CmVer: 3
594
595
596 \(grid)
597
598
599 A1. Crafted ~ \(answer)
600 """
601
602 #expect(throws: XD.ParseError.self) {
603 try XD.parse(source)
604 }
605 }
606
607 @Test("Oversized source is rejected before parsing")
608 func oversizedSourceIsRejected() throws {
609 let source = String(repeating: "A", count: XD.maxSourceBytes + 1)
610
611 do {
612 _ = try XD.parse(source)
613 Issue.record("expected parse to throw sourceTooLarge")
614 } catch let error as XD.ParseError {
615 guard case .sourceTooLarge = error else {
616 Issue.record("expected sourceTooLarge, got \(error)")
617 return
618 }
619 }
620 }
621
622 @Test("A source at the size limit still parses")
623 func sourceAtLimitParses() throws {
624
625
626
627 let base = """
628 Title: Padded
629
630
631 A
632
633
634 A1. Letter ~ A
635 D1. Letter ~ A
636 """
637 let padding = String(repeating: " ", count: XD.maxSourceBytes - base.utf8.count)
638 let source = base + padding
639
640 #expect(source.utf8.count == XD.maxSourceBytes)
641 #expect(throws: Never.self) {
642 try XD.parse(source)
643 }
644 }
645
646 @Test("Over-long clue text is rejected")
647 func overLongClueTextIsRejected() throws {
648 let longText = String(repeating: "x", count: XD.maxClueTextLength + 1)
649 let source = """
650 Title: Long Clue
651
652
653 AB
654
655
656 A1. \(longText) ~ AB
657 """
658
659 #expect(throws: XD.ParseError.self) {
660 try XD.parse(source)
661 }
662 }
663
664 @Test("Check accepts alternate entries")
665 func checkAcceptsAlternateEntries() throws {
666 let source = """
667 Title: Check Test
668 Rebus: 1=PHI
669
670
671 1A
672
673
674 A1. Greek letter represented in the puzzle. ~ PHI
675 A1 ^Accept: IO
676 """
677
678 let game = Game(puzzle: Puzzle(xd: try XD.parse(source)))
679 game.setLetter("IO", atRow: 0, atCol: 0, pencil: false)
680 game.checkCells([game.puzzle.cells[0][0]])
681
682 #expect(game.squares[0][0].mark == .pen(checked: .right))
683 }
684}