crossmate

GridSilhouetteTests.swift (5842B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("Grid silhouette codec")
 struct GridSilhouetteTests {
 
     @Test("encodes a small symmetric grid to a stable segment")
     func encodesSymmetricSegment() {
         // 3×3 with only the centre blocked. Symmetric, so the first ⌈9/2⌉ = 5
         // cells (00001) pack into one byte 0x08 → base64url "CA"; side 3 → "3".
         var blocks = [Bool](repeating: false, count: 9)
         blocks[4] = true
         #expect(GridSilhouette.encode(side: 3, blocks: blocks) == "s3CA")
     }
 
     @Test("tags an asymmetric grid for a full dump")
     func tagsAsymmetricGrid() {
         // A single corner block has no 180° partner → not symmetric → "f".
         var blocks = [Bool](repeating: false, count: 9)
         blocks[0] = true
         let segment = GridSilhouette.encode(side: 3, blocks: blocks)
         #expect(segment?.first == "f")
         #expect(GridSilhouette.decode(segment ?? "") == GridSilhouette.Grid(side: 3, blocks: blocks))
     }
 
     @Test("round-trips a symmetric grid through decode")
     func roundTripsSymmetric() {
         var blocks = [Bool](repeating: false, count: 9)
         blocks[4] = true
         let grid = GridSilhouette.Grid(side: 3, blocks: blocks)
         let segment = GridSilhouette.encode(side: grid.width, blocks: grid.blocks)
         #expect(GridSilhouette.decode(segment ?? "") == grid)
     }
 
     @Test("round-trips a realistic 15×15 and stays compact")
     func roundTrips15x15() {
         // A symmetric scatter of blocks across a standard 15×15.
         let side = 15
         let n = side * side
         var blocks = [Bool](repeating: false, count: n)
         for k in [0, 4, 16, 30, 47, 88, 100, 112] {
             blocks[k] = true
             blocks[n - 1 - k] = true  // keep it symmetric
         }
         let grid = GridSilhouette.Grid(side: side, blocks: blocks)
         let segment = GridSilhouette.encode(side: side, blocks: blocks)
         #expect(segment?.first == "s")
         // ~2 tag/size chars + ⌈113 bits / 6⌉ ≈ 19 payload chars.
         #expect((segment?.count ?? .max) <= 24)
         #expect(GridSilhouette.decode(segment ?? "") == grid)
     }
 
     @Test("encodes a rectangular grid under the uppercase two-digit form")
     func encodesRectangularSegment() {
         // 2×3, all empty. Width≠height → uppercase `S`, width "2", height "3";
         // symmetric (all false), so ⌈6/2⌉ = 3 cells pack into 0x00 → "AA".
         let grid = GridSilhouette.Grid(width: 2, height: 3, blocks: [Bool](repeating: false, count: 6))
         let segment = GridSilhouette.encode(width: 2, height: 3, blocks: grid.blocks)
         #expect(segment == "S23AA")
         #expect(GridSilhouette.decode(segment ?? "") == grid)
     }
 
     @Test("tags an asymmetric rectangular grid with uppercase F")
     func tagsAsymmetricRectangle() {
         // A single corner block has no 180° partner → full dump → "F".
         var blocks = [Bool](repeating: false, count: 6)
         blocks[0] = true
         let segment = GridSilhouette.encode(width: 2, height: 3, blocks: blocks)
         #expect(segment?.first == "F")
         #expect(
             GridSilhouette.decode(segment ?? "")
                 == GridSilhouette.Grid(width: 2, height: 3, blocks: blocks)
         )
     }
 
     @Test("round-trips a realistic 21×22 Sunday grid")
     func roundTrips21x22() {
         // The shape that motivated rectangular support: a non-square Sunday.
         let width = 21
         let height = 22
         let n = width * height
         var blocks = [Bool](repeating: false, count: n)
         for k in [0, 5, 21, 64, 200, 230, 300, 410] {
             blocks[k] = true
             blocks[n - 1 - k] = true  // keep it 180°-symmetric
         }
         let grid = GridSilhouette.Grid(width: width, height: height, blocks: blocks)
         let segment = GridSilhouette.encode(width: width, height: height, blocks: blocks)
         #expect(segment?.first == "S")
         // width 21 → "l", height 22 → "m".
         #expect(segment?.dropFirst().prefix(2) == "lm")
         #expect(GridSilhouette.decode(segment ?? "") == grid)
     }
 
     @Test("encodes the largest supported side via base-36")
     func encodesLargeSide() {
         let side = GridSilhouette.maxSide  // 35 → base-36 'z'
         let blocks = [Bool](repeating: false, count: side * side)
         let segment = GridSilhouette.encode(side: side, blocks: blocks)
         #expect(segment?.dropFirst().first == "z")
         #expect(GridSilhouette.decode(segment ?? "") == GridSilhouette.Grid(side: side, blocks: blocks))
     }
 
     @Test("refuses a mismatched block count or out-of-range dimension")
     func refusesUnsupportedGrids() {
         #expect(GridSilhouette.encode(side: 3, blocks: [Bool](repeating: false, count: 6)) == nil)
         #expect(GridSilhouette.encode(side: 1, blocks: [false]) == nil)
         #expect(GridSilhouette.encode(side: 36, blocks: [Bool](repeating: false, count: 36 * 36)) == nil)
         #expect(GridSilhouette.encode(width: 2, height: 36, blocks: [Bool](repeating: false, count: 72)) == nil)
         #expect(GridSilhouette.encode(width: 2, height: 3, blocks: [Bool](repeating: false, count: 5)) == nil)
     }
 
     @Test("rejects malformed segments")
     func rejectsMalformedSegments() {
         #expect(GridSilhouette.decode("") == nil)
         #expect(GridSilhouette.decode("x3CA") == nil)   // unknown tag
         #expect(GridSilhouette.decode("s") == nil)      // no size/payload
         #expect(GridSilhouette.decode("s3") == nil)     // empty payload, no bits
         #expect(GridSilhouette.decode("s1CA") == nil)   // side 1 is below minSide
         #expect(GridSilhouette.decode("S2") == nil)     // rectangular tag, missing height
         #expect(GridSilhouette.decode("S21AA") == nil)  // height 1 is below minSide
     }
 }