crossmate

DecorationRenderingTests.swift (6517B)

---

 import CoreGraphics
 import Foundation
 import ImageIO
 import SwiftUI
 import Testing
 import UniformTypeIdentifiers
 
 @testable import Crossmate
 
 @Suite("Decoration rendering")
 @MainActor
 struct DecorationRenderingTests {
     /// A real 8×8 PNG, base64-encoded, so the decode path is exercised against
     /// actual image bytes rather than a magic literal.
     private static func samplePNGBase64() throws -> String {
         let context = try #require(CGContext(
             data: nil, width: 8, height: 8, bitsPerComponent: 8, bytesPerRow: 0,
             space: CGColorSpaceCreateDeviceRGB(),
             bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
         ))
         context.setFillColor(CGColor(red: 1, green: 0, blue: 0, alpha: 1))
         context.fill(CGRect(x: 0, y: 0, width: 8, height: 8))
         let image = try #require(context.makeImage())
         let data = NSMutableData()
         let destination = try #require(CGImageDestinationCreateWithData(
             data, UTType.png.identifier as CFString, 1, nil
         ))
         CGImageDestinationAddImage(destination, image, nil)
         #expect(CGImageDestinationFinalize(destination))
         return (data as Data).base64EncodedString()
     }
 
     private static func dataDecoration(
         mimeType: String = "image/png",
         encoding: String = "base64",
         payload: String
     ) -> Puzzle.Decoration {
         Puzzle.Decoration(
             content: .data(mimeType: mimeType, encoding: encoding, payload: payload),
             phase: .after
         )
     }
 
     // MARK: - Phase gating
 
     @Test("before layers are always visible; after layers only once solved")
     func phaseGating() {
         let before = Puzzle.Decoration(content: .mark(.circled), phase: .before)
         let after = Puzzle.Decoration(content: .text("!"), phase: .after)
 
         #expect(before.isVisible(solved: false))
         #expect(before.isVisible(solved: true))
         #expect(!after.isVisible(solved: false))
         #expect(after.isVisible(solved: true))
     }
 
     // MARK: - Colour scheme
 
     @Test("A colour with a dark variant selects on the current appearance")
     func darkVariantSelectsOnAppearance() {
         let red = Color(.sRGB, red: 1, green: 0, blue: 0, opacity: 1)
         let blue = Color(.sRGB, red: 0, green: 0, blue: 1, opacity: 1)
 
         #expect(Puzzle.Decoration.Content.color(
             light: "#FF0000", dark: "#0000FF", for: .light
         ) == red)
         #expect(Puzzle.Decoration.Content.color(
             light: "#FF0000", dark: "#0000FF", for: .dark
         ) == blue)
     }
 
     @Test("A colour with no dark variant is used in both appearances")
     func singleColorAppliesToBothAppearances() {
         let red = Color(.sRGB, red: 1, green: 0, blue: 0, opacity: 1)
         #expect(Puzzle.Decoration.Content.color(light: "#FF0000", dark: nil, for: .light) == red)
         #expect(Puzzle.Decoration.Content.color(light: "#FF0000", dark: nil, for: .dark) == red)
     }
 
     // MARK: - Hex colours
 
     @Test("Hex colours parse in their three accepted lengths")
     func hexColorsParse() {
         let red = Color(.sRGB, red: 1, green: 0, blue: 0, opacity: 1)
         #expect(Puzzle.Decoration.Content.color(fromHex: "#FF0000") == red)
         #expect(Puzzle.Decoration.Content.color(fromHex: "#F00") == red)
         #expect(Puzzle.Decoration.Content.color(fromHex: "FF0000") == red)
         #expect(Puzzle.Decoration.Content.color(fromHex: "#ff0000") == red)
 
         let halfRed = Color(.sRGB, red: 1, green: 0, blue: 0, opacity: 0.5)
         let parsed = Puzzle.Decoration.Content.color(fromHex: "#FF000080")
         #expect(parsed != nil)
         // 0x80/255 is 0.502, so compare against the same construction rather
         // than a rounded literal.
         #expect(parsed == Color(.sRGB, red: 1, green: 0, blue: 0, opacity: Double(0x80) / 255))
         #expect(parsed != halfRed)
     }
 
     @Test("An unparseable hex colour is skipped rather than guessed at")
     func unparseableHexColorsAreNil() {
         #expect(Puzzle.Decoration.Content.color(fromHex: "") == nil)
         #expect(Puzzle.Decoration.Content.color(fromHex: "#") == nil)
         #expect(Puzzle.Decoration.Content.color(fromHex: "#GGGGGG") == nil)
         #expect(Puzzle.Decoration.Content.color(fromHex: "#FF00") == nil)
         #expect(Puzzle.Decoration.Content.color(fromHex: "rebeccapurple") == nil)
     }
 
     // MARK: - Image decoding
 
     @Test("A base64 PNG payload decodes to a drawable image")
     func base64PNGDecodes() throws {
         let payload = try Self.samplePNGBase64()
         let images = DecorationImages.decode([
             GridPosition(row: 0, col: 0): [Self.dataDecoration(payload: payload)]
         ])
         #expect(images.count == 1)
         #expect(images[payload] != nil)
     }
 
     @Test("Identical payloads on different cells decode once")
     func identicalPayloadsDecodeOnce() throws {
         let payload = try Self.samplePNGBase64()
         let images = DecorationImages.decode([
             GridPosition(row: 0, col: 0): [Self.dataDecoration(payload: payload)],
             GridPosition(row: 3, col: 4): [Self.dataDecoration(payload: payload)]
         ])
         #expect(images.count == 1)
     }
 
     @Test("Unsupported encodings and mime types are left undrawn")
     func unsupportedPayloadsAreSkipped() throws {
         let payload = try Self.samplePNGBase64()
         let images = DecorationImages.decode([
             GridPosition(row: 0, col: 0): [
                 Self.dataDecoration(encoding: "hex", payload: payload),
                 Self.dataDecoration(mimeType: "text/plain", payload: payload)
             ]
         ])
         #expect(images.isEmpty)
     }
 
     @Test("A payload that isn't valid base64 or isn't an image is skipped")
     func malformedPayloadsAreSkipped() {
         let images = DecorationImages.decode([
             GridPosition(row: 0, col: 0): [
                 Self.dataDecoration(payload: "not base64!!"),
                 Self.dataDecoration(payload: Data("not a png".utf8).base64EncodedString())
             ]
         ])
         #expect(images.isEmpty)
     }
 
     @Test("Non-data decorations contribute no images")
     func nonDataDecorationsContributeNoImages() {
         let images = DecorationImages.decode([
             GridPosition(row: 0, col: 0): [
                 Puzzle.Decoration(content: .mark(.shaded), phase: .before),
                 Puzzle.Decoration(content: .text("x"), phase: .after)
             ]
         ])
         #expect(images.isEmpty)
     }
 }