@voxgig/sdkgen 4.8.2 → 4.8.3

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

@@ -1,8 +1,14 @@
 package JAVAPACKAGE.sdktest;
 
-// Shared test-runner support: env overrides, sdk-test-control.json skips,
-// the ../.sdk/test/test.json spec loader, and the runset/match engine whose
-// matching logic mirrors js/test/runner.js (and the go runner_test.go).
+// Shared test-runner SUPPORT (vendor-tag rollout): env overrides, the
+// sdk-test-control.json skip machinery, live pacing, the
+// ../.sdk/test/test.json spec loader, ctx/entity conversion helpers, and
+// the canon/jsonStr comparison helpers the feature tests use. The corpus
+// ENGINE that used to live beside them (runset/matchDeep/matchString) is
+// retired: both corpora now run on the vendored omni runner through
+// OmniResolver.java. The class name is unchanged so the emitted
+// TestEntity/TestDirect call sites (RunnerSupport.skipReason,
+// RunnerSupport.envOverride, ...) need no churn.
 
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -13,7 +19,6 @@ import java.util.Map;
 import java.util.Objects;
 import java.util.TreeMap;
 import java.util.function.Supplier;
-import java.util.regex.Pattern;
 
 import JAVAPACKAGE.core.Context;
 import JAVAPACKAGE.core.Entity;
@@ -260,123 +265,6 @@ public final class RunnerSupport {
     return Helpers.toMapAny(cur);
   }
 
-  @FunctionalInterface
-  public interface RunSubject {
-    Object run(Map<String, Object> entry) throws Exception;
-  }
-
-  // runset drives a test.json entry set against a subject, mirroring the
-  // matching semantics of the go/js runners. All entry failures are
-  // reported together as one AssertionError.
-  public static void runset(Map<String, Object> testspec, RunSubject subject) {
-    if (testspec == null || !(testspec.get("set") instanceof List)) {
-      return;
-    }
-    List<Object> set = (List<Object>) testspec.get("set");
-
-    List<String> failures = new ArrayList<>();
-
-    for (int i = 0; i < set.size(); i++) {
-      Map<String, Object> entry = Helpers.toMapAny(set.get(i));
-      if (entry == null) {
-        continue;
-      }
-
-      String mark = entry.get("mark") == null ? "" : " (mark=" + entry.get("mark") + ")";
-
-      Object result = null;
-      Exception err = null;
-      try {
-        result = subject.run(entry);
-      }
-      catch (Exception e) {
-        err = e;
-      }
-
-      Object expectedErr = entry.get("err");
-
-      if (err != null) {
-        if (expectedErr != null) {
-          String errMsg = err.getMessage() == null ? String.valueOf(err) : err.getMessage();
-          if (expectedErr instanceof String
-              && !matchString((String) expectedErr, errMsg)) {
-            failures.add("entry " + i + mark + ": error mismatch: got \"" + errMsg
-                + "\", want contains \"" + expectedErr + "\"");
-          }
-          Map<String, Object> matchSpec = Helpers.toMapAny(entry.get("match"));
-          if (matchSpec != null) {
-            Map<String, Object> resultMap = new LinkedHashMap<>();
-            resultMap.put("in", entry.get("in"));
-            resultMap.put("out", jsonNormalize(result));
-            Map<String, Object> errRec = new LinkedHashMap<>();
-            errRec.put("message", errMsg);
-            resultMap.put("err", errRec);
-            matchDeep(failures, i, mark, matchSpec, resultMap, "");
-          }
-          continue;
-        }
-        failures.add("entry " + i + mark + ": unexpected error: " + err);
-        continue;
-      }
-
-      if (expectedErr != null) {
-        failures.add("entry " + i + mark + ": expected error containing \""
-            + expectedErr + "\" but got result: " + jsonStr(result));
-        continue;
-      }
-
-      boolean matched = false;
-      Map<String, Object> matchSpec = Helpers.toMapAny(entry.get("match"));
-      if (matchSpec != null) {
-        Map<String, Object> resultMap = new LinkedHashMap<>();
-        resultMap.put("in", entry.get("in"));
-        resultMap.put("out", jsonNormalize(result));
-        if (entry.get("args") != null) {
-          resultMap.put("args", entry.get("args"));
-        }
-        else if (entry.get("in") != null) {
-          List<Object> args = new ArrayList<>();
-          args.add(entry.get("in"));
-          resultMap.put("args", args);
-        }
-        if (entry.get("ctx") != null) {
-          resultMap.put("ctx", entry.get("ctx"));
-        }
-        matchDeep(failures, i, mark, matchSpec, resultMap, "");
-        matched = true;
-      }
-
-      Object expectedOut = entry.get("out");
-      if (expectedOut == null && matched) {
-        continue;
-      }
-      if (expectedOut != null) {
-        Object normResult = jsonNormalize(result);
-        Object normExpected = jsonNormalize(expectedOut);
-        if (!Objects.equals(canon(normResult), canon(normExpected))) {
-          failures.add("entry " + i + mark + ": output mismatch:\n  got:  "
-              + jsonStr(normResult) + "\n  want: " + jsonStr(normExpected));
-        }
-      }
-    }
-
-    if (!failures.isEmpty()) {
-      throw new AssertionError(String.join("\n", failures));
-    }
-  }
-
-  public static Object jsonNormalize(Object val) {
-    if (val == null) {
-      return null;
-    }
-    try {
-      return Json.parse(Struct.jsonify(val));
-    }
-    catch (RuntimeException e) {
-      return val;
-    }
-  }
-
   public static String jsonStr(Object val) {
     try {
       return Struct.jsonify(val);
@@ -419,79 +307,6 @@ public final class RunnerSupport {
     return String.valueOf(v);
   }
 
-  static void matchDeep(List<String> failures, int entryIdx, String mark,
-      Object check, Object base, String path) {
-
-    if (check == null) {
-      return;
-    }
-
-    if (check instanceof Map) {
-      for (Map.Entry<String, Object> e : ((Map<String, Object>) check).entrySet()) {
-        String childPath = path + "." + e.getKey();
-        Object baseVal = base instanceof Map
-            ? ((Map<String, Object>) base).get(e.getKey()) : null;
-        matchDeep(failures, entryIdx, mark, e.getValue(), baseVal, childPath);
-      }
-    }
-    else if (check instanceof List) {
-      List<Object> checkList = (List<Object>) check;
-      for (int i = 0; i < checkList.size(); i++) {
-        String childPath = path + "[" + i + "]";
-        Object baseVal = null;
-        if (base instanceof List && i < ((List<Object>) base).size()) {
-          baseVal = ((List<Object>) base).get(i);
-        }
-        matchDeep(failures, entryIdx, mark, checkList.get(i), baseVal, childPath);
-      }
-    }
-    else {
-      if ("__EXISTS__".equals(check)) {
-        if (base == null) {
-          failures.add("entry " + entryIdx + mark + ": match " + path
-              + ": expected value to exist but got null");
-        }
-        return;
-      }
-      if ("__UNDEF__".equals(check)) {
-        if (base != null) {
-          failures.add("entry " + entryIdx + mark + ": match " + path
-              + ": expected null but got " + base);
-        }
-        return;
-      }
-
-      Object normCheck = jsonNormalize(check);
-      Object normBase = jsonNormalize(base);
-
-      if (!Objects.equals(canon(normCheck), canon(normBase))) {
-        if (check instanceof String && !"".equals(check)) {
-          String baseStr = Struct.stringify(base);
-          if (matchString((String) check, baseStr)) {
-            return;
-          }
-        }
-        failures.add("entry " + entryIdx + mark + ": match " + path + ": got "
-            + jsonStr(normBase) + ", want " + jsonStr(normCheck));
-      }
-    }
-  }
-
-  // matchString checks if val matches pattern. If pattern is /regex/, use
-  // regex; otherwise do case-insensitive contains.
-  public static boolean matchString(String pattern, String val) {
-    if (pattern.length() >= 2 && pattern.startsWith("/") && pattern.endsWith("/")) {
-      try {
-        return Pattern.compile(pattern.substring(1, pattern.length() - 1))
-            .matcher(val).find();
-      }
-      catch (RuntimeException e) {
-        return false;
-      }
-    }
-    return val.toLowerCase().contains(pattern.toLowerCase());
-  }
-
   // makeCtxFromMap creates a Context from a JSON test entry's ctx or args map.
   public static Context makeCtxFromMap(Map<String, Object> ctxmap,
       ProjectNameSDK client, Utility utility) {

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

@@ -1,14 +1,19 @@
 package JAVAPACKAGE.sdktest;
 
-// Drives the shared struct corpus (../.sdk/test/test.json, root key "struct")
-// against the vendored struct utility, mirroring the go target's
-// struct_utility_test.go coverage. Adapted from the voxgig struct java
-// port's StructCorpusTest; here the corpus is a green-bar test — any
-// failing entry fails the build. Categories absent from this SDK's
-// test.json are skipped.
+// Drives the shared struct corpus (../.sdk/test/test.json, root key
+// "struct") against the vendored struct utility THROUGH the vendored omni
+// runner (OmniResolver over test/vendor/omni) - the engine half of the
+// retired StructRunner. Mirrors the go target's struct_utility_test.go
+// coverage. A missing category or section FAILS (the old runner skipped it
+// silently - a renamed fixture reported PASS while running zero
+// assertions); a failing entry throws OmniError with the entry named.
 
-import org.junit.jupiter.api.AfterAll;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.DynamicTest;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestFactory;
 
 import java.util.ArrayList;
@@ -17,15 +22,34 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
-import java.util.TreeMap;
 import java.util.function.Function;
 
+import JAVAPACKAGE.core.Helpers;
+import JAVAPACKAGE.core.ProjectNameSDK;
 import JAVAPACKAGE.utility.struct.Struct;
 
 @SuppressWarnings({"unchecked", "rawtypes"})
 public class StructCorpusTest {
 
-  private static final Map<String, StructRunner.Result> SCOREBOARD = new TreeMap<>();
+  static final String TEST_JSON_FILE = "../.sdk/test/test.json";
+
+  private static OmniResolver.Run RUN;
+
+  static synchronized OmniResolver.Run structRun() {
+    if (RUN == null) {
+      RUN = OmniResolver
+          .makeRunner(TEST_JSON_FILE, ProjectNameSDK.testSDK())
+          .runner("struct", new LinkedHashMap<String, Object>());
+      assertNotNull(RUN.spec, "struct section not found in test.json");
+    }
+    return RUN;
+  }
+
+  /** A subject in the struct-corpus shape: one argument in, one value out. */
+  @FunctionalInterface
+  interface StructSubject {
+    Object apply(Object in) throws Exception;
+  }
 
   private static Object getp(Object in, String key) {
     if (in instanceof Map<?, ?> m) {
@@ -41,6 +65,33 @@ public class StructCorpusTest {
     return def;
   }
 
+  // The struct-corpus nullModifier (was StructRunner.NULL_MODIFIER): a bare
+  // "__NULL__" becomes a real null, and an embedded "__NULL__" inside a
+  // larger string is rewritten to the literal text "null". Mirrors omni's
+  // nullmodifier for struct's own Modify callback shape.
+  static final Struct.Modify NULL_MODIFIER =
+      (val, key, parent, inj, store) -> {
+        if (!(val instanceof String s)) {
+          return;
+        }
+        Object repl;
+        if (OmniResolver.NULLMARK.equals(s)) {
+          repl = null;
+        }
+        else if (s.contains(OmniResolver.NULLMARK)) {
+          repl = s.replace(OmniResolver.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);
+        }
+      };
+
   @TestFactory
   Iterable<DynamicTest> corpus() {
     List<DynamicTest> tests = new ArrayList<>();
@@ -242,10 +293,10 @@ public class StructCorpusTest {
 
     // ===== inject =====
     // inject.string passes the nullModifier so a resolved JSON null (encoded by
-    // the runner's fixJSON as "__NULL__") renders as the literal text "null".
+    // the runner as "__NULL__") renders as the literal text "null".
     add(tests, "inject", "string", true, in -> {
       Map<String, Object> opts = new LinkedHashMap<>();
-      opts.put("modify", StructRunner.NULL_MODIFIER);
+      opts.put("modify", NULL_MODIFIER);
       return Struct.inject(getp(in, "val"), getp(in, "store"), opts);
     });
     add(tests, "inject", "deep", true, in -> Struct.inject(getp(in, "val"), getp(in, "store")));
@@ -306,46 +357,72 @@ public class StructCorpusTest {
     return tests;
   }
 
+  // The struct.nullsem section: does a PRESENT key holding a JSON null
+  // read as "no value"? Opt-in per target (create-sdkgen ships it; an
+  // older project corpus may predate it - the abort below says so OUT
+  // LOUD, as a skipped test, rather than passing vacuously). All lanes
+  // run {null: false}: without the flag the runner rewrites every null to
+  // '__NULL__' and the section asserts nothing about null at all.
+  @Test
+  public void nullsem() {
+    OmniResolver.Run run = structRun();
+    Map<String, Object> nullsem = Helpers.toMapAny(run.spec.get("nullsem"));
+    if (nullsem == null) {
+      Assumptions.abort(
+          "corpus predates struct.nullsem - refresh .sdk/test/struct from create-sdkgen");
+    }
+    Map<String, Object> flags = OmniResolver.flags("null", false);
+
+    run.runsetflags(nullsem.get("getprop"), flags, (args) -> {
+      Object in = args[0];
+      Object alt = getpDef(in, "alt", Struct.UNDEF);
+      return alt == Struct.UNDEF
+          ? Struct.getprop(getp(in, "val"), getp(in, "key"))
+          : Struct.getprop(getp(in, "val"), getp(in, "key"), alt);
+    });
+
+    run.runsetflags(nullsem.get("getelem"), flags, (args) -> {
+      Object in = args[0];
+      Object alt = getpDef(in, "alt", Struct.UNDEF);
+      return alt == Struct.UNDEF
+          ? Struct.getelem(getp(in, "val"), getp(in, "key"))
+          : Struct.getelem(getp(in, "val"), getp(in, "key"), alt);
+    });
+
+    run.runsetflags(nullsem.get("getpath"), flags, (args) ->
+        Struct.getpath(getp(args[0], "store"), getp(args[0], "path")));
+
+    run.runsetflags(nullsem.get("haskey"), flags, (args) ->
+        Struct.haskey(getp(args[0], "src"), getp(args[0], "key")));
+
+    run.runsetflags(nullsem.get("keysof"), flags, (args) ->
+        Struct.keysof(args[0]));
+  }
+
   private void add(
       List<DynamicTest> tests,
       String category,
       String name,
       boolean nullFlag,
-      StructRunner.Subject subject) {
+      StructSubject subject) {
     tests.add(
         DynamicTest.dynamicTest(
             category + "-" + name,
             () -> {
-              Map<String, Object> spec = StructRunner.getSpec(category, name);
-              if (spec == null) {
-                // Category/name absent from this SDK's corpus: skip.
-                return;
-              }
-              StructRunner.Result r =
-                  StructRunner.runsetflags(category + "." + name, spec, nullFlag, subject);
-              SCOREBOARD.put(category + "." + name, r);
-              if (!r.failures.isEmpty()) {
-                throw new AssertionError(
-                    category + "." + name + ": " + r.passed + "/" + r.total
-                        + " passed; failures:\n  " + String.join("\n  ", r.failures));
-              }
+              OmniResolver.Run run = structRun();
+              Map<String, Object> cat = Helpers.toMapAny(run.spec.get(category));
+              assertNotNull(cat, "struct corpus category missing: " + category
+                  + " - check .sdk/test/struct/");
+              Map<String, Object> spec = Helpers.toMapAny(cat.get(name));
+              assertNotNull(spec, "struct corpus section missing: "
+                  + category + "." + name + " - check .sdk/test/struct/");
+              Object set = spec.get("set");
+              assertTrue(set instanceof List && !((List<Object>) set).isEmpty(),
+                  "struct corpus section is EMPTY: " + category + "." + name
+                      + " - zero cases would run");
+              run.runsetflags(spec, OmniResolver.flags("null", nullFlag),
+                  (args) -> subject.apply(
+                      0 < args.length ? args[0] : Struct.UNDEF));
             }));
   }
-
-  @AfterAll
-  static void printScoreboard() {
-    int totalP = 0;
-    int totalT = 0;
-    StringBuilder banner = new StringBuilder();
-    banner.append("\n========= STRUCT CORPUS SCOREBOARD =========\n");
-    for (Map.Entry<String, StructRunner.Result> e : SCOREBOARD.entrySet()) {
-      StructRunner.Result r = e.getValue();
-      banner.append(String.format("  %-30s %4d / %4d%n", e.getKey(), r.passed, r.total));
-      totalP += r.passed;
-      totalT += r.total;
-    }
-    banner.append(String.format("  %-30s %4d / %4d%n", "TOTAL", totalP, totalT));
-    banner.append("============================================\n");
-    System.out.println(banner);
-  }
 }