@voxgig/sdkgen 4.8.2 → 4.8.3

package/project/.sdk/tm/java/test/StructRunner.java

@@ -1,281 +0,0 @@
-package JAVAPACKAGE.sdktest;
-
-// Vendored from the voxgig struct java port's test Runner (src/test/Runner.java),
-// adapted for this SDK: the corpus comes from ../.sdk/test/test.json (root key
-// "struct"), and JSON handling uses the SDK's zero-dep Json/Struct utilities
-// instead of Gson.
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.TreeMap;
-
-import JAVAPACKAGE.utility.Json;
-import JAVAPACKAGE.utility.struct.Struct;
-
-@SuppressWarnings({"unchecked", "rawtypes"})
-public class StructRunner {
-  public static final String NULLMARK = "__NULL__";
-  public static final String UNDEFMARK = "__UNDEF__";
-  public static final String EXISTSMARK = "__EXISTS__";
-
-  private static volatile Map<String, Object> CORPUS;
-
-  private StructRunner() {}
-
-  public static synchronized Map<String, Object> loadCorpus() {
-    if (CORPUS == null) {
-      try {
-        Path p = Path.of("..", ".sdk", "test", "test.json");
-        String json = Files.readString(p);
-        CORPUS = (Map<String, Object>) Json.parse(json);
-      }
-      catch (Exception e) {
-        throw new AssertionError("Failed to load struct corpus: " + e.getMessage(), e);
-      }
-    }
-    return CORPUS;
-  }
-
-  public static Map<String, Object> getSpec(String category, String name) {
-    Map<String, Object> all = loadCorpus();
-    Map<String, Object> struct = (Map<String, Object>) all.get("struct");
-    if (struct == null) {
-      return null;
-    }
-    Map<String, Object> cat = (Map<String, Object>) struct.get(category);
-    if (cat == null) {
-      return null;
-    }
-    return (Map<String, Object>) cat.get(name);
-  }
-
-  /** Drives a {@code subject} against a test set; collects per-entry pass/fail. */
-  @FunctionalInterface
-  public interface Subject {
-    Object apply(Object in) throws Exception;
-  }
-
-  public static class Result {
-    public final String name;
-    public int passed;
-    public int total;
-    public final List<String> failures = new ArrayList<>();
-
-    public Result(String name) {
-      this.name = name;
-    }
-
-    @Override
-    public String toString() {
-      return name + ": " + passed + "/" + total;
-    }
-  }
-
-  public static Result runset(String fullName, Map<String, Object> testspec, Subject subject) {
-    return runsetflags(fullName, testspec, true, subject);
-  }
-
-  public static Result runsetflags(
-      String fullName, Map<String, Object> testspec, boolean nullFlag, Subject subject) {
-    Result res = new Result(fullName);
-    Object setObj = testspec == null ? null : testspec.get("set");
-    if (!(setObj instanceof List<?> set)) {
-      return res;
-    }
-
-    for (int i = 0; i < set.size(); i++) {
-      Object eo = set.get(i);
-      if (!(eo instanceof Map<?, ?> em)) {
-        continue;
-      }
-      Map<String, Object> entry = (Map<String, Object>) em;
-
-      Object in =
-          entry.containsKey("in")
-              ? Struct.clone(entry.get("in"))
-              : Struct.UNDEF;
-      Object expected =
-          entry.containsKey("out")
-              ? entry.get("out")
-              : (nullFlag ? null : Struct.UNDEF);
-
-      // NULLMARK convention (mirrors js runner fixJSON): when nullFlag is set,
-      // every JSON null in the input and expected output is encoded as the
-      // sentinel string "__NULL__", and the function result is encoded the same
-      // way before comparison. This preserves the null-vs-absent distinction
-      // across the round-trip exactly as the canonical cross-port runner does.
-      if (nullFlag) {
-        // Only encode a *present* input; an absent `in` stays UNDEF so the
-        // subject sees "undefined" (matches the canonical runner, which clones
-        // the absent value rather than a null marker).
-        if (entry.containsKey("in")) {
-          in = fixJSON(in);
-        }
-        expected = fixJSON(expected);
-      }
-
-      res.total++;
-      try {
-        Object got = subject.apply(in);
-        if (nullFlag) {
-          got = fixJSON(got);
-        }
-
-        if (entry.containsKey("err")) {
-          res.failures.add(
-              String.format(
-                  "[%d] expected err='%s' but call returned %s",
-                  i, brief(entry.get("err")), brief(got)));
-          continue;
-        }
-
-        if (deepEqual(got, expected)) {
-          res.passed++;
-        }
-        else {
-          res.failures.add(
-              String.format(
-                  "[%d] in=%s expected=%s got=%s",
-                  i, brief(entry.get("in")), brief(expected), brief(got)));
-        }
-      }
-      catch (Exception ex) {
-        if (entry.containsKey("err")) {
-          // Accept any thrown error when err is true, or substring match otherwise.
-          Object expErr = entry.get("err");
-          String msg = ex.getMessage() == null ? "" : ex.getMessage();
-          if (Boolean.TRUE.equals(expErr)
-              || (expErr instanceof String es
-                  && (es.isEmpty() || msg.contains(es)
-                      || msg.toLowerCase().contains(es.toLowerCase())))) {
-            res.passed++;
-          }
-          else {
-            res.failures.add(
-                String.format(
-                    "[%d] err mismatch: expected '%s' got '%s'", i, brief(expErr), msg));
-          }
-        }
-        else {
-          res.failures.add(
-              String.format(
-                  "[%d] in=%s threw=%s", i, brief(entry.get("in")), ex.getMessage()));
-        }
-      }
-    }
-    return res;
-  }
-
-  /** Normalize then deep-equal. Treats {@link Struct#UNDEF} as {@code null}. */
-  public static boolean deepEqual(Object a, Object b) {
-    return Objects.equals(normalize(a), normalize(b));
-  }
-
-  /**
-   * Encode JSON null (and the {@link Struct#UNDEF} "no value" sentinel) as the
-   * {@link #NULLMARK} string throughout a cloned structure. Mirrors
-   * {@code fixJSON} in js/test/runner.js when {@code flags.null} is true.
-   */
-  public static Object fixJSON(Object v) {
-    if (v == null || v == Struct.UNDEF) {
-      return NULLMARK;
-    }
-    if (v instanceof Map<?, ?> m) {
-      Map<String, Object> out = new LinkedHashMap<>();
-      for (Map.Entry<?, ?> e : m.entrySet()) {
-        out.put(Objects.toString(e.getKey()), fixJSON(e.getValue()));
-      }
-      return out;
-    }
-    if (v instanceof List<?> l) {
-      List<Object> out = new ArrayList<>(l.size());
-      for (Object x : l) {
-        out.add(fixJSON(x));
-      }
-      return out;
-    }
-    return v;
-  }
-
-  /**
-   * Modify callback mirroring {@code nullModifier} in js/test/runner.js: a bare
-   * {@link #NULLMARK} becomes a real null, and an embedded {@link #NULLMARK}
-   * inside a larger string is rewritten to the literal text {@code "null"}.
-   */
-  public static final Struct.Modify NULL_MODIFIER =
-      (val, key, parent, inj, store) -> {
-        if (!(val instanceof String s)) {
-          return;
-        }
-        Object repl;
-        if (NULLMARK.equals(s)) {
-          repl = null;
-        }
-        else if (s.contains(NULLMARK)) {
-          repl = s.replace(NULLMARK, "null");
-        }
-        else {
-          return;
-        }
-        if (parent instanceof Map<?, ?> m) {
-          ((Map<String, Object>) m).put(Objects.toString(key), repl);
-        }
-        else if (parent instanceof List<?> l && key instanceof Number n) {
-          ((List<Object>) l).set(n.intValue(), repl);
-        }
-      };
-
-  /**
-   * Canonicalize a value for comparison:
-   * numbers to Long/Double, maps to sorted TreeMap, lists recurse,
-   * {@link Struct#UNDEF} treated as {@code null}.
-   */
-  public static Object normalize(Object v) {
-    if (v == Struct.UNDEF || v == null) {
-      return null;
-    }
-    if (v instanceof Number n) {
-      double d = n.doubleValue();
-      if (Double.isFinite(d) && Math.floor(d) == d) {
-        return (long) d;
-      }
-      return d;
-    }
-    if (v instanceof Boolean || v instanceof String) {
-      return v;
-    }
-    if (v instanceof Map<?, ?> m) {
-      Map<String, Object> out = new TreeMap<>();
-      for (Map.Entry<?, ?> e : m.entrySet()) {
-        out.put(Objects.toString(e.getKey(), ""), normalize(e.getValue()));
-      }
-      return out;
-    }
-    if (v instanceof List<?> l) {
-      List<Object> out = new ArrayList<>(l.size());
-      for (Object x : l) {
-        out.add(normalize(x));
-      }
-      return out;
-    }
-    return v.toString();
-  }
-
-  private static String brief(Object v) {
-    if (v == Struct.UNDEF) {
-      return UNDEFMARK;
-    }
-    try {
-      String s = Struct.jsonify(v);
-      return s.length() > 200 ? s.substring(0, 197) + "..." : s;
-    }
-    catch (Exception e) {
-      return Objects.toString(v);
-    }
-  }
-}

package/project/.sdk/tm/js/test/runner.js

@@ -1,387 +0,0 @@
-// VERSION: @voxgig/struct 0.0.10
-// This test utility runs the JSON-specified tests in build/test/test.json.
-// (or .sdk/test/test.json if used in a @voxgig/sdkgen project)
-
-const { readFileSync } = require('node:fs')
-const { join } = require('node:path')
-const { deepStrictEqual, fail, AssertionError } = require('node:assert')
-
-const NULLMARK = '__NULL__' // Value is JSON null
-const UNDEFMARK = '__UNDEF__' // Value is not present (thus, undefined).
-const EXISTSMARK = '__EXISTS__' // Value exists (not undefined).
-
-
-async function makeRunner(testfile, client) {
-
-  return async function runner(
-    name,
-    store,
-  ) {
-    store = store || {}
-
-    const utility = client.utility()
-    const structUtils = utility.struct
-
-    let spec = resolveSpec(name, testfile)
-    let clients = await resolveClients(client, spec, store, structUtils)
-    let subject = resolveSubject(name, utility)
-
-    let runsetflags = async (
-      testspec,
-      flags,
-      testsubject
-    ) => {
-      subject = testsubject || subject
-      flags = resolveFlags(flags)
-      const testspecmap = fixJSON(testspec, flags)
-
-      const testset = testspecmap.set
-      for (let entry of testset) {
-        try {
-          entry = resolveEntry(entry, flags)
-
-          let testpack = resolveTestPack(name, entry, subject, client, clients)
-          let args = resolveArgs(entry, testpack, utility, structUtils)
-
-          let res = await testpack.subject(...args)
-          res = fixJSON(res, flags)
-          entry.res = res
-
-          checkResult(entry, args, res, structUtils)
-        }
-        catch (err) {
-          if (err instanceof AssertionError) {
-            throw err
-          }
-          handleError(entry, err, structUtils)
-        }
-      }
-    }
-
-    let runset = async (
-      testspec,
-      testsubject
-    ) => runsetflags(testspec, {}, testsubject)
-
-    const runpack = {
-      spec,
-      runset,
-      runsetflags,
-      subject,
-      client,
-    }
-
-    return runpack
-  }
-}
-
-function resolveSpec(name, testfile) {
-  const alltests =
-    JSON.parse(readFileSync(join(__dirname, testfile), 'utf8'))
-
-  let spec = alltests.primary?.[name] || alltests[name] || alltests
-  return spec
-}
-
-
-async function resolveClients(
-  client,
-  spec,
-  store,
-  structUtils
-) {
-
-  const clients = {}
-  if (spec.DEF && spec.DEF.client) {
-    for (let cn in spec.DEF.client) {
-      const cdef = spec.DEF.client[cn]
-      const copts = cdef.test.options || {}
-      if ('object' === typeof store && structUtils?.inject) {
-        structUtils.inject(copts, store)
-      }
-
-      clients[cn] = await client.tester(copts)
-    }
-  }
-  return clients
-}
-
-
-function resolveSubject(name, container) {
-  const subject = container[name] || container.struct[name]
-  return subject
-}
-
-
-function resolveFlags(flags) {
-  if (null == flags) {
-    flags = {}
-  }
-  flags.null = null == flags.null ? true : !!flags.null
-  return flags
-}
-
-
-function resolveEntry(entry, flags) {
-  entry.out = null == entry.out && flags.null ? NULLMARK : entry.out
-  return entry
-}
-
-
-function checkResult(entry, args, res, structUtils) {
-  let matched = false
-
-  if (entry.err) {
-    return fail('Expected error did not occur: ' + entry.err +
-      '\n\nENTRY: ' + safeStringify(entry))
-  }
-
-  if (entry.match) {
-    const result = { in: entry.in, args, out: entry.res, ctx: entry.ctx }
-    match(
-      entry.match,
-      result,
-      structUtils
-    )
-
-    matched = true
-  }
-
-  const out = entry.out
-
-  if (out === res) {
-    return
-  }
-
-  // NOTE: allow match with no out.
-  if (matched && (NULLMARK === out || null == out)) {
-    return
-  }
-
-  deepStrictEqual(null != res ? JSON.parse(safeStringify(res)) : res, entry.out)
-}
-
-
-// Handle errors from test execution
-function handleError(entry, err, structUtils) {
-  entry.thrown = err
-
-  const entry_err = entry.err
-
-  if (null != entry_err) {
-    if (true === entry_err || matchval(entry_err, err.message, structUtils)) {
-      if (entry.match) {
-        match(
-          entry.match,
-          { in: entry.in, out: entry.res, ctx: entry.ctx, err: fixJSON(err, { null: true }) },
-          structUtils
-        )
-      }
-      return
-    }
-
-    fail('ERROR MATCH: [' + structUtils.stringify(entry_err) +
-      '] <=> [' + err.message + ']')
-  }
-
-  // Unexpected error (test didn't specify an error expectation)
-  else if (err instanceof AssertionError) {
-    fail(err.message + '\n\nENTRY: ' + safeStringify(entry))
-  }
-  else {
-    fail(err.stack + '\n\nENTRY: ' + safeStringify(entry))
-  }
-}
-
-
-function resolveArgs(
-  entry,
-  testpack,
-  utility,
-  structUtils
-) {
-  let args = []
-
-  if (entry.ctx) {
-    args = [entry.ctx]
-  }
-  else if (entry.args) {
-    args = entry.args
-  }
-  else {
-    args = [structUtils.clone(entry.in)]
-  }
-
-  if (entry.ctx || entry.args) {
-    let first = args[0]
-    if (structUtils.ismap(first)) {
-      first = structUtils.clone(first)
-      first = utility.makeContext(first)
-      args[0] = first
-      entry.ctx = first
-
-      first.client = testpack.client
-      first.utility = testpack.utility
-    }
-  }
-
-  return args
-}
-
-
-function resolveTestPack(
-  name,
-  entry,
-  subject,
-  client,
-  clients
-) {
-  const testpack = {
-    name,
-    client,
-    subject,
-    utility: client.utility(),
-  }
-
-  if (entry.client) {
-    testpack.client = clients[entry.client]
-    testpack.utility = testpack.client.utility()
-    testpack.subject = resolveSubject(name, testpack.utility)
-  }
-
-  return testpack
-}
-
-
-function match(
-  check,
-  basex,
-  structUtils
-) {
-  const cbase = structUtils.clone(basex)
-
-  structUtils.walk(check, (_key, val, _parent, path) => {
-    if (!structUtils.isnode(val)) {
-      let baseval = structUtils.getpath(cbase, path)
-
-      if (baseval === val) {
-        return val
-      }
-
-      // Explicit undefined expected
-      if (UNDEFMARK === val && undefined === baseval) {
-        return val
-      }
-
-      // Explicit defined expected
-      if (EXISTSMARK === val && null != baseval) {
-        return val
-      }
-
-      if (!matchval(val, baseval, structUtils)) {
-        fail('MATCH: ' + path.join('.') +
-          ': [' + structUtils.stringify(val) +
-          '] <=> [' + structUtils.stringify(baseval) + ']')
-      }
-    }
-
-    return val
-  })
-}
-
-
-function matchval(
-  check,
-  base,
-  structUtils
-) {
-  let pass = check === base
-
-  if (!pass) {
-
-    if ('string' === typeof check) {
-      let basestr = structUtils.stringify(base)
-
-      let rem = check.match(/^\/(.+)\/$/)
-      if (rem) {
-        pass = new RegExp(rem[1]).test(basestr)
-      }
-      else {
-        pass = basestr.toLowerCase().includes(structUtils.stringify(check).toLowerCase())
-      }
-    }
-    else if ('function' === typeof check) {
-      pass = true
-    }
-  }
-
-  return pass
-}
-
-
-function safeStringify(val) {
-  const seen = new WeakSet()
-  return JSON.stringify(val, (_k, v) => {
-    if ('object' === typeof v && null !== v) {
-      if (seen.has(v)) return '[Circular]'
-      seen.add(v)
-    }
-    if (v instanceof Error) {
-      return { name: v.name, message: v.message }
-    }
-    return v
-  }, 2)
-}
-
-
-function fixJSON(val, flags) {
-  if (null == val) {
-    return flags?.null ? NULLMARK : val
-  }
-
-  const seen = new WeakSet()
-  const replacer = (_k, v) => {
-    if (null == v && flags?.null) {
-      return NULLMARK
-    }
-
-    if (v instanceof Error) {
-      return {
-        ...v,
-        name: v.name,
-        message: v.message,
-      }
-    }
-
-    if ('object' === typeof v && null !== v) {
-      if (seen.has(v)) return '[Circular]'
-      seen.add(v)
-    }
-
-    return v
-  }
-
-  return JSON.parse(JSON.stringify(val, replacer))
-}
-
-
-function nullModifier(
-  val,
-  key,
-  parent
-) {
-  if ("__NULL__" === val) {
-    parent[key] = null
-  }
-  else if ('string' === typeof val) {
-    parent[key] = val.replaceAll('__NULL__', 'null')
-  }
-}
-
-
-module.exports = {
-  NULLMARK,
-  EXISTSMARK,
-  nullModifier,
-  makeRunner,
-}