@voxgig/sdkgen 4.8.2 → 4.9.0

package/project/.sdk/tm/cpp/test/runner_support.hpp

@@ -1,18 +1,25 @@
-// ProjectName SDK — shared test runner support (mirrors java
+// ProjectName SDK — shared test runner SUPPORT (mirrors java
 // test/RunnerSupport.java): env overrides, sdk-test-control.json skips, the
-// ../.sdk/test/test.json loader, and the runset/match engine.
+// ../.sdk/test/test.json loader, and Context construction from a test-entry
+// ctx map.
+//
+// SUPPORT ONLY. The runset/match ENGINE that used to live here (and the
+// whole of the retired test/struct_runner.hpp) was replaced by the vendored
+// @voxgig/omni runner — see test/omni_resolver.hpp, which drives it and
+// calls make_ctx_from_map/fixctx below. The file KEEPS ITS NAME because the
+// generated entity suites (<entity>_direct_test.cpp, <entity>_entity_test.cpp)
+// include it for read_file, load_env_local, env_override,
+// is_control_skipped, entity_list_to_data and now_ms.
 
 #ifndef SDK_TEST_RUNNER_SUPPORT_HPP
 #define SDK_TEST_RUNNER_SUPPORT_HPP
 
 #include <cctype>
 #include <chrono>
-#include <cmath>
 #include <cstdlib>
 #include <fstream>
 #include <functional>
 #include <map>
-#include <regex>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -155,183 +162,6 @@ inline Value get_spec(const Value& spec, std::initializer_list<std::string> keys
   return Helpers::toMapAny(cur);
 }
 
-// ---- normalisation / matching ----------------------------------------
-
-inline Value json_normalize(const Value& v) {
-  // Roundtrip through JSON to drop function values and canonicalise numbers.
-  return vs::parse_json(vs::jsonify(v, 0));
-}
-
-// canon: integer-valued numbers -> int; maps sorted; recursive. Returns a
-// normalised Value used only for deep-equality.
-inline Value canon(const Value& v) {
-  if (v.is_double()) {
-    double d = v.as_double();
-    if (std::isfinite(d) && std::floor(d) == d) return Value((int64_t)d);
-    return v;
-  }
-  if (v.is_list()) {
-    Value out = vlist();
-    for (const auto& e : *v.as_list()) out.as_list()->push_back(canon(e));
-    return out;
-  }
-  if (v.is_map()) {
-    std::vector<std::string> keys = Struct::keysof(v); // sorted
-    Value out = vmap();
-    for (const auto& k : keys) map_put(out, k, canon(getp(v, k)));
-    return out;
-  }
-  return v;
-}
-
-inline bool canon_eq(const Value& a, const Value& b) { return canon(a) == canon(b); }
-
-inline std::string to_lower(std::string s) {
-  for (auto& c : s) c = static_cast<char>(std::tolower((unsigned char)c));
-  return s;
-}
-
-inline bool match_string(const std::string& pattern, const std::string& val) {
-  if (pattern.size() >= 2 && pattern.front() == '/' && pattern.back() == '/') {
-    try {
-      std::regex re(pattern.substr(1, pattern.size() - 2));
-      return std::regex_search(val, re);
-    } catch (...) { return false; }
-  }
-  return to_lower(val).find(to_lower(pattern)) != std::string::npos;
-}
-
-// match_deep: walk `check`; every leaf must equal/match base at that path.
-inline void match_deep(const std::string& where, const Value& check, const Value& base,
-                       const std::string& path) {
-  if (check.is_undef()) return;
-  if (check.is_map()) {
-    for (const auto& kv : *check.as_map()) {
-      Value bv = base.is_map() ? getp(base, kv.first) : Value::undef();
-      match_deep(where, kv.second, bv, path + "." + kv.first);
-    }
-    return;
-  }
-  if (check.is_list()) {
-    auto cl = check.as_list();
-    for (size_t i = 0; i < cl->size(); i++) {
-      Value bv = Value::undef();
-      if (base.is_list() && i < base.as_list()->size()) bv = (*base.as_list())[i];
-      match_deep(where, (*cl)[i], bv, path + "[" + std::to_string(i) + "]");
-    }
-    return;
-  }
-  // leaf
-  if (check.is_string() && check.as_string() == "__EXISTS__") {
-    sdktest::checks()++;
-    if (is_nullish(base)) sdktest::record_fail(where, "match " + path + ": expected value to exist");
-    return;
-  }
-  if (check.is_string() && check.as_string() == "__UNDEF__") {
-    sdktest::checks()++;
-    if (!is_nullish(base)) sdktest::record_fail(where, "match " + path + ": expected undef, got " + vs::jsonify(base, 0));
-    return;
-  }
-  Value nc = json_normalize(check);
-  Value nb = json_normalize(base);
-  sdktest::checks()++;
-  if (!canon_eq(nc, nb)) {
-    if (check.is_string() && !check.as_string().empty() &&
-        match_string(check.as_string(), Struct::stringify(base))) {
-      return;
-    }
-    sdktest::record_fail(where, "match " + path + ": got " + vs::jsonify(nb, 0) + ", want " + vs::jsonify(nc, 0));
-  }
-}
-
-// runset — drive a test.json entry set against a subject (which returns a
-// Value or throws SdkErrorPtr). Records failures via testlib.
-using RunSubject = std::function<Value(const Value& entry)>;
-
-inline void runset(const std::string& label, const Value& testspec, RunSubject subject) {
-  if (!testspec.is_map()) return;
-  Value set = getp(testspec, "set");
-  if (!set.is_list()) return;
-
-  auto entries = set.as_list();
-  for (size_t i = 0; i < entries->size(); i++) {
-    const Value& entry = (*entries)[i];
-    if (!entry.is_map()) continue;
-    std::string where = label + "#" + std::to_string(i);
-
-    Value result = Value::undef();
-    SdkErrorPtr err;
-    std::string errMsg;
-    try {
-      result = subject(entry);
-    } catch (const SdkErrorPtr& e) {
-      err = e;
-      errMsg = e->getMessage();
-    } catch (const std::exception& e) {
-      err = std::make_shared<SdkError>("", e.what(), nullptr);
-      errMsg = e.what();
-    }
-
-    Value expectedErr = getp(entry, "err");
-
-    if (err) {
-      if (!is_nullish(expectedErr)) {
-        sdktest::checks()++;
-        if (expectedErr.is_string() && !match_string(expectedErr.as_string(), errMsg)) {
-          sdktest::record_fail(where, "error mismatch: got \"" + errMsg + "\", want contains \"" + expectedErr.as_string() + "\"");
-        }
-        Value matchSpec = Helpers::toMapAny(getp(entry, "match"));
-        if (matchSpec.is_map()) {
-          Value resultMap = vmap();
-          map_put(resultMap, "in", getp(entry, "in"));
-          map_put(resultMap, "out", json_normalize(result));
-          Value errRec = vmap();
-          map_put(errRec, "message", Value(errMsg));
-          map_put(resultMap, "err", errRec);
-          match_deep(where, matchSpec, resultMap, "");
-        }
-        continue;
-      }
-      sdktest::checks()++;
-      sdktest::record_fail(where, "unexpected error: " + errMsg);
-      continue;
-    }
-
-    if (!is_nullish(expectedErr)) {
-      sdktest::checks()++;
-      sdktest::record_fail(where, "expected error containing \"" + Struct::stringify(expectedErr) + "\" but got " + vs::jsonify(json_normalize(result), 0));
-      continue;
-    }
-
-    bool matched = false;
-    Value matchSpec = Helpers::toMapAny(getp(entry, "match"));
-    if (matchSpec.is_map()) {
-      Value resultMap = vmap();
-      map_put(resultMap, "in", getp(entry, "in"));
-      map_put(resultMap, "out", json_normalize(result));
-      if (!is_nullish(getp(entry, "args"))) {
-        map_put(resultMap, "args", getp(entry, "args"));
-      } else if (!is_nullish(getp(entry, "in"))) {
-        map_put(resultMap, "args", vlist({getp(entry, "in")}));
-      }
-      if (!is_nullish(getp(entry, "ctx"))) map_put(resultMap, "ctx", getp(entry, "ctx"));
-      match_deep(where, matchSpec, resultMap, "");
-      matched = true;
-    }
-
-    Value expectedOut = getp(entry, "out");
-    if (is_nullish(expectedOut) && matched) continue;
-    if (!is_nullish(expectedOut)) {
-      sdktest::checks()++;
-      Value nr = json_normalize(result);
-      Value ne = json_normalize(expectedOut);
-      if (!canon_eq(nr, ne)) {
-        sdktest::record_fail(where, "output mismatch: got " + vs::jsonify(nr, 0) + ", want " + vs::jsonify(ne, 0));
-      }
-    }
-  }
-}
-
 // ---- Context construction from a JSON ctx map ------------------------
 
 struct EntityTestSetup {
@@ -345,6 +175,39 @@ struct EntityTestSetup {
   long long now = 0;
 };
 
+// A minimal Entity for a test-entry ctx map. Context resolves the operation
+// through the Entity INTERFACE — resolveOp keys the config lookup on
+// entity->getName() — and a literal {"name": "planet"} map out of the
+// fixture is not one, so entname would be "" and every op lookup would miss,
+// reporting point_no_points for the whole makePoint group. (java's peer is
+// PrimaryUtilityTest.PlEntity, go's is plEntity. cpp keeps it here rather
+// than at the call site because Context holds a RAW Entity*, so the instance
+// must outlive the Context: named_entity interns one per name for the life
+// of the test binary.)
+class NamedEntity : public Entity {
+public:
+  explicit NamedEntity(std::string name) : name_(std::move(name)) {}
+  std::string getName() override { return name_; }
+  EntityPtr make() override { return std::make_shared<NamedEntity>(name_); }
+  Value data(const Value& arg) override { return Value::undef(); }
+  Value match(const Value& arg) override { return Value::undef(); }
+  void markDeleted() override { deleted_ = true; }
+  bool deleted() override { return deleted_; }
+
+private:
+  std::string name_;
+  bool deleted_ = false;
+};
+
+inline Entity* named_entity(const std::string& name) {
+  static std::map<std::string, std::shared_ptr<NamedEntity>> interned;
+  auto it = interned.find(name);
+  if (it == interned.end()) {
+    it = interned.emplace(name, std::make_shared<NamedEntity>(name)).first;
+  }
+  return it->second.get();
+}
+
 // makeCtxFromMap — build a Context from a test-entry ctx/args map.
 inline CtxPtr make_ctx_from_map(const Value& ctxmap_, std::shared_ptr<ProjectNameSDK> client,
                                 UtilityPtr utility) {
@@ -370,6 +233,30 @@ inline CtxPtr make_ctx_from_map(const Value& ctxmap_, std::shared_ptr<ProjectNam
   Value point = Helpers::toMapAny(getp(ctxmap, "point"));
   if (point.is_map()) cs.point = point;
 
+  // An entry may carry the whole operation lookup — the API config, the SDK
+  // options that gate it, and the entity it hangs off. makePoint's group is
+  // built entirely out of these three (java reads the same keys in its
+  // Context constructor); without them ctx.config falls back to the client's
+  // BAKED-IN config and the group asserts against the wrong endpoints.
+  Value configMap = Helpers::toMapAny(getp(ctxmap, "config"));
+  if (configMap.is_map()) cs.config = configMap;
+  Value optionsMap = Helpers::toMapAny(getp(ctxmap, "options"));
+  if (optionsMap.is_map()) cs.options = optionsMap;
+  Value entityMap = Helpers::toMapAny(getp(ctxmap, "entity"));
+  if (entityMap.is_map()) {
+    Value entname = getp(entityMap, "name");
+    if (entname.is_string()) cs.entity = named_entity(entname.as_string());
+  }
+
+  // EVERY entry gets its OWN op cache. resolveOp memoises on
+  // "<entity>:<opname>", and makePoint drives seven entries that all read
+  // planet:list from a DIFFERENT config — inheriting the client's root opmap
+  // would serve entry one's operation to all seven and the group would pass
+  // while testing one case. (java gets this for free: its makeCtxFromMap
+  // builds `new Context(ctxmap, null)`, so there is no base context to
+  // inherit a cache from.)
+  cs.opmap = std::make_shared<OpMap>();
+
   CtxPtr ctx = utility->makeContext(cs, client ? client->getRootCtx() : nullptr);
 
   if (client && !ctx->options.is_map()) ctx->options = client->optionsMap();

package/project/.sdk/tm/cpp/test/struct_corpus_test.cpp

@@ -1,8 +1,20 @@
 // Voxgig Struct corpus driver — C++ port.
-// Mirrors java/src/test/StructCorpusTest.java.
 //
-// Loads build/test/test.json, drives every (category, name) pair, and prints
-// a per-.jsonic-file scoreboard plus a totals line.
+// Drives the shared struct corpus (../.sdk/test/test.json, root key
+// "struct") against the vendored struct utility THROUGH the VENDORED omni
+// runner (test/omni_resolver.hpp over test/vendor/omni) — the engine half
+// of the retired test/struct_runner.hpp. Mirrors
+// tm/java/test/StructCorpusTest.java.
+//
+// Two behaviour changes came with the swap, both deliberate:
+//
+//  - A missing category, a missing section or an EMPTY set now FAILS. The
+//    retired runner skipped all three silently, so a renamed fixture
+//    reported PASS while running zero assertions.
+//  - omni THROWS on the first bad entry in a group instead of recording
+//    every one, so a group reports its FIRST failure and the scoreboard
+//    below counts the entries that actually ran. Each group is its own
+//    T_RUN-style unit, so one bad group never hides the rest.
 
 #include <cstdio>
 #include <fstream>
@@ -11,21 +23,32 @@
 #include <string>
 #include <vector>
 
-#include "../utility/voxgigstruct/value.hpp"
-#include "../utility/voxgigstruct/value_io.hpp"
-#include "../utility/voxgigstruct/voxgig_struct.hpp"
-#include "struct_runner.hpp"
+#include "omni_resolver.hpp"
+#include "testlib.hpp"
 
 using namespace voxgig::structlib;
-using runner::get_spec;
-using runner::Result;
-using runner::runset;
-using runner::runsetflags;
-using runner::Subject;
+namespace res = sdk::resolver;
 
 namespace {
 
-std::map<std::string, Result> SCOREBOARD;
+// One corpus subject in the shape the groups below are written in: one
+// value in, one value out. `in` is args[0], and because a Value shares its
+// container by shared_ptr, an in-place rewrite by the subject reaches
+// omni's `match: {args: ...}` through the resolver's refill.
+using StructSubject = std::function<Value(const Value&)>;
+
+res::Subject onearg(const StructSubject& subject) {
+  return [subject](std::vector<Value>& args) -> Value {
+    return subject(args.empty() ? Value::undef() : args[0]);
+  };
+}
+
+struct GroupResult {
+  long long cases = 0;
+  bool ok = true;
+};
+
+std::map<std::string, GroupResult> SCOREBOARD;
 
 const std::map<std::string, std::string>& category_to_file() {
   static const std::map<std::string, std::string> M = {
@@ -33,15 +56,78 @@ const std::map<std::string, std::string>& category_to_file() {
       {"merge", "merge.jsonic"},       {"getpath", "getpath.jsonic"},
       {"inject", "inject.jsonic"},     {"transform", "transform.jsonic"},
       {"validate", "validate.jsonic"}, {"select", "select.jsonic"},
+      {"nullsem", "nullsem.jsonic"},
   };
   return M;
 }
 
-void run(const std::string& cat, const std::string& name, bool null_flag, const Subject& s) {
+// One client + one corpus runner for the whole binary.
+res::Run& structRun() {
+  static res::Run run =
+      res::makeRunner("../.sdk/test/test.json", sdk::ProjectNameSDK::testSDK())
+          .runner("struct", Value::undef());
+  return run;
+}
+
+// Resolve one corpus group, failing LOUDLY when it would run zero cases.
+Value group_spec(const std::string& cat, const std::string& name, const std::string& full) {
+  Value category = structRun().set(cat);
+  if (!category.is_map()) {
+    sdktest::record_fail(full, "struct corpus category missing: " + cat +
+                                   " - check .sdk/test/struct/");
+    return Value::undef();
+  }
+  Value spec = sdk::getp(category, Value(name));
+  if (!spec.is_map()) {
+    sdktest::record_fail(full, "struct corpus section missing: " + full +
+                                   " - check .sdk/test/struct/");
+    return Value::undef();
+  }
+  Value set = sdk::getp(spec, Value("set"));
+  if (!set.is_list() || set.as_list()->empty()) {
+    sdktest::record_fail(full, "struct corpus section is EMPTY: " + full +
+                                   " - zero cases would run");
+    return Value::undef();
+  }
+  return spec;
+}
+
+// Run one corpus group. A failing entry throws omni::OmniError naming the
+// entry; it is recorded and the next group still runs.
+void runflags(const std::string& cat, const std::string& name, bool null_flag,
+              const res::Subject& subject) {
   std::string full = cat + "." + name;
-  Value spec = get_spec(cat, name);
-  Result r = runsetflags(full, spec, null_flag, s);
-  SCOREBOARD[full] = r;
+  sdktest::tests()++;
+  sdktest::checks()++;
+
+  GroupResult result;
+  long long before = res::cases();
+
+  Value spec = group_spec(cat, name, full);
+  if (spec.is_map()) {
+    try {
+      structRun().runsetflags(full, spec, null_flag, subject);
+    } catch (const res::OmniError& e) {
+      result.ok = false;
+      sdktest::record_fail(full, e.what());
+    } catch (const sdk::SdkErrorPtr& e) {
+      result.ok = false;
+      sdktest::record_fail(full, std::string("uncaught SdkError: ") + e->getMessage());
+    } catch (const std::exception& e) {
+      result.ok = false;
+      sdktest::record_fail(full, std::string("uncaught exception: ") + e.what());
+    }
+  } else {
+    result.ok = false;
+  }
+
+  result.cases = res::cases() - before;
+  SCOREBOARD[full] = result;
+}
+
+void run(const std::string& cat, const std::string& name, bool null_flag,
+         const StructSubject& subject) {
+  runflags(cat, name, null_flag, onearg(subject));
 }
 
 // Extract a named field from a test-spec object. This mirrors the canonical
@@ -56,6 +142,29 @@ inline Value getpDef(const Value& in, const std::string& k, const Value& def) {
   return lookup_v(in, Value(k)).is_undef() ? def : lookup_v(in, Value(k));
 }
 
+// The struct-corpus nullModifier (was struct_runner.hpp's null_modifier): a
+// bare "__NULL__" becomes a real null, and an embedded "__NULL__" inside a
+// larger string is rewritten to the literal text "null".
+void null_modifier(const Value& val, const Value& key, const Value& parent, Injection&,
+                   const Value&) {
+  if (!val.is_string())
+    return;
+  const std::string& s = val.as_string();
+  if (s == res::NULLMARK) {
+    setprop(parent, key, Value(nullptr));
+    return;
+  }
+  if (s.find(res::NULLMARK) != std::string::npos) {
+    std::string out = s;
+    std::string::size_type pos = 0;
+    while ((pos = out.find(res::NULLMARK, pos)) != std::string::npos) {
+      out.replace(pos, res::NULLMARK.size(), "null");
+      pos += 4;
+    }
+    setprop(parent, key, Value(out));
+  }
+}
+
 } // namespace
 
 int main() {
@@ -103,7 +212,7 @@ int main() {
     Value val = getpDef(in, "val", Value::undef());
     // Canonical subject: a stored-null (the NULLMARK in null mode) stringifies
     // as the literal text "null".
-    if (val.is_string() && val.as_string() == runner::NULLMARK())
+    if (val.is_string() && val.as_string() == res::NULLMARK)
       val = Value("null");
     Value max = getp(in, "max");
     int m = max.is_int() ? static_cast<int>(max.as_int()) : -1;
@@ -119,7 +228,7 @@ int main() {
     // path *element* (the marker) is stripped from the rendered string; and a
     // wholly-null path renders "<unknown-path:null>".
     Value path = getpDef(in, "path", Value::undef());
-    bool path_was_null = path.is_string() && path.as_string() == runner::NULLMARK();
+    bool path_was_null = path.is_string() && path.as_string() == res::NULLMARK;
     if (path_was_null)
       path = Value::undef();
     Value from = getp(in, "from");
@@ -336,7 +445,7 @@ int main() {
     // Canonical subject passes { modify: nullModifier }: an injected stored-null
     // (the marker, in null mode) renders as the literal text "null".
     Injection inj(Value::undef(), Value::undef());
-    inj.modify = runner::null_modifier;
+    inj.modify = null_modifier;
     return inject(getp(in, "val"), getp(in, "store"), &inj);
   });
   run("inject", "deep", true,
@@ -427,49 +536,64 @@ int main() {
     return Value(out);
   });
 
-  // Aggregate per-file scoreboard.
-  std::map<std::string, std::pair<int, int>> by_file;
+  // ===== nullsem =====
+  // Does a PRESENT key holding a JSON null read as "no value"? Every lane
+  // runs {null: false}: with the flag on, the runner rewrites every null to
+  // "__NULL__" and the section asserts nothing about null at all.
+  run("nullsem", "getprop", false, [](const Value& in) {
+    Value alt = getpDef(in, "alt", Value::undef());
+    return alt.is_undef() ? getprop(getp(in, "val"), getp(in, "key"))
+                          : getprop(getp(in, "val"), getp(in, "key"), alt);
+  });
+  run("nullsem", "getelem", false, [](const Value& in) {
+    Value alt = getpDef(in, "alt", Value::undef());
+    return alt.is_undef() ? getelem(getp(in, "val"), getp(in, "key"))
+                          : getelem(getp(in, "val"), getp(in, "key"), alt);
+  });
+  run("nullsem", "getpath", false,
+      [](const Value& in) { return getpath_v(getp(in, "store"), getp(in, "path")); });
+  run("nullsem", "haskey", false,
+      [](const Value& in) { return Value(haskey(getp(in, "src"), getp(in, "key"))); });
+  run("nullsem", "keysof", false, [](const Value& in) {
+    auto out = std::make_shared<List>();
+    for (const auto& k : keysof(in))
+      out->push_back(Value(k));
+    return Value(out);
+  });
+
+  // ===== scoreboard =====
+  // Per-.jsonic-file case counts. `cases` is what the vendored runner
+  // actually DROVE: a group that throws stops at its first bad entry, so a
+  // count below the fixture's set size is itself a failure signal.
+  std::map<std::string, std::pair<long long, int>> by_file; // cases, failed groups
   std::map<std::string, std::vector<std::pair<std::string, std::string>>> details;
-  int totalP = 0, totalT = 0;
+  long long total_cases = 0;
+  int failed_groups = 0;
+
   for (const auto& [key, r] : SCOREBOARD) {
     std::string cat = key.substr(0, key.find('.'));
     auto it = category_to_file().find(cat);
     std::string file = it == category_to_file().end() ? cat + ".jsonic" : it->second;
-    by_file[file].first += r.passed;
-    by_file[file].second += r.total;
-    details[file].push_back({key, std::to_string(r.passed) + "/" + std::to_string(r.total)});
-    totalP += r.passed;
-    totalT += r.total;
+    by_file[file].first += r.cases;
+    by_file[file].second += r.ok ? 0 : 1;
+    details[file].push_back({key, std::to_string(r.cases) + (r.ok ? "" : " FAILED")});
+    total_cases += r.cases;
+    if (!r.ok)
+      failed_groups++;
   }
 
   std::cout << "\n========= STRUCT CORPUS SCOREBOARD =========\n";
   for (const auto& [file, pt] : by_file) {
-    std::printf("  %-18s %4d / %4d\n", file.c_str(), pt.first, pt.second);
+    std::printf("  %-18s %5lld cases%s\n", file.c_str(), pt.first,
+                pt.second > 0 ? "  (FAILURES)" : "");
     for (const auto& [name, tally] : details[file]) {
       std::printf("      %-30s %s\n", name.c_str(), tally.c_str());
     }
   }
-  std::printf("  %-18s %4d / %4d\n", "TOTAL", totalP, totalT);
+  std::printf("  %-18s %5lld cases, %d group(s) failed\n", "TOTAL", total_cases, failed_groups);
   std::cout << "============================================\n";
 
-  // Optionally print failure details when CORPUS_VERBOSE is set.
-  if (const char* v = std::getenv("CORPUS_VERBOSE"); v && std::string(v) != "0") {
-    for (const auto& [name, r] : SCOREBOARD) {
-      if (r.failures.empty())
-        continue;
-      std::cerr << "\n--- " << name << " (" << r.passed << "/" << r.total << ") ---\n";
-      int shown = 0;
-      for (const auto& f : r.failures) {
-        std::cerr << "  " << f << "\n";
-        if (++shown >= 5) {
-          std::cerr << "  ... " << (r.failures.size() - shown) << " more\n";
-          break;
-        }
-      }
-    }
-  }
-
-  // Write target/corpus-scoreboard.json
+  // Write corpus-scoreboard.json beside the binary's working directory.
   std::ofstream out("corpus-scoreboard.json");
   if (out) {
     out << "{\n  \"files\": {\n";
@@ -478,17 +602,20 @@ int main() {
       if (!first)
         out << ",\n";
       first = false;
-      out << "    \"" << file << "\": {\"passed\": " << pt.first << ", \"total\": " << pt.second
+      out << "    \"" << file << "\": {\"cases\": " << pt.first << ", \"failed\": " << pt.second
           << "}";
     }
-    out << "\n  },\n  \"total\": {\"passed\": " << totalP << ", \"total\": " << totalT << "}\n}\n";
+    out << "\n  },\n  \"total\": {\"cases\": " << total_cases << ", \"failed\": " << failed_groups
+        << "}\n}\n";
   }
 
-  // Green-bar: any failing corpus entry fails the test binary.
-  if (totalP != totalT) {
-    std::cerr << "struct corpus: " << (totalT - totalP) << " FAILED of " << totalT << "\n";
-    return 1;
+  if (failed_groups > 0) {
+    std::cerr << "struct corpus: " << failed_groups << " group(s) FAILED of " << SCOREBOARD.size()
+              << "\n";
+  } else {
+    std::cout << "struct corpus: " << total_cases << " cases PASSED across " << SCOREBOARD.size()
+              << " groups\n";
   }
-  std::cout << "struct corpus: " << totalP << "/" << totalT << " PASSED\n";
-  return 0;
+
+  return sdktest::summary("struct_corpus_test");
 }