@voxgig/sdkgen 4.8.2 → 4.8.3

package/project/.sdk/tm/swift/Tests/ProjectNameSDKTests/StructUtilityTest.swift

@@ -1,477 +1,361 @@
-// Struct corpus runner — loads ../../../.sdk/test/test.json and exercises every
-// subsystem the canonical TS test suite drives.
+// Drives the shared struct corpus (../../../.sdk/test/test.json, root key
+// "struct") against the vendored struct utility THROUGH the vendored omni
+// runner (OmniResolver over Tests/vendor/omni) - the engine half of the
+// hand-written runner this file used to carry. Mirrors
+// tm/csharp/test/StructUtilityTest.cs and tm/go/test/struct_utility_test.go.
+//
+// What changed with the migration, and why each change is load-bearing:
+//
+//   - A missing or EMPTY category/section now FAILS. The retired inline
+//     engine returned early whenever a section did not resolve to a list,
+//     so `testSentinels` drove a category called "sentinels" that the
+//     corpus renamed to "nullsem" LONG AGO and reported PASS over zero
+//     assertions for every one of its 33 entries.
+//
+//   - `err:` entries now RUN. The retired engine skipped every entry
+//     carrying one ("not yet wired uniformly"), which silently dropped 55
+//     cases - all of validate.invalid and transform.apply among them.
+//     Struct's Swift port COLLECTS diagnostics in `Injection.errs` instead
+//     of raising (unlike the C#/TS ports, which throw), so the validate and
+//     transform subjects below collect and raise them; the messages
+//     asserted are the port's own.
+//
+//   - `match:` entries now RUN. The retired engine compared `out` only, so
+//     `minor.setpath` and `merge.integrity` - thirteen entries whose whole
+//     point is `match: {args: ...}`, i.e. what the call did to its
+//     ARGUMENTS - asserted nothing about that. Subjects therefore no longer
+//     clone their input: an in-place rewrite has to be visible.
+//
+//   - `.noval` and `.null` are DISTINCT. The retired engine's canonical
+//     comparison folded them together; omni's `null` flag decides per
+//     section, and the flags below track csharp's.
+//
+// RUN: cd swift && swift test
+// RUN-SOME: swift test --filter StructUtilityTest.testMinor
 
+import Foundation
 import XCTest
 
 @testable import ProjectNameSdk
 
-private let CORPUS_PATH =
-  (URL(fileURLWithPath: #filePath)
-    .deletingLastPathComponent()  // ProjectNameSDKTests/
-    .deletingLastPathComponent()  // Tests/
-    .deletingLastPathComponent()  // swift/  (generated SDK root)
-    .deletingLastPathComponent()  // <project>/  (holds .sdk/)
-    .appendingPathComponent(".sdk")
-    .appendingPathComponent("test")
-    .appendingPathComponent("test.json"))
-
-private let NULLMARK = "__NULL__"
-
-// Apply the canonical NULLMARK fixup: replace every JSON null with the
-// sentinel string "__NULL__" so "stored null" vs "absent" survives the
-// otherwise lossy round-trip through the test entry.
-private func fixNull(_ v: Value) -> Value {
-  switch v {
-  case .null: return .string(NULLMARK)
-  case .list(let l): return .list(l.items.map { fixNull($0) })
-  case .map(let m):
-    let nm = VMap()
-    for (k, vv) in m.entries { nm.entries[k] = fixNull(vv) }
-    return .map(nm)
-  default: return v
+final class StructUtilityTest: XCTestCase {
+
+  // One corpus runner for the whole suite (XCTest builds a fresh instance
+  // per test method, so the runner is static).
+  private static var RUN: OmniResolver.Run?
+  private static let runLock = NSLock()
+
+  private static func structRun() throws -> OmniResolver.Run {
+    runLock.lock()
+    defer { runLock.unlock() }
+    if let run = RUN { return run }
+    let run = try OmniResolver.makeRunner(
+      SdkRunner.testJsonPath(), ProjectNameSDK.testSDK(nil, nil))("struct")
+    RUN = run
+    return run
   }
-}
 
-// Modifier that mirrors test/runner.ts `nullModifier`. Swaps any string
-// `"__NULL__"` slot for actual JSON null, and replaces embedded
-// "__NULL__" substrings with the literal string "null".
-private func nullModifier(_ val: Value, _ key: Value, _ parent: Value, _ inj: Injection, _ store: Value) {
-  if case .string(let s) = val {
-    if s == NULLMARK {
-      setprop(parent, key, .null)
-    } else if s.contains(NULLMARK) {
-      setprop(parent, key, .string(s.replacingOccurrences(of: NULLMARK, with: "null")))
+  // Run one corpus section through the vendored engine, failing loudly when
+  // the category, the section, or its `set` is missing or EMPTY - a renamed
+  // fixture must not report PASS while running zero assertions. The case
+  // count is printed so a collapse is visible in the log, not just in a
+  // red/green bit.
+  private func runStruct(
+    _ category: String, _ name: String, _ nullFlag: Bool,
+    _ subject: @escaping (Value) throws -> Value,
+    file: StaticString = #filePath, line: UInt = #line
+  ) {
+    let label = category + "." + name
+    do {
+      let run = try StructUtilityTest.structRun()
+
+      let cat = run.spec.get(category)
+      guard cat.isMap else {
+        return XCTFail(
+          "struct corpus category missing: \(category) - check .sdk/test/struct/",
+          file: file, line: line)
+      }
+
+      let section = cat.get(name)
+      guard section.isMap else {
+        return XCTFail(
+          "struct corpus section missing: \(label) - check .sdk/test/struct/",
+          file: file, line: line)
+      }
+
+      guard let count = section.setCount else {
+        return XCTFail(
+          "struct corpus section has no set list: \(label) - zero cases would run",
+          file: file, line: line)
+      }
+      guard 0 < count else {
+        return XCTFail(
+          "struct corpus section is EMPTY: \(label) - zero cases would run",
+          file: file, line: line)
+      }
+
+      try run.runsetflags(section, nullFlag) { args in
+        try subject(args.first ?? .noval)
+      }
+
+      print("ok \(label): \(count)/\(count)")
+    } catch {
+      XCTFail("\(label): \(OmniResolver.message(error))", file: file, line: line)
     }
   }
-}
 
-// Stable JSON-string with sorted map keys so per-port map order doesn't
-// flap the equality check (matches the way other-port runners compare
-// via deepStrictEqual / canonical jsonify). At the test-runner level we
-// treat NOVAL and NULL as equivalent — the canonical TS runner roundtrips
-// values through JSON.stringify which erases the distinction.
-private func canon(_ v: Value) -> String {
-  let normalised = normaliseAbsent(v)
-  return stringify(normalised)
-}
+  // A section of the corpus in the SDK's value model, for the few subjects
+  // that need to read fixture data directly.
+  private func section(_ category: String, _ name: String) throws -> Value {
+    try StructUtilityTest.structRun().spec.get([category, name]).value
+  }
+
+  // MARK: - Local helpers
+
+  private func intArg(_ v: Value) -> Int? { v.asInt.map(Int.init) }
 
-private func normaliseAbsent(_ v: Value) -> Value {
-  switch v {
-  case .noval: return .null
-  case .list(let l):
-    return .list(l.items.map { normaliseAbsent($0) })
-  case .map(let m):
-    let nm = VMap()
-    for (k, vv) in m.entries { nm.entries[k] = normaliseAbsent(vv) }
-    return .map(nm)
-  default: return v
+  // A RAW fixture read. `gp`/`getprop` is Group A - a stored null reads as
+  // absent - so reading a fixture field with it collapses the very
+  // distinction the `null: false` sections exist to test (an explicit
+  // `alt: null` arrived as "no alt", and `data: null` as "no data").
+  // `lookup` is Group B: the stored value, null included, and `.noval` only
+  // when the key is genuinely missing.
+  private func raw(_ v: Value, _ key: String) -> Value { lookup(v, .string(key)) }
+
+  // An Injection whose `errs` list this suite holds, so the diagnostics
+  // struct's Swift port COLLECTS can be raised as the failure the corpus
+  // `err:` entries expect. (The C# port raises them from inside Validate;
+  // the Swift port does not - see the header note.)
+  private func errCollector() -> (Injection, VList) {
+    let inj = Injection(val: .noval, parent: .noval)
+    let errs = VList()
+    inj.errs = errs
+    return (inj, errs)
   }
-}
 
-final class StructUtilityTest: XCTestCase {
-  private func loadStructSpec() -> Value {
-    do {
-      let text = try String(contentsOf: CORPUS_PATH, encoding: .utf8)
-      let spec = try JSON.parse(text)
-      return getprop(spec, .string("struct"))
-    } catch {
-      XCTFail("Failed to load corpus at \(CORPUS_PATH.path): \(error)")
-      return .noval
-    }
+  private func raiseErrs(_ errs: VList) throws {
+    if errs.items.isEmpty { return }
+    throw OmniResolver.SubjectError(
+      errs.items.map { stringify($0) }.joined(separator: " | "))
   }
 
-  private func runset(_ label: String, _ entries: Value, _ subject: (Value) -> Value) {
-    guard case .list(let l) = entries else { return }
-    var pass = 0
-    var fails: [String] = []
-    for (i, entry) in l.items.enumerated() {
-      guard case .map(let em) = entry else { continue }
-      let inVal = em.entries["in"] ?? .noval
-      // Skip entries with an `err:` field — those exercise error
-      // collection, which is not yet wired uniformly.
-      if em.entries["err"] != nil { continue }
-      let expected = em.entries["out"] ?? .noval
-      let got = subject(inVal)
-      let exp = canon(expected)
-      let gotS = canon(got)
-      if exp == gotS { pass += 1 } else { fails.append("[\(label)#\(i)] exp=\(exp) got=\(gotS)") }
-    }
-    if !fails.isEmpty {
-      for f in fails.prefix(5) { print(f) }
-      XCTFail("\(label): \(pass)/\(pass + fails.count) — \(fails.count) failed")
-    } else {
-      print("ok \(label): \(pass)/\(pass)")
-    }
+  // MARK: - Existence
+
+  func testMinorExists() {
+    XCTAssertFalse(isnode(.noval))
+    XCTAssertTrue(isnode(.map(VMap())))
+    XCTAssertEqual(typename(T_string), S_string)
+    XCTAssertEqual(escre(.string("a.b")), "a\\.b")
   }
 
   // MARK: - Minor
 
   func testMinor() {
-    let s = loadStructSpec()
-    guard case .map(let minor) = getprop(s, .string("minor")) else {
-      return XCTFail("missing minor")
+    runStruct("minor", "isnode", true) { .bool(isnode($0)) }
+    runStruct("minor", "ismap", true) { .bool(ismap($0)) }
+    runStruct("minor", "islist", true) { .bool(islist($0)) }
+    runStruct("minor", "iskey", false) { .bool(iskey($0)) }
+    runStruct("minor", "isempty", false) { .bool(isempty($0)) }
+    runStruct("minor", "isfunc", true) { .bool(isfunc($0)) }
+    runStruct("minor", "size", false) { .int(Int64(size($0))) }
+    runStruct("minor", "typify", false) { .int(Int64(typify($0))) }
+    runStruct("minor", "typename", true) { .string(typename(Int($0.asInt ?? 0))) }
+    runStruct("minor", "strkey", false) { .string(strkey($0)) }
+    runStruct("minor", "keysof", true) { .list(keysof($0).map { Value.string($0) }) }
+    runStruct("minor", "clone", false) { clone($0) }
+    runStruct("minor", "escre", true) { .string(escre($0)) }
+    runStruct("minor", "escurl", true) { .string(escurl($0)) }
+    runStruct("minor", "items", true) { .list(items($0).map { Value.list($0) }) }
+
+    runStruct("minor", "haskey", false) {
+      .bool(haskey(gp($0, "src"), gp($0, "key")))
+    }
+    runStruct("minor", "getprop", false) {
+      getprop(gp($0, "val"), gp($0, "key"), self.raw($0, "alt"))
+    }
+    runStruct("minor", "getelem", false) {
+      getelem(gp($0, "val"), gp($0, "key"), gp($0, "alt"))
+    }
+    runStruct("minor", "stringify", false) {
+      if case .map(let m) = $0 {
+        return .string(stringify(m.entries["val"] ?? .noval,
+          m.entries["max"]?.asInt.map(Int.init)))
+      }
+      return .string(stringify($0))
+    }
+    runStruct("minor", "jsonify", false) {
+      var indent = 2
+      var offset = 0
+      let flags = gp($0, "flags")
+      if case .map = flags {
+        if case .int(let n) = gp(flags, "indent") { indent = Int(n) }
+        if case .int(let n) = gp(flags, "offset") { offset = Int(n) }
+      }
+      return .string(jsonify(lookup($0, .string("val")), indent: indent, offset: offset))
+    }
+    runStruct("minor", "pathify", false) {
+      .string(pathify(lookup($0, .string("path")), self.intArg(gp($0, "from"))))
+    }
+    runStruct("minor", "flatten", true) {
+      flatten(gp($0, "val"), self.intArg(gp($0, "depth")))
+    }
+    runStruct("minor", "filter", true) {
+      let checks: [String: (Value, Value) -> Bool] = [
+        "gt3": { _, v in (v.asDouble ?? 0) > 3 },
+        "lt3": { _, v in (v.asDouble ?? 0) < 3 },
+      ]
+      let check = strkey(gp($0, "check"))
+      return filter(gp($0, "val"), checks[check] ?? { _, _ in false })
+    }
+    runStruct("minor", "join", false) {
+      let sep: String
+      if case .string(let s) = gp($0, "sep") { sep = s } else { sep = "," }
+      var url = false
+      if case .bool(let b) = gp($0, "url") { url = b }
+      return .string(join(gp($0, "val"), sep, url))
+    }
+    runStruct("minor", "slice", false) {
+      slice(gp($0, "val"), self.intArg(gp($0, "start")), self.intArg(gp($0, "end")))
+    }
+    runStruct("minor", "pad", false) {
+      let padding = self.intArg(gp($0, "pad"))
+      var padchar: Character = " "
+      if case .string(let c) = gp($0, "char"), let f = c.first { padchar = f }
+      return pad(lookup($0, .string("val")), padding, padchar)
     }
 
-    runset(
-      "minor.isnode", getprop(.map(minor), .string("isnode")) |> setProp("set"),
-      { .bool(isnode($0)) })
-    runset(
-      "minor.ismap", getprop(.map(minor), .string("ismap")) |> setProp("set"),
-      { .bool(ismap($0)) })
-    runset(
-      "minor.islist", getprop(.map(minor), .string("islist")) |> setProp("set"),
-      { .bool(islist($0)) })
-    runset(
-      "minor.iskey", getprop(.map(minor), .string("iskey")) |> setProp("set"),
-      { .bool(iskey($0)) })
-    runset(
-      "minor.isempty", getprop(.map(minor), .string("isempty")) |> setProp("set"),
-      { .bool(isempty($0)) })
-    runset(
-      "minor.size", getprop(.map(minor), .string("size")) |> setProp("set"),
-      { .int(Int64(size($0))) })
-    runset(
-      "minor.keysof", getprop(.map(minor), .string("keysof")) |> setProp("set"),
-      { .list(keysof($0).map { Value.string($0) }) })
-    runset(
-      "minor.haskey", getprop(.map(minor), .string("haskey")) |> setProp("set"),
-      { .bool(haskey(getprop($0, .string("src")), getprop($0, .string("key")))) })
-    runset(
-      "minor.getprop", getprop(.map(minor), .string("getprop")) |> setProp("set"),
-      {
-        getprop(
-          getprop($0, .string("val")),
-          getprop($0, .string("key")),
-          getprop($0, .string("alt")))
-      })
-    runset(
-      "minor.clone", getprop(.map(minor), .string("clone")) |> setProp("set"),
-      { clone($0) })
-    runset(
-      "minor.escre", getprop(.map(minor), .string("escre")) |> setProp("set"),
-      { .string(escre($0)) })
-    runset(
-      "minor.escurl", getprop(.map(minor), .string("escurl")) |> setProp("set"),
-      { .string(escurl($0)) })
-    runset(
-      "minor.stringify", getprop(.map(minor), .string("stringify")) |> setProp("set"),
-      {
-        if case .map(let m) = $0 {
-          let v = m.entries["val"] ?? .noval
-          let maxlen = m.entries["max"]?.asInt.map(Int.init)
-          return .string(stringify(v, maxlen))
-        }
-        return .string(stringify($0))
-      })
-
-    func mset(_ name: String) -> Value { getprop(.map(minor), .string(name)) |> setProp("set") }
-    runset("minor.isfunc", mset("isfunc"), { .bool(isfunc($0)) })
-    runset("minor.typify", mset("typify"), { .int(Int64(typify($0))) })
-    runset("minor.typename", mset("typename"), { .string(typename(Int($0.asInt ?? 0))) })
-    runset("minor.strkey", mset("strkey"), { .string(strkey($0)) })
-    runset(
-      "minor.getelem", mset("getelem"),
-      {
-        getelem(
-          getprop($0, .string("val")), getprop($0, .string("key")), getprop($0, .string("alt")))
-      })
-    runset("minor.items", mset("items"), { .list(items($0).map { Value.list($0) }) })
-    runset(
-      "minor.flatten", mset("flatten"),
-      {
-        flatten(getprop($0, .string("val")), getprop($0, .string("depth")).asInt.map(Int.init))
-      })
-    let filterChecks: [String: (Value, Value) -> Bool] = [
-      "gt3": { _, v in (v.asDouble ?? 0) > 3 },
-      "lt3": { _, v in (v.asDouble ?? 0) < 3 },
-    ]
-    runset(
-      "minor.filter", mset("filter"),
-      {
-        let check = strkey(getprop($0, .string("check")))
-        return filter(getprop($0, .string("val")), filterChecks[check] ?? { _, _ in false })
-      })
-    runset(
-      "minor.join", mset("join"),
-      {
-        let sep: String
-        if case .string(let s) = getprop($0, .string("sep")) { sep = s } else { sep = "," }
-        var url = false
-        if case .bool(let b) = getprop($0, .string("url")) { url = b }
-        return .string(join(getprop($0, .string("val")), sep, url))
-      })
-    runset(
-      "minor.jsonify", mset("jsonify"),
-      {
-        var indent = 2
-        var offset = 0
-        let flags = getprop($0, .string("flags"))
-        if case .map = flags {
-          if case .int(let n) = getprop(flags, .string("indent")) { indent = Int(n) }
-          if case .int(let n) = getprop(flags, .string("offset")) { offset = Int(n) }
-        }
-        return .string(jsonify(lookup($0, .string("val")), indent: indent, offset: offset))
-      })
-    runset(
-      "minor.pathify", mset("pathify"),
-      {
-        .string(
-          pathify(lookup($0, .string("path")), getprop($0, .string("from")).asInt.map(Int.init)))
-      })
-    runset(
-      "minor.slice", mset("slice"),
-      {
-        slice(
-          getprop($0, .string("val")),
-          getprop($0, .string("start")).asInt.map(Int.init),
-          getprop($0, .string("end")).asInt.map(Int.init))
-      })
-    runset(
-      "minor.pad", mset("pad"),
-      {
-        let padding = getprop($0, .string("pad")).asInt.map(Int.init)
-        let padchar: Character
-        if case .string(let c) = getprop($0, .string("char")), let f = c.first {
-          padchar = f
-        } else {
-          padchar = " "
-        }
-        return pad(lookup($0, .string("val")), padding, padchar)
-      })
-    runset(
-      "minor.setprop", mset("setprop"),
-      {
-        setprop(
-          clone(getprop($0, .string("parent"))), getprop($0, .string("key")),
-          lookup($0, .string("val")))
-      })
-    runset(
-      "minor.delprop", mset("delprop"),
-      {
-        delprop(clone(getprop($0, .string("parent"))), getprop($0, .string("key")))
-      })
-    runset(
-      "minor.setpath", mset("setpath"),
-      {
-        setpath(
-          clone(getprop($0, .string("store"))), getprop($0, .string("path")),
-          lookup($0, .string("val")))
-      })
+    // setprop/delprop/setpath REWRITE the container they are given, and
+    // minor.setpath asserts exactly that through `match: {args: ...}`, so
+    // the argument crosses by identity - no clone.
+    runStruct("minor", "setprop", true) {
+      setprop(gp($0, "parent"), gp($0, "key"), lookup($0, .string("val")))
+    }
+    runStruct("minor", "delprop", true) {
+      delprop(gp($0, "parent"), gp($0, "key"))
+    }
+    runStruct("minor", "setpath", false) {
+      setpath(gp($0, "store"), gp($0, "path"), lookup($0, .string("val")))
+    }
   }
 
-  // MARK: - Sentinels (null / absent unification across the readers)
-
-  func testSentinels() {
-    let s = loadStructSpec()
-    guard case .map(let sn) = getprop(s, .string("sentinels")) else { return }
-    func sset(_ name: String) -> Value { getprop(.map(sn), .string(name)) |> setProp("set") }
-    runset(
-      "sentinels.getprop_unify", sset("getprop_unify"),
-      {
-        getprop(
-          getprop($0, .string("val")), getprop($0, .string("key")), getprop($0, .string("alt")))
-      })
-    runset(
-      "sentinels.getelem_absent", sset("getelem_absent"),
-      {
-        getelem(
-          getprop($0, .string("val")), getprop($0, .string("key")), getprop($0, .string("alt")))
-      })
-    runset(
-      "sentinels.haskey_unify", sset("haskey_unify"),
-      {
-        .bool(haskey(getprop($0, .string("val")), getprop($0, .string("key"))))
-      })
-    runset("sentinels.isempty_unify", sset("isempty_unify"), { .bool(isempty($0)) })
-    runset("sentinels.isnode_unify", sset("isnode_unify"), { .bool(isnode($0)) })
-    runset("sentinels.stringify_null", sset("stringify_null"), { .string(stringify($0)) })
+  // MARK: - Null semantics
+  //
+  // The corpus group is `nullsem` - it was called `sentinels` once, and the
+  // retired engine kept driving the old name over zero entries.
+
+  func testNullsem() {
+    runStruct("nullsem", "getprop", false) {
+      getprop(gp($0, "val"), gp($0, "key"), self.raw($0, "alt"))
+    }
+    runStruct("nullsem", "getelem", false) {
+      getelem(gp($0, "val"), gp($0, "key"), gp($0, "alt"))
+    }
+    runStruct("nullsem", "getpath", false) {
+      getpath(gp($0, "store"), gp($0, "path"))
+    }
+    runStruct("nullsem", "haskey", false) {
+      .bool(haskey(gp($0, "src"), gp($0, "key")))
+    }
+    runStruct("nullsem", "keysof", false) {
+      .list(keysof($0).map { Value.string($0) })
+    }
   }
 
   // MARK: - Walk
 
   func testWalkBasic() {
-    let s = loadStructSpec()
-    let walkBasic = getprop(getprop(s, .string("walk")), .string("basic"))
-    let set = getprop(walkBasic, .string("set"))
     let walkpath: WalkApply = { _, v, _, path in
       if case .string(let s) = v {
         return .string(s + "~" + path.joined(separator: "."))
       }
       return v
     }
-    runset("walk.basic", set, { walk(clone($0), walkpath) })
+    runStruct("walk", "basic", true) { walk($0, walkpath) }
   }
 
   // MARK: - Getpath
 
   func testGetpathBasic() {
-    let s = loadStructSpec()
-    let set = getprop(getprop(s, .string("getpath")), .string("basic")) |> setProp("set")
-    runset(
-      "getpath.basic", set,
-      {
-        getpath(getprop($0, .string("store")), getprop($0, .string("path")))
-      })
+    runStruct("getpath", "basic", true) {
+      getpath(gp($0, "store"), gp($0, "path"))
+    }
   }
 
   // MARK: - Merge
 
-  func testMergeBasic() {
-    let s = loadStructSpec()
-    let mergeSpec = getprop(s, .string("merge"))
-    if case .map(let mm) = mergeSpec {
-      for (name, sub) in mm.entries {
-        if name == "name" { continue }
-        let set = getprop(sub, .string("set"))
-        if name == "depth" {
-          // depth set has shape {val: [...], depth: N}
-          runset(
-            "merge.\(name)", set,
-            {
-              let val = getprop($0, .string("val"))
-              let depth = getprop($0, .string("depth")).asInt.map(Int.init) ?? MAXDEPTH
-              return merge(clone(val), depth)
-            })
-        } else {
-          runset("merge.\(name)", set, { merge(clone($0)) })
-        }
-      }
+  func testMerge() {
+    // merge.integrity asserts through `match: {args: ...}` that merge does
+    // NOT rewrite the list it was handed, so nothing is cloned here.
+    runStruct("merge", "cases", true) { merge($0) }
+    runStruct("merge", "array", true) { merge($0) }
+    runStruct("merge", "integrity", true) { merge($0) }
+    runStruct("merge", "depth", true) {
+      merge(gp($0, "val"), self.intArg(gp($0, "depth")) ?? MAXDEPTH)
     }
   }
 
   // MARK: - Inject
 
   func testInject() {
-    let s = loadStructSpec()
-    let injectSpec = getprop(s, .string("inject"))
-    guard case .map(let im) = injectSpec else { return }
-    // Single-entry `basic` is not a `.set`.
-    if let basic = im.entries["basic"], case .map(let bm) = basic, let inv = bm.entries["in"] {
-      let got = inject(
-        clone(getprop(inv, .string("val"))),
-        getprop(inv, .string("store")))
-      let exp = bm.entries["out"] ?? .noval
-      XCTAssertEqual(canon(got), canon(exp), "inject.basic")
+    runStruct("inject", "string", true) {
+      let inj = Injection(val: .noval, parent: .noval)
+      inj.modify = OmniResolver.nullModifier
+      return inject(gp($0, "val"), gp($0, "store"), inj)
     }
-    // String / deep variants apply the NULLMARK fixup.
-    if let stringSet = im.entries["string"], case .map(let sm) = stringSet,
-      let set = sm.entries["set"], case .list(let sl) = set
-    {
-      var pass = 0
-      var fail = 0
-      for (i, entry) in sl.items.enumerated() {
-        guard case .map(let em) = entry else { continue }
-        if em.entries["err"] != nil { continue }
-        let inVal = em.entries["in"] ?? .noval
-        let v = fixNull(clone(getprop(inVal, .string("val"))))
-        let st = fixNull(clone(getprop(inVal, .string("store"))))
-        let runInj = Injection(val: .noval, parent: .noval)
-        runInj.modify = nullModifier
-        let got = inject(v, st, runInj)
-        let exp = em.entries["out"] ?? .noval
-        if canon(got) == canon(exp) {
-          pass += 1
-        } else {
-          fail += 1
-          if fail <= 5 { print("[inject.string#\(i)] exp=\(canon(exp)) got=\(canon(got))") }
-        }
-      }
-      if fail > 0 {
-        XCTFail("inject.string: \(pass)/\(pass + fail)")
-      } else {
-        print("ok inject.string: \(pass)/\(pass)")
-      }
-    }
-    if let deepSet = im.entries["deep"], case .map(let dm) = deepSet,
-      let set = dm.entries["set"]
-    {
-      runset(
-        "inject.deep", set,
-        {
-          inject(
-            clone(getprop($0, .string("val"))),
-            getprop($0, .string("store")))
-        })
+    runStruct("inject", "deep", true) {
+      inject(gp($0, "val"), gp($0, "store"))
     }
   }
 
   // MARK: - Transform
 
   func testTransform() {
-    let s = loadStructSpec()
-    let txSpec = getprop(s, .string("transform"))
-    guard case .map(let tm) = txSpec else { return }
-    if let basic = tm.entries["basic"], case .map(let bm) = basic, let inv = bm.entries["in"] {
-      let got = transform(
-        clone(getprop(inv, .string("data"))),
-        clone(getprop(inv, .string("spec"))))
-      let exp = bm.entries["out"] ?? .noval
-      XCTAssertEqual(canon(got), canon(exp), "transform.basic")
-    }
-    for name in ["paths", "cmds", "each", "pack", "ref", "apply", "format"] {
-      if let sub = tm.entries[name], case .map(let sm) = sub,
-        let set = sm.entries["set"]
-      {
-        runset(
-          "transform.\(name)", set,
-          {
-            transform(
-              clone(getprop($0, .string("data"))),
-              clone(getprop($0, .string("spec"))))
-          })
+    for name in ["paths", "cmds", "each", "pack", "ref"] {
+      runStruct("transform", name, true) {
+        let (inj, errs) = self.errCollector()
+        let out = transform(gp($0, "data"), gp($0, "spec"), inj)
+        try self.raiseErrs(errs)
+        return out
       }
     }
-    // Modify uses an `@`-prefix string modifier.
-    if let sub = tm.entries["modify"], case .map(let sm) = sub,
-      let set = sm.entries["set"]
-    {
-      runset(
-        "transform.modify", set,
-        {
-          let runInj = Injection(val: .noval, parent: .noval)
-          runInj.modify = { val, key, parent, _, _ in
-            if case .string(let s) = val {
-              setprop(parent, key, .string("@" + s))
-            }
-          }
-          return transform(
-            clone(getprop($0, .string("data"))),
-            clone(getprop($0, .string("spec"))),
-            runInj)
-        })
+    runStruct("transform", "format", false) {
+      let (inj, errs) = self.errCollector()
+      let out = transform(gp($0, "data"), gp($0, "spec"), inj)
+      try self.raiseErrs(errs)
+      return out
+    }
+    runStruct("transform", "apply", true) {
+      let (inj, errs) = self.errCollector()
+      let out = transform(gp($0, "data"), gp($0, "spec"), inj)
+      try self.raiseErrs(errs)
+      return out
+    }
+    runStruct("transform", "modify", true) {
+      let inj = Injection(val: .noval, parent: .noval)
+      inj.modify = { val, key, parent, _, _ in
+        if case .string(let s) = val, !s.isEmpty {
+          setprop(parent, key, .string("@" + s))
+        }
+      }
+      return transform(gp($0, "data"), gp($0, "spec"), inj)
     }
   }
 
   // MARK: - Validate
 
   func testValidate() {
-    let s = loadStructSpec()
-    let vSpec = getprop(s, .string("validate"))
-    guard case .map(let vm) = vSpec else { return }
-    for name in ["basic", "child", "one", "exact", "invalid", "special"] {
-      if let sub = vm.entries[name], case .map(let sm) = sub,
-        let set = sm.entries["set"]
-      {
-        runset(
-          "validate.\(name)", set,
-          { entry in
-            let runInj: Injection?
-            if case .map(let im) = getprop(entry, .string("inj")) {
-              let i = Injection(val: .noval, parent: .noval)
-              i.meta = im
-              runInj = i
-            } else if let ij = (entry.asMap?.entries["inj"]), case .map(let im) = ij {
-              let i = Injection(val: .noval, parent: .noval)
-              i.meta = im
-              runInj = i
-            } else {
-              runInj = nil
-            }
-            return validate(
-              clone(getprop(entry, .string("data"))),
-              clone(getprop(entry, .string("spec"))),
-              runInj)
-          })
+    for (name, nullFlag) in [
+      ("basic", false), ("child", true), ("one", true),
+      ("exact", true), ("invalid", false), ("special", true),
+    ] {
+      runStruct("validate", name, nullFlag) {
+        let (inj, errs) = self.errCollector()
+        if case .map(let im) = gp($0, "inj"), let meta = im.entries["meta"]?.asMap {
+          inj.meta = meta
+        }
+        let out = validate(self.raw($0, "data"), self.raw($0, "spec"), inj)
+        try self.raiseErrs(errs)
+        return out
       }
     }
   }
@@ -479,45 +363,10 @@ final class StructUtilityTest: XCTestCase {
   // MARK: - Select
 
   func testSelect() {
-    let s = loadStructSpec()
-    let sSpec = getprop(s, .string("select"))
-    guard case .map(let sm) = sSpec else { return }
     for name in ["basic", "operators", "edge", "alts"] {
-      if let sub = sm.entries[name], case .map(let ssm) = sub,
-        let set = ssm.entries["set"], case .list(let sl) = set
-      {
-        var pass = 0
-        var fail = 0
-        for (i, entry) in sl.items.enumerated() {
-          guard case .map(let em) = entry else { continue }
-          if em.entries["err"] != nil { continue }
-          let inVal = em.entries["in"] ?? .noval
-          let obj = fixNull(clone(getprop(inVal, .string("obj"))))
-          let q = fixNull(clone(getprop(inVal, .string("query"))))
-          let got = select(obj, q)
-          let exp = fixNull(clone(em.entries["out"] ?? .noval))
-          if canon(got) == canon(exp) {
-            pass += 1
-          } else {
-            fail += 1
-            if fail <= 5 {
-              print("[select.\(name)#\(i)] exp=\(canon(exp)) got=\(canon(got))")
-            }
-          }
-        }
-        if fail > 0 {
-          XCTFail("select.\(name): \(pass)/\(pass + fail)")
-        } else {
-          print("ok select.\(name): \(pass)/\(pass)")
-        }
+      runStruct("select", name, true) {
+        select(gp($0, "obj"), gp($0, "query"))
       }
     }
   }
 }
-
-// Convenience: "x |> setProp(y)" sugar to chain a getprop access.
-infix operator |> : MultiplicationPrecedence
-private func |> (lhs: Value, rhs: (Value) -> Value) -> Value { rhs(lhs) }
-private func setProp(_ key: String) -> (Value) -> Value {
-  { v in getprop(v, .string(key)) }
-}