@voxgig/sdkgen 4.2.8 → 4.4.0

package/project/.sdk/tm/js/test/feature/Corpus.test.js

@@ -0,0 +1,285 @@
+
+// Feature behaviour, driven by the SHARED corpus.
+//
+// This is the route PrimaryUtility.test.ts already takes for the utilities:
+// language-neutral cases in .sdk/test/test.json, executed against the REAL
+// generated SDK. Features here are ordinary classes in ordinary compiled
+// source, unit-tested the ordinary way — no transpiled templates, and no
+// miniature of the pipeline standing in for the pipeline (which is what
+// harness.ts does, and why its assertions can only be as right as the
+// miniature is). A feature is built through the generated config, wrapped
+// into a client built by the generated constructor, and driven by a real
+// entity operation. What is asserted is what ships.
+//
+// Everything in a case is data: features are activated by name, options are
+// plain JSON, the transport is scripted by `res`, and the assertion is a
+// subset of the client's own record. Turning `res` into a fetcher is the one
+// piece each language writes for itself.
+//
+// The ts twin of this file is the reference; keep the two in step.
+
+const { test, describe, before } = require('node:test')
+const { ok, deepStrictEqual } = require('node:assert')
+
+const { readFileSync } = require('node:fs')
+const { join } = require('node:path')
+
+const { SDK, TEST_JSON_FILE } = require('../utility/index')
+
+
+// Features with a corpus section. A name here with no section is a skip, not
+// a failure: an SDK generated without the feature has nothing to run.
+const FEATURES = ['cost']
+
+
+// One operation this SDK can actually perform is described by
+// { key, accessor, entity, op }: `key` is '<entity>.<op>', how features
+// attribute spend, and `accessor` is the client method returning the entity.
+
+
+// A scripted transport built from a case's `res` list. Responses are consumed
+// in order and the last one repeats, so a case that does not care how many
+// attempts happen need only declare one.
+function scriptedFetcher(res) {
+  let n = -1
+  return async function (_ctx, _url, _fetchdef) {
+    n++
+    const spec = res[n < res.length ? n : res.length - 1] || {}
+
+    if (true === spec.throw) {
+      throw new Error('scripted transport failure')
+    }
+
+    const headers = spec.headers || {}
+    const status = null == spec.status ? 200 : spec.status
+
+    return {
+      status,
+      statusText: status < 400 ? 'OK' : 'ERR',
+      body: 'not-used',
+      json: async () => (undefined === spec.body ? {} : spec.body),
+      headers: {
+        get(key) {
+          const lower = String(key).toLowerCase()
+          for (const k of Object.keys(headers)) {
+            if (k.toLowerCase() === lower) { return headers[k] }
+          }
+          return undefined
+        },
+        forEach(cb) { Object.keys(headers).forEach((k) => cb(headers[k], k, this)) },
+      },
+    }
+  }
+}
+
+
+function makeClient(kase) {
+  return new SDK({
+    feature: kase.feature,
+    utility: { fetcher: scriptedFetcher(kase.res || [{ status: 200, body: {} }]) },
+  })
+}
+
+
+// Every operation this SDK declares, in a stable order.
+//
+// The corpus cannot name an entity — it is shared by SDKs that have none in
+// common — so the runner finds them here. The generated client exposes one
+// capitalised, zero-argument accessor per entity, and the entity it returns
+// carries the same `name` the config is keyed by; that pairing is what turns
+// a config entry back into a callable method.
+function candidates(client) {
+  const entities = client._rootctx.config.entity || {}
+
+  const accessor = {}
+  for (const m of Object.getOwnPropertyNames(Object.getPrototypeOf(client))) {
+    if (!/^[A-Z]/.test(m) || 'function' !== typeof client[m]) { continue }
+    let inst
+    try { inst = client[m]() }
+    catch (e) { continue }
+    if (null != inst && 'string' === typeof inst.name && null != entities[inst.name]) {
+      accessor[inst.name] = m
+    }
+  }
+
+  const out = []
+  for (const entity of Object.keys(entities).sort()) {
+    if (null == accessor[entity]) { continue }
+    for (const op of Object.keys(entities[entity].op || {}).sort()) {
+      out.push({ key: entity + '.' + op, accessor: accessor[entity], entity, op })
+    }
+  }
+  return out
+}
+
+
+// Pick operations the corpus can drive, by DRIVING them: an op is usable when
+// it completes against a plain 200 with no feature active. Declared ops are
+// not all callable with no arguments (a required path parameter, a body), and
+// a case that failed for that reason would look like a feature defect.
+async function usableOps(want) {
+  const picked = []
+  for (const cand of candidates(makeClient({}))) {
+    const client = makeClient({})
+    try {
+      await client[cand.accessor]()[cand.op]({}, {})
+    }
+    catch (e) { continue }
+    picked.push(cand)
+    if (want <= picked.length) { break }
+  }
+  return picked
+}
+
+
+// Replace #OP1/#OP2 throughout a case, keys included.
+function resolve(node, tokens) {
+  if ('string' === typeof node) {
+    let s = node
+    for (const t of Object.keys(tokens)) { s = s.split(t).join(tokens[t]) }
+    return s
+  }
+  if (Array.isArray(node)) {
+    return node.map((n) => resolve(n, tokens))
+  }
+  if (null != node && 'object' === typeof node) {
+    const out = {}
+    for (const k of Object.keys(node)) {
+      out[resolve(k, tokens)] = resolve(node[k], tokens)
+    }
+    return out
+  }
+  return node
+}
+
+
+// Which #OPn tokens a case uses. A case wanting more operations than this SDK
+// has is skipped rather than failed.
+function tokensUsed(kase) {
+  const m = JSON.stringify(kase).match(/#OP(\d+)/g) || []
+  return m.reduce((max, t) => Math.max(max, Number(t.slice(3))), 0)
+}
+
+
+// Assert that `actual` contains `expect`, recursively. Cases assert only the
+// fields they are about, so a full deepStrictEqual would force every case to
+// restate the whole record.
+function subset(actual, expect, path) {
+  if (null != expect && 'object' === typeof expect && !Array.isArray(expect)) {
+    for (const k of Object.keys(expect)) {
+      ok(null != actual, `${path}.${k}: nothing at ${path}`)
+      subset(actual[k], expect[k], `${path}.${k}`)
+    }
+    return
+  }
+  deepStrictEqual(actual, expect, path)
+}
+
+
+describe('FeatureCorpus', () => {
+
+  let corpus
+  let ops = []
+  let byKey = {}
+
+
+  before(async () => {
+    corpus = JSON.parse(readFileSync(join(__dirname, '..', TEST_JSON_FILE), 'utf8'))
+    ops = await usableOps(2)
+    byKey = {}
+    for (const o of ops) { byKey[o.key] = o }
+  })
+
+
+  // A corpus with no `feature` section is a SKIP, not a failure.
+  //
+  // Each project carries its OWN materialised copy of .sdk/test/test.json, so
+  // a project scaffolded before the section existed legitimately has no cases
+  // to run - and a hard assertion here turned that into a red suite in every
+  // SDK on the fleet, for a corpus the project had simply not re-pulled yet.
+  //
+  // The strict check belongs where the corpus is CONTROLLED, not where it is
+  // consumed: sdkgen's own end-to-end lane generates against a corpus it
+  // supplies and requires the cases to actually run, so a section that goes
+  // missing there still fails loudly.
+  test('the corpus carries a feature section', (t) => {
+    if (null == corpus.feature) {
+      return t.skip(
+        'this project\'s test.json has no `feature` section - recompile the ' +
+        'corpus (create-sdkgen .sdk/test/feature/) to run these cases')
+    }
+  })
+
+
+  // At least one operation, or every case below would skip and the whole
+  // suite would report green having run nothing.
+  test('this SDK has an operation the corpus can drive', () => {
+    ok(0 < ops.length,
+      'no declared operation completed against a plain 200 — the corpus ' +
+      'cannot exercise a feature without one')
+  })
+
+
+  for (const name of FEATURES) {
+
+    test(name, async (t) => {
+      const section = corpus.feature?.[name]
+      if (null == section) {
+        return t.skip(`no corpus section for ${name}`)
+      }
+
+      const probe = makeClient({})
+      if (!probe._rootctx.config.hasFeature(name)) {
+        return t.skip(`this SDK was generated without the ${name} feature`)
+      }
+
+      const cases = section.basic?.set || []
+      ok(0 < cases.length,
+        `corpus section feature.${name} ran ZERO cases — a renamed section ` +
+        `or an emptied fixture must fail loudly, not pass silently`)
+
+      let ran = 0
+      for (const raw of cases) {
+        const need = tokensUsed(raw)
+        if (ops.length < need) {
+          t.diagnostic(`skip "${raw.name}": needs ${need} operations, this SDK offers ${ops.length}`)
+          continue
+        }
+
+        const tokens = {}
+        for (let i = 0; i < need; i++) { tokens['#OP' + (i + 1)] = ops[i].key }
+
+        const kase = resolve(raw, tokens)
+        const client = makeClient(kase)
+
+        for (const step of (kase.op || [])) {
+          const ref = byKey[step.op]
+          ok(null != ref, `${kase.name}: no operation ${step.op}`)
+          try {
+            await client[ref.accessor]()[ref.op]({}, step.ctrl || {})
+            ok(null == step.err,
+              `${kase.name}: ${step.op} was expected to fail, and did not`)
+          }
+          catch (err) {
+            if (null == step.err) { throw err }
+            if ('string' === typeof step.err) {
+              deepStrictEqual(err.code, step.err, `${kase.name}: wrong error code`)
+            }
+          }
+        }
+
+        subset(client[`_${name}`], kase.out, `${kase.name}: _${name}`)
+        ran++
+      }
+
+      ok(0 < ran, `every feature.${name} case was skipped`)
+      // Say how many ran. A partial run is legitimate (an SDK with one
+      // operation skips the cases needing two) but it should be visible
+      // rather than inferred from a green tick - and it is the one line
+      // sdkgen's end-to-end lane reads, in the same wording, from every
+      // language's runner.
+      t.diagnostic(`feature.${name}: ran ${ran} of ${cases.length} ` +
+        `case(s) against ${ops.length} operation(s)`)
+    })
+  }
+})

package/project/.sdk/tm/kotlin/utility/MakeOptions.kt

@@ -2,6 +2,7 @@ package KOTLINPACKAGE.utility
 
 import KOTLINPACKAGE.core.Context
 import KOTLINPACKAGE.core.Helpers
+import KOTLINPACKAGE.core.Utility
 import KOTLINPACKAGE.utility.struct.Struct
 
 @Suppress("UNCHECKED_CAST")
@@ -11,11 +12,20 @@ fun makeOptions(ctx: Context): MutableMap<String, Any?> {
     options = linkedMapOf()
   }
 
-  // Merge custom utility overrides onto the utility object.
+  // Merge utility overrides from options onto the utility object.
   // Read from original options before clone for parity with the donors.
+  //
+  // A key naming a real utility member REPLACES it; anything else is attached
+  // as a custom extra. Shelving everything in `custom` - a map nothing reads -
+  // made `utility = mapOf("fetcher" to ...)`, the documented transport seam, a
+  // silent no-op here while ts honoured it.
   val customUtils = Helpers.toMapAny(options["utility"])
   if (customUtils != null && ctx.utility != null) {
-    ctx.utility!!.custom.putAll(customUtils)
+    for ((key, value) in customUtils) {
+      if (!overrideUtil(ctx.utility!!, key, value)) {
+        ctx.utility!!.custom[key] = value
+      }
+    }
   }
 
   var opts = Struct.clone(options) as MutableMap<String, Any?>
@@ -165,3 +175,47 @@ fun makeOptions(ctx: Context): MutableMap<String, Any?> {
 
   return opts
 }
+
+
+/**
+ * Replaces one utility member from `options.utility`, matching the ts
+ * reference: a key naming a real member REPLACES it, and any other key is
+ * attached as a custom extra. Returns false when the key names no member or
+ * the value is not that member's type, so the caller keeps it in `custom`.
+ *
+ * REFLECTION, NOT A KEYED SWITCH. The go and java ports list every member by
+ * hand and carry a "keep this in step with registerAll" warning, because a
+ * utility added to one list and not the other is overridable there and not
+ * here. The field set is readable off the class, so the list cannot drift.
+ *
+ * Kotlin function types erase to FunctionN, so `isInstance` checks arity and
+ * not the full signature - the same limit java's port documents. A wrongly
+ * shaped value of the right arity is accepted, exactly as the dynamic donors
+ * accept whatever they are given.
+ *
+ * Only a PUBLIC name may replace a member: public utility names are camelCase
+ * and carry no underscore, so an underscore means the caller named something
+ * of their own rather than a member.
+ */
+internal fun overrideUtil(utility: Utility, key: String, value: Any?): Boolean {
+  if (key.isEmpty() || key.contains('_') || "custom" == key) {
+    return false
+  }
+  if (null == value) {
+    return false
+  }
+
+  val field = try {
+    Utility::class.java.getDeclaredField(key)
+  } catch (e: NoSuchFieldException) {
+    return false
+  }
+
+  if (!field.type.isInstance(value)) {
+    return false
+  }
+
+  field.isAccessible = true
+  field.set(utility, value)
+  return true
+}

package/project/.sdk/tm/lua/utility/make_options.lua

@@ -5,13 +5,33 @@ local vs = require("utility.struct.struct")
 local function make_options_util(ctx)
   local options = ctx.options or {}
 
-  -- Merge custom utility overrides.
+  -- Merge utility overrides from options onto the utility object.
+  --
+  -- A key naming a real utility member REPLACES it; anything else is attached
+  -- as a custom extra. Shelving everything in `custom` - a table nothing reads
+  -- - made `utility = { fetcher = ... }`, the documented transport seam, a
+  -- silent no-op here while ts honoured it.
+  --
+  -- Option keys are camelCase, as ts spells them; members here are
+  -- snake_case. Only a PUBLIC name may replace: public utility names carry no
+  -- underscore, so an underscore means the caller named something of their
+  -- own - possibly the internal spelling of a real member. `make_error` must
+  -- stay an extension, or a non-callable would break the error path on the
+  -- next request.
   local custom_utils = vs.getprop(options, "utility")
   if type(custom_utils) == "table" then
     local utility = ctx.utility
     if utility ~= nil then
       for key, val in pairs(custom_utils) do
-        utility.custom[key] = val
+        local member = nil
+        if type(key) == "string" and not key:find("_") then
+          member = key:gsub("(%u)", function(c) return "_" .. c:lower() end)
+        end
+        if member ~= nil and member ~= "custom" and utility[member] ~= nil then
+          utility[member] = val
+        else
+          utility.custom[key] = val
+        end
       end
     end
   end

package/project/.sdk/tm/ocaml/Makefile

@@ -34,11 +34,16 @@ SDK_TEST = $(RUNTIME) sdk_config.ml $(ENTITIES) sdk_client.ml sdk_error.ml \
   $(ENTITY_TESTS) $(DOC_TESTS) test/t_main.ml
 
 CORPUS_SRC = utility/vregex.ml utility/voxgig_struct.ml sdk_json.ml \
-  test/struct_corpus.ml
+  test/corpus_runner.ml test/struct_corpus.ml
 
-.PHONY: test test-sdk test-corpus build lint clean
+# The primary-utility corpus needs the whole SDK, because it drives the SDK's
+# own request-shaping utilities — not just the struct library.
+PRIMARY_SRC = $(RUNTIME) sdk_config.ml $(ENTITIES) sdk_client.ml sdk_error.ml \
+  test/corpus_runner.ml test/primary_utility_test.ml
 
-test: test-sdk test-corpus
+.PHONY: test test-sdk test-corpus test-primary build lint clean
+
+test: test-sdk test-corpus test-primary
 
 test-sdk: run_sdk_test
 	./run_sdk_test
@@ -50,7 +55,13 @@ run_sdk_test: $(SDK_TEST)
 	$(OCAMLC) $(INC) $(SDK_TEST) -o run_sdk_test
 
 run_struct_corpus: $(CORPUS_SRC)
-	$(OCAMLC) -I utility $(CORPUS_SRC) -o run_struct_corpus
+	$(OCAMLC) -I utility -I test $(CORPUS_SRC) -o run_struct_corpus
+
+test-primary: run_primary_corpus
+	./run_primary_corpus $(CORPUS)
+
+run_primary_corpus: $(PRIMARY_SRC)
+	$(OCAMLC) $(INC) $(PRIMARY_SRC) -o run_primary_corpus
 
 # Type-check the SDK library (a clean compile means it is sound).
 build: lint

package/project/.sdk/tm/ocaml/sdk_runtime.ml

@@ -345,7 +345,14 @@ let prepare_method_util (ctx : ctx) : string =
   | _ ->
     match ctx.c_op.op_name with
     | "create" -> "POST" | "update" -> "PUT" | "load" -> "GET"
-    | "list" -> "GET" | "remove" -> "DELETE" | "patch" -> "PATCH" | _ -> "GET"
+    | "list" -> "GET" | "remove" -> "DELETE" | "patch" -> "PATCH"
+    (* NO CATCH-ALL GET. The ts reference returns methodMap[key], which is
+     * undefined for an op the map does not name — the request is then rejected
+     * rather than silently issued. A `| _ -> "GET"` here turned every
+     * unrecognised op into a GET, which is both a divergence from the corpus
+     * (which expects no method for opname "bad") and the more dangerous of the
+     * two behaviours: a mistyped or unsupported op quietly fetched. *)
+    | _ -> ""
 
 let prepare_headers_util (ctx : ctx) : value =
   let options = client_options_map (cc ctx) in

package/project/.sdk/tm/ocaml/test/corpus_runner.ml

@@ -0,0 +1,185 @@
+(* Shared corpus harness for the ProjectName SDK.
+ *
+ * Extracted from struct_corpus.ml so the primary-utility suite can drive the
+ * SAME runner over test.json's "primary" section. OCaml runs a module's
+ * top-level effects on link, so a harness sitting beside a `let () = ...` main
+ * cannot be reused — linking it would run the struct corpus as a side effect.
+ * This module deliberately has no main.
+ *)
+
+(* Test runner for the shared JSON corpus (build/test/test.json).
+ * Self-contained: an in-tree JSON reader builds the library's `value` type
+ * directly, so the OCaml port is exercised exactly as in production. *)
+
+open Voxgig_struct
+
+let nullmark = "__NULL__"
+let undefmark = "__UNDEF__"
+let existsmark = "__EXISTS__"
+
+(* The JSON reader now lives in the runtime (sdk_json.ml) so the SDK's
+ * generated config can use it; the corpus runs against that same function
+ * rather than a second copy that could drift from it. *)
+let json_read = Sdk_json.json_read
+
+(* ---------------- fixJSON / equality ---------------- *)
+
+let rec fix_json v flag_null =
+  match v with
+  | Noval | Null -> if flag_null then Str nullmark else v
+  | Map m -> let o = empty_map () in
+    List.iter (fun (k, x) -> ignore (setprop o (Str k) (fix_json x flag_null))) m.entries; o
+  | List r -> lst (List.map (fun x -> fix_json x flag_null) !r)
+  | _ -> v
+
+(* Order-independent deep equality for maps; sequence equality for lists. *)
+let rec eqv a b =
+  match a, b with
+  | (Noval | Null), (Noval | Null) -> true
+  | Bool x, Bool y -> x = y
+  | Num x, Num y -> x = y
+  | Str x, Str y -> x = y
+  | List x, List y -> List.length !x = List.length !y && List.for_all2 eqv !x !y
+  | Map x, Map y ->
+    omap_len x = omap_len y &&
+    List.for_all (fun (k, v) -> match omap_get y k with Some w -> eqv v w | None -> false) x.entries
+  | _ -> a == b
+
+(* ---------------- match support ---------------- *)
+
+let matchval check base =
+  let check = if check = Str undefmark || check = Str nullmark then Noval else check in
+  if eqv check base then true
+  else match check with
+    | Str cs ->
+      let basestr = stringify base in
+      if String.length cs >= 2 && cs.[0] = '/' && cs.[String.length cs - 1] = '/' then
+        Vregex.test_str (String.sub cs 1 (String.length cs - 2)) basestr
+      else
+        let low s = String.lowercase_ascii s in
+        let contains hay needle =
+          let hl = String.length hay and nl = String.length needle in
+          let rec go i = if i + nl > hl then false
+            else if String.sub hay i nl = needle then true else go (i + 1) in
+          nl = 0 || go 0 in
+        contains (low basestr) (low (stringify check))
+    | Func _ -> true
+    | _ -> false
+
+let do_match check base =
+  let base = clone base in
+  ignore (walk ~before:(fun _k v _p path ->
+      (if not (isnode v) then begin
+          let baseval = getpath base path in
+          if eqv baseval v then ()
+          else if v = Str undefmark && is_nullish baseval then ()
+          else if v = Str existsmark && not (is_nullish baseval) then ()
+          else if not (matchval v baseval) then
+            raise (Struct_error (Printf.sprintf "MATCH: %s: [%s] <=> [%s]"
+                                   (String.concat "." (List.map js_string (match path with List r -> !r | _ -> [])))
+                                   (stringify v) (stringify baseval)))
+        end);
+      v) check)
+
+(* ---------------- result tracking ---------------- *)
+
+let npass = ref 0
+let nfail = ref 0
+let failures = ref []
+
+let record group name ok msg =
+  if ok then incr npass
+  else (incr nfail; failures := Printf.sprintf "FAIL %s %s - %s" group name msg :: !failures)
+
+(* ---------------- per-entry runner ---------------- *)
+
+let omap_v kvs =
+  let m = empty_map () in
+  List.iter (fun (k, v) -> ignore (setprop m (Str k) v)) kvs; m
+
+let getprop_raw_pub e k = (match e with Map m -> (match omap_get m k with Some x -> x | None -> Noval) | _ -> Noval)
+let entry_get e k = getprop_raw_pub e k
+let entry_has e k = match e with Map m -> omap_has m k | _ -> false
+let default_injdef_pub () =
+  { d_meta = Noval; d_extra = Noval; d_errs = Noval; d_modify = None; d_handler = None;
+    d_base = Noval; d_dparent = Noval; d_dpath = Noval; d_key = Noval }
+
+let resolve_args entry =
+  if entry_has entry "ctx" then [entry_get entry "ctx"]
+  else if entry_has entry "args" then (
+    match entry_get entry "args" with
+    | List r ->
+      (* ts's resolveArgs writes the live first arg back as entry.ctx, so a
+         `match: {ctx: ...}` resolves for args-style entries too. Without it
+         every such assertion reads null and asserts nothing. *)
+      (match !r with
+       | (Map _ as first) :: _ -> ignore (setprop entry (Str "ctx") first)
+       | _ -> ());
+      !r
+    | _ -> [])
+  else if entry_has entry "in" then [clone (entry_get entry "in")]
+  else [Noval]
+
+let check_result entry args res =
+  let matched = ref false in
+  (if entry_has entry "match" then begin
+      do_match (entry_get entry "match")
+        (omap_v ["in", entry_get entry "in"; "args", lst args;
+                 "out", entry_get entry "res"; "ctx", entry_get entry "ctx"]);
+      matched := true
+    end);
+  let out = entry_get entry "out" in
+  if eqv out res then ()
+  else if !matched && (out = Str nullmark || is_nullish out) then ()
+  else raise (Struct_error (Printf.sprintf "Expected: %s, got: %s" (stringify out) (stringify res)))
+
+let handle_error entry err =
+  let msg = (match err with Struct_error m -> m | e -> Printexc.to_string e) in
+  if entry_has entry "err" then begin
+    let entry_err = entry_get entry "err" in
+    if entry_err = Bool true || matchval entry_err (Str msg) then begin
+      if entry_has entry "match" then
+        do_match (entry_get entry "match")
+          (omap_v ["in", entry_get entry "in"; "out", entry_get entry "res";
+                   (* ts hands do_match the ERROR OBJECT, so a corpus
+                      `match: {err: {message: ...}}` resolves; a bare string
+                      leaves err.message reading null. *)
+                   "ctx", entry_get entry "ctx";
+                   "err", omap_v ["message", Str msg]])
+    end else
+      raise (Struct_error (Printf.sprintf "ERROR MATCH: [%s] <=> [%s]" (stringify entry_err) msg))
+  end else raise err
+
+let run_set ?(flags = []) group node subject =
+  let flag_null = (match List.assoc_opt "null" flags with Some b -> b | None -> true) in
+  let fixed = fix_json node flag_null in
+  let testset = (match getprop fixed (Str "set") with List r -> !r | _ -> []) in
+  List.iter (fun entry ->
+      let name = js_string (entry_get entry "name") in
+      try
+        (if not (entry_has entry "out") && flag_null then ignore (setprop entry (Str "out") (Str nullmark)));
+        let args = resolve_args entry in
+        let res = fix_json (subject args) flag_null in
+        ignore (setprop entry (Str "res") res);
+        check_result entry args res;
+        record group name true ""
+      with
+      | e ->
+        (try handle_error entry e; record group name true ""
+         with e2 -> record group name false
+                      (match e2 with Struct_error m -> m | _ -> Printexc.to_string e2)))
+    testset
+
+let run_single group node actual_fn =
+  try
+    let expected = getprop_raw_pub node "out" in
+    let actual = actual_fn (getprop_raw_pub node "in") in
+    if eqv expected actual then record group "single" true ""
+    else record group "single" false (Printf.sprintf "Expected: %s, got: %s" (stringify expected) (stringify actual))
+  with e -> record group "single" false (match e with Struct_error m -> m | _ -> Printexc.to_string e)
+
+(* ---------------- arg helpers ---------------- *)
+
+let arg1 f = fun args -> f (match args with x :: _ -> x | [] -> Noval)
+let vget vin k = match vin with Map m -> (match omap_get m k with Some x -> x | None -> Noval) | _ -> Noval
+let vhas vin k = match vin with Map m -> omap_has m k | _ -> false