@voxgig/sdkgen 4.8.2 → 4.9.0

package/project/.sdk/tm/clojure/test/sdk/test/primary.clj

@@ -4,7 +4,7 @@
   (:require [sdk.core :as core]
             [sdk.client :as client]
             [sdk.testutil :as t]
-            [sdk.test.struct-corpus :as corpus]
+            [sdk.test.omni :as omni]
             [voxgig.struct :as vs]
             [clojure.string :as str])
   (:import [java.util Map]))
@@ -19,9 +19,6 @@
 
 (def ^:private CORPUS "../.sdk/test/test.json")
 
-(defn- getspec [root & path]
-  (reduce (fn [acc k] (when acc (.get ^Map acc k))) root path))
-
 (defn- lower-headers [m]
   ;; Header names arrive in any case and the contract is lowercase; the SDK
   ;; copies them verbatim, so the driver normalises, as the lua reference does.
@@ -143,16 +140,24 @@
                  (t/is-true (str/includes? (str (vs/getprop fetchdef "url")) "/api/items/item01") "url includes")))))
     nil))
 
-
 (defn run-corpus
-  "Drive every primary section of the shared corpus through this SDK."
+  "Drive every primary section of the shared corpus through this SDK.
+
+   The engine is the VENDORED omni runner (sdk.test.omni), not a hand-written
+   entry loop: each section names its corpus node and the subject that drives
+   it, and omni decides whether the result, the match and the error
+   expectations hold. omni raises on the first failing entry of a set, so a
+   green section counts its whole set - counted at the SUBJECT, from
+   sdk.test.omni's execution counter, and failed when it disagrees with the
+   set handed over, so the number cannot survive a stopped engine."
   [rec]
-  (let [sdk (client/test-sdk nil nil)
+  (let [alltests (omni/load-spec CORPUS)
+        primary (get alltests "primary")
+        sdk (client/test-sdk nil nil)
+        mkrunner (omni/make-runner alltests sdk)
         utility (core/get-utility sdk)
         u (fn [k] (get (deref utility) k))
-        alltests (core/json-parse (slurp CORPUS))
-        primary (.get ^Map alltests "primary")
-        setup-of (fn [nm] (getspec primary nm "DEF" "setup" "a"))
+        setup-of (fn [nm] (omni/->struct (get-in primary [nm "DEF" "setup" "a"])))
         client-for (fn [nm] (let [su (setup-of nm)]
                               (if (vs/ismap su) (client/test-sdk nil su) sdk)))
         ;; make-spec and prepare-auth read defaults off the CLIENT, as the ts
@@ -161,62 +166,91 @@
         spec-sdk (client-for "makeSpec")
         auth-sdk (client-for "prepareAuth")
         ran (atom 0)
+        npass (atom 0)
+        fails (atom [])
         ;; One section, driven with a ctx built from the corpus entry.
         runset (fn [nm cl f]
-              (let [node (getspec primary nm "basic")]
-                (when (nil? node)
-                  (throw (ex-info (str "corpus section missing: " nm) {})))
-                (swap! ran inc)
-                ;; run-set APPLIES the resolved args, so an args-style entry
-                ;; calls the subject with more than one — variadic, and the
-                ;; extra arg reaches the section through `more`.
-                (corpus/run-set nm node
-                  (fn [& as]
-                    (let [ctxmap (first as)
-                          more (second as)
-                          ctx (corpus-ctx cl (core/get-utility cl) ctxmap)
-                          out (f ctx ctxmap more)]
-                      (publish-ctx ctxmap ctx)
-                      out)))))
+                 (let [node (get-in primary [nm "basic"])]
+                   (when (nil? node)
+                     (throw (ex-info (str "corpus section missing: " nm) {})))
+                   (swap! ran inc)
+                   (let [rp (mkrunner nm)
+                         testset (get node "set")
+                         n (count testset)]
+                     ;; A section whose `set` is present but empty runs nothing
+                     ;; and raises nothing - no passes, and green. omni refuses
+                     ;; that under a versioned spec (`checkset`, with an
+                     ;; `empty: true` opt-out); the shared corpus is lenient v0,
+                     ;; so it is refused here. A section with no `set` at all is
+                     ;; left to omni, whose message for it is the better one.
+                     (if (and (sequential? testset) (zero? n)
+                              (not (true? (get node "empty"))))
+                       (swap! fails conj [nm "corpus section has an empty set"])
+                       (try
+                       ;; omni APPLIES the resolved args, so an args-style entry
+                       ;; calls the subject with more than one - variadic, and the
+                       ;; extra arg reaches the section through `more`.
+                       ;;
+                         ;; `executed` is the engine's own count for this set
+                         ;; (sdk.test.omni counts inside the subject wrapper),
+                         ;; NOT the section's declared size: a number derived
+                         ;; from the spec prints the same whether the engine ran
+                         ;; or was never called, so it could never show a
+                         ;; stoppage.
+                         (let [executed (long (or ((:runsetflags rp) node {:name nm}
+                                                   (fn [& as]
+                                                     (let [ctxmap (first as)
+                                                           more (second as)
+                                                           ctx (corpus-ctx cl (core/get-utility cl) ctxmap)
+                                                           out (f ctx ctxmap more)]
+                                                       ;; ctxmap is the LIVE map behind omni's
+                                                       ;; ctx view, so this write is what
+                                                       ;; `match: {ctx: ...}` reads.
+                                                       (publish-ctx ctxmap ctx)
+                                                       out)))
+                                                  0))]
+                           (if (not= executed n)
+                             (swap! fails conj
+                                    [nm (str "the engine ran " executed " of the section's "
+                                             n " entries")])
+                             (swap! npass + executed)))
+                         (catch Throwable err
+                           (swap! fails conj [nm (or (ex-message err) (str err))])))))))
         argof (fn [ctxmap k] (vs/getprop ctxmap k))]
 
     (t/run-check rec "primary-corpus"
       (fn []
-        (binding [corpus/*results* (atom {:pass [] :fail []})]
-          (runset "done" sdk              (fn [c _ _2] ((u :done) c)))
-          (runset "makeUrl" sdk           (fn [c _ _2] (first ((u :make-url) c))))
-          (runset "makeRequest" sdk       (fn [c _ _2] (first ((u :make-request) c))))
-          (runset "makeResponse" sdk      (fn [c _ _2] (first ((u :make-response) c))))
-          (runset "makeSpec" spec-sdk     (fn [c _ _2] (first ((u :make-spec) c))))
-          (runset "prepareAuth" auth-sdk  (fn [c _ _2] (first ((u :prepare-auth) c))))
-          (runset "prepareBody" sdk       (fn [c _ _2] ((u :prepare-body) c)))
-          (runset "prepareHeaders" sdk    (fn [c _ _2] ((u :prepare-headers) c)))
-          (runset "prepareMethod" sdk     (fn [c _ _2] ((u :prepare-method) c)))
-          (runset "prepareParams" sdk     (fn [c _ _2] ((u :prepare-params) c)))
-          (runset "preparePath" sdk       (fn [c _ _2] ((u :prepare-path) c)))
-          (runset "prepareQuery" sdk      (fn [c _ _2] ((u :prepare-query) c)))
-          (runset "resultBasic" sdk       (fn [c _ _2] (neutral ((u :result-basic) c))))
-          (runset "resultBody" sdk        (fn [c _ _2] (neutral ((u :result-body) c))))
-          (runset "resultHeaders" sdk     (fn [c _ _2] (neutral ((u :result-headers) c))))
-          (runset "transformRequest" sdk  (fn [c _ _2] ((u :transform-request) c)))
-          (runset "transformResponse" sdk (fn [c _ _2] ((u :transform-response) c)))
-          (runset "makeOptions" sdk       (fn [c m _2]
+        (runset "done" sdk              (fn [c _ _2] ((u :done) c)))
+        (runset "makeUrl" sdk           (fn [c _ _2] (first ((u :make-url) c))))
+        (runset "makeRequest" sdk       (fn [c _ _2] (first ((u :make-request) c))))
+        (runset "makeResponse" sdk      (fn [c _ _2] (first ((u :make-response) c))))
+        (runset "makeSpec" spec-sdk     (fn [c _ _2] (first ((u :make-spec) c))))
+        (runset "prepareAuth" auth-sdk  (fn [c _ _2] (first ((u :prepare-auth) c))))
+        (runset "prepareBody" sdk       (fn [c _ _2] ((u :prepare-body) c)))
+        (runset "prepareHeaders" sdk    (fn [c _ _2] ((u :prepare-headers) c)))
+        (runset "prepareMethod" sdk     (fn [c _ _2] ((u :prepare-method) c)))
+        (runset "prepareParams" sdk     (fn [c _ _2] ((u :prepare-params) c)))
+        (runset "preparePath" sdk       (fn [c _ _2] ((u :prepare-path) c)))
+        (runset "prepareQuery" sdk      (fn [c _ _2] ((u :prepare-query) c)))
+        (runset "resultBasic" sdk       (fn [c _ _2] (neutral ((u :result-basic) c))))
+        (runset "resultBody" sdk        (fn [c _ _2] (neutral ((u :result-body) c))))
+        (runset "resultHeaders" sdk     (fn [c _ _2] (neutral ((u :result-headers) c))))
+        (runset "transformRequest" sdk  (fn [c _ _2] ((u :transform-request) c)))
+        (runset "transformResponse" sdk (fn [c _ _2] ((u :transform-response) c)))
+        (runset "makeOptions" sdk       (fn [c m _2]
                                          (core/oset! c :config (argof m "config"))
                                          (core/oset! c :options (argof m "options"))
                                          ((u :make-options) c)))
-          (runset "makeContext" sdk       (fn [c _ _2]
+        (runset "makeContext" sdk       (fn [c _ _2]
                                          (let [op (core/oget c :op)]
                                            (vs/jm "op" (neutral op)))))
-          (runset "makeError" sdk         (fn [c _ err] (first ((u :make-error) c err))))
-          (runset "operator" sdk          (fn [_ m _2] (neutral (core/make-operation m))))
-          (runset "param" sdk             (fn [c _ pd] ((u :param) c pd)))
-
-          (let [r @corpus/*results*
-                np (count (:pass r))
-                nf (count (:fail r))]
-            (doseq [f (:fail r)]
-              (println "PRIMARY-FAIL" (:group f) (:name f) "-" (:msg f)))
-            (println "PRIMARY CORPUS: PASS" np " FAIL" nf)
-            (t/is-true (< 0 @ran) "the primary corpus executed no sections")
-            (t/is-true (< 0 np) "the primary corpus executed no cases")
-            (t/is-true (= 0 nf) (str nf " primary corpus failures"))))))))
+        (runset "makeError" sdk         (fn [c _ err] (first ((u :make-error) c err))))
+        (runset "operator" sdk          (fn [_ m _2] (neutral (core/make-operation m))))
+        (runset "param" sdk             (fn [c _ pd] ((u :param) c pd)))
+
+        (let [np @npass nf (count @fails)]
+          (doseq [[nm msg] @fails] (println "PRIMARY-FAIL" nm "-" msg))
+          (println "PRIMARY CORPUS: PASS" np " FAIL" nf)
+          (t/is-true (< 0 @ran) "the primary corpus executed no sections")
+          (t/is-true (< 0 np) "the primary corpus executed no cases")
+          (t/is-true (= 0 nf) (str nf " primary corpus failures")))))))

package/project/.sdk/tm/clojure/test/sdk/test/struct_corpus.clj

@@ -1,155 +1,124 @@
-;; ProjectName SDK — vendored voxgig/struct corpus runner.
-;; Runs the shared JSON corpus (.sdk/test/test.json "struct" section) through
-;; the vendored voxgig.struct port exposed by the SDK utility. Adapted from the
-;; canonical clojure struct test runner.
+;; ProjectName SDK - the shared struct corpus, driven by the VENDORED
+;; @voxgig/omni engine.
+;;
+;; The corpus wiring (`run-all` and the walk subjects below) is unchanged: it
+;; names each section of .sdk/test/test.json "struct" and hands omni the
+;; subject that drives it through this SDK's own vendored voxgig.struct. What
+;; changed is the ENGINE underneath - the hand-written entry loop, matcher and
+;; error handling that used to live in this file are gone, replaced by the
+;; vendored runner reached through sdk.test.omni. A hand-written matcher can
+;; only ever check what its author thought of; the shared one is the same code
+;; every other port is held to.
+;;
+;; Counting: omni raises on the first failing entry in a set rather than
+;; recording per-entry results, so a green section counts its whole set and a
+;; red one counts one failure and names the entry omni rejected.
+;;
+;; The count is what the ENGINE RAN, never the section's declared `set` size.
+;; sdk.test.omni increments a counter inside the subject wrapper - the one
+;; place only the engine reaches - and its `runsetflags` returns the delta
+;; across the set; `run-set` records that many passes, and fails the section
+;; outright when the delta does not match the set it handed over. A count
+;; taken from the spec instead would print the same number for a working
+;; engine and for one that was never called, which is worse than no number:
+;; it reads as evidence. So an all-green run reports exactly the corpus's own
+;; entry count BECAUSE the engine executed exactly those entries - if the
+;; number falls, the corpus stopped running, which is the one thing this
+;; suite exists to notice.
 (ns sdk.test.struct-corpus
   (:require [voxgig.struct :as s]
-            [sdk.core :as core]
+            [sdk.test.omni :as omni]
             [clojure.string :as str])
   (:import [java.util LinkedHashMap ArrayList List Map]))
 
-(def NULLMARK "__NULL__")
-(def UNDEFMARK "__UNDEF__")
-(def EXISTSMARK "__EXISTS__")
-
-(defn fix-json [v flag-null]
-  (cond
-    (nil? v) (if flag-null NULLMARK nil)
-    (s/ismap v) (let [o (LinkedHashMap.)]
-                  (doseq [k (.keySet ^Map v)] (.put o (str k) (fix-json (.get ^Map v k) flag-null)))
-                  o)
-    (s/islist v) (let [a (ArrayList.)]
-                   (doseq [x v] (.add a (fix-json x flag-null)))
-                   a)
-    :else v))
-
-(defn canon [v]
-  (cond
-    (s/ismap v) (into (sorted-map) (map (fn [k] [(str k) (canon (.get ^Map v k))]) (.keySet ^Map v)))
-    (s/islist v) (mapv canon (vec v))
-    :else v))
-
-(defn eqv [a b] (= (canon a) (canon b)))
-
-(defn matchval [check base]
-  (let [check (if (or (= check UNDEFMARK) (= check NULLMARK)) nil check)]
-    (cond
-      (eqv check base) true
-      (string? check)
-      (let [basestr (s/stringify base)
-            m (re-matches #"^/(.+)/$" check)]
-        (if m
-          (boolean (re-find (re-pattern (second m)) basestr))
-          (str/includes? (str/lower-case basestr) (str/lower-case (s/stringify check)))))
-      (s/isfunc check) true
-      :else false)))
-
-(defn- omap [& kvs]
-  (let [m (LinkedHashMap.)]
-    (doseq [[k v] (partition 2 kvs)] (.put m k v))
-    m))
-
-(defn do-match [check base]
-  (let [base (s/clone base)]
-    (s/walk check
-            (fn [_k val _p path]
-              (when-not (s/isnode val)
-                (let [baseval (s/getpath base path)]
-                  (cond
-                    (eqv baseval val) nil
-                    (and (= val UNDEFMARK) (nil? baseval)) nil
-                    (and (= val EXISTSMARK) (some? baseval)) nil
-                    (not (matchval val baseval))
-                    (throw (AssertionError.
-                            (str "MATCH: " (str/join "." (vec path)) ": ["
-                                 (s/stringify val) "] <=> [" (s/stringify baseval) "]"))))))
-              val))))
-
-(defn- resolve-args [^Map entry subject]
-  (cond
-    (.containsKey entry "ctx") [(.get entry "ctx")]
-    (.containsKey entry "args")
-    (let [args (vec (.get entry "args"))]
-      ;; 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 silently passes nothing.
-      (when (and (seq args) (s/ismap (first args)))
-        (.put entry "ctx" (first args)))
-      args)
-    (.containsKey entry "in") [(s/clone (.get entry "in"))]
-    :else []))
-
-(defn- safe-call [subject args]
-  (if (empty? args)
-    (try (subject) (catch clojure.lang.ArityException _ (subject nil)))
-    (apply subject args)))
-
-(defn check-result [^Map entry args res]
-  (let [matched (atom false)]
-    (when (.containsKey entry "match")
-      (do-match (.get entry "match")
-                (omap "in" (.get entry "in") "args" (s/clone (ArrayList. ^java.util.Collection args))
-                      "out" (.get entry "res") "ctx" (.get entry "ctx")))
-      (reset! matched true))
-    (let [out (.get entry "out")]
-      (cond
-        (eqv out res) nil
-        (and @matched (or (= out NULLMARK) (nil? out))) nil
-        :else (throw (AssertionError. (str "Expected: " (s/stringify out) ", got: " (s/stringify res))))))))
-
-(defn handle-error [^Map entry err]
-  (let [entry-err (when (.containsKey entry "err") (.get entry "err"))
-        msg (or (.getMessage ^Throwable err) (str err))]
-    (if (.containsKey entry "err")
-      (if (or (= entry-err true) (matchval entry-err msg))
-        (when (.containsKey entry "match")
-          (do-match (.get entry "match")
-                    (omap "in" (.get entry "in") "out" (.get entry "res")
-                          ;; The ts runner hands do-match the ERROR OBJECT, so a
-                          ;; corpus `match: {err: {message: ...}}` resolves. This
-                          ;; port passed the bare message string, where err.message
-                          ;; walks into a string and reads null.
-                          "ctx" (.get entry "ctx") "err" (omap "message" msg))))
-        (throw (AssertionError. (str "ERROR MATCH: [" (s/stringify entry-err) "] <=> [" msg "]"))))
-      (throw (if (instance? AssertionError err) err (AssertionError. (str err)))))))
+(def NULLMARK omni/NULLMARK)
+(def UNDEFMARK omni/UNDEFMARK)
+(def EXISTSMARK omni/EXISTSMARK)
 
 (def ^:dynamic *results* nil)
 
+;; The omni runpack for the section being driven, bound by run-corpus (and by
+;; the primary suite, which shares this recording shape).
+(def ^:dynamic *runner* nil)
+
 (defn- record! [group name ok? msg]
   (swap! *results* update (if ok? :pass :fail) (fnil conj []) {:group group :name name :msg msg}))
 
+(defn- setsize [node]
+  (let [testset (when (s/ismap node) (.get ^Map node "set"))]
+    (if (s/islist testset) (.size ^List testset) 0)))
+
+;; A section whose `set` is PRESENT but empty runs nothing and raises nothing:
+;; it would record no passes and leave the suite green, which is the same
+;; silent stoppage wearing corpus clothes. omni's own strict mode refuses it
+;; (`checkset`), with an `empty: true` opt-out for a section that means it;
+;; the shared corpus declares no OMNI version, so it is lenient v0 and that
+;; check never fires - the rule is applied here instead. A section with no
+;; `set` at all is left to omni, whose message for it is the better one.
+(defn- empty-set? [node]
+  (let [testset (when (s/ismap node) (.get ^Map node "set"))]
+    (boolean (and (s/islist testset)
+                  (zero? (.size ^List testset))
+                  (not (true? (.get ^Map node "empty")))))))
+
+;; Drive one corpus section through the vendored engine.
+;;
+;; `flags` is the corpus-facing spelling ({"null" false}); omni's own is
+;; keyword-keyed, and it takes the section label there too, so a failure names
+;; the section rather than the runner.
 (defn run-set
   ([group node subject] (run-set group node {} subject))
   ([group node flags subject]
-   (when (s/ismap node)
-     (let [flag-null (get flags "null" true)
-           fixed (fix-json node flag-null)
-           testset (.get ^Map fixed "set")]
-       (doseq [^Map entry testset]
-         (try
-           (when (and (not (.containsKey entry "out")) flag-null)
-             (.put entry "out" NULLMARK))
-           (let [args (resolve-args entry subject)
-                 res (fix-json (safe-call subject args) flag-null)]
-             (.put entry "res" res)
-             (check-result entry args res))
-           (record! group (str (.get entry "name")) true nil)
-           (catch Throwable err
-             (try
-               (handle-error entry err)
-               (record! group (str (.get entry "name")) true nil)
-               (catch Throwable e2
-                 (record! group (str (.get entry "name")) false (.getMessage e2)))))))))))
+   (cond
+     (nil? *runner*)
+     (record! group "section" false "no omni runner bound")
+
+     (not (s/ismap node))
+     ;; A missing section used to be skipped in silence, which is how a
+     ;; renamed corpus section becomes a suite that tests nothing.
+     (record! group "section" false "corpus section missing")
 
+     (empty-set? node)
+     (record! group "entries" false "corpus section has an empty set")
+
+     :else
+     (let [omniflags (cond-> {:name group}
+                       (contains? flags "null") (assoc :null (boolean (get flags "null"))))
+           n (setsize node)]
+       (try
+         ;; `ran` is the engine's own execution count for this set, not the
+         ;; corpus's declared size: a section that reports fewer (or, with a
+         ;; disconnected engine, none) fails here instead of counting the
+         ;; entries nobody ran.
+         (let [ran (long (or ((:runsetflags *runner*) node omniflags subject) 0))]
+           (if (not= ran n)
+             (record! group "entries" false
+                      (str "the engine ran " ran " of the section's " n " entries"))
+             (dotimes [_ ran] (record! group "entry" true nil))))
+         (catch Throwable err
+           (record! group "entry" false (or (ex-message err) (str err)))))))))
+
+;; A section that is one case rather than a `set`: `in` in, `out` expected.
+;; omni has no entry point for these, so the comparison is its own
+;; `deepequal`, on values converted back into its model.
 (defn run-single [group node actual-fn]
-  (when (s/ismap node)
+  (if-not (s/ismap node)
+    (record! group "single" false "corpus section missing")
     (try
       (let [expected (.get ^Map node "out")
-            actual (actual-fn (.get ^Map node "in"))]
-        (if (eqv expected actual)
+            actual (omni/->omni (actual-fn (omni/->struct (.get ^Map node "in"))))]
+        (if (omni/deep-equal? expected actual)
           (record! group "single" true nil)
-          (record! group "single" false (str "Expected: " (s/stringify expected) ", got: " (s/stringify actual)))))
-      (catch Throwable e (record! group "single" false (.getMessage e))))))
+          (record! group "single" false
+                   (str "Expected: " (omni/stringify expected) ", got: " (omni/stringify actual)))))
+      (catch Throwable e (record! group "single" false (or (ex-message e) (str e)))))))
+
+;; A struct-model map literal, for the inject/transform sections that build a
+;; store or an injection descriptor by hand.
+(defn- omap [& kvs]
+  (let [m (LinkedHashMap.)]
+    (doseq [[k v] (partition 2 kvs)] (.put m k v))
+    m))
 
 (defn- gp [^Map m & ks] (reduce (fn [acc k] (when (s/ismap acc) (.get ^Map acc k))) m ks))
 (defn- vget [vin k] (when (s/ismap vin) (.get ^Map vin k)))
@@ -157,10 +126,7 @@
 
 (declare run-walk-log walk-copy-subject walk-depth-subject)
 
-(defn null-modifier [val key parent & _]
-  (cond
-    (= val NULLMARK) (s/setprop parent key nil)
-    (string? val) (s/setprop parent key (str/replace val NULLMARK "null"))))
+(def null-modifier omni/null-modifier)
 
 (defn run-all [spec]
   (let [minor (gp spec "minor") walk (gp spec "walk") mergeS (gp spec "merge")
@@ -285,23 +251,30 @@
       (run-set (str "select." g) (gp selectS g)
                (fn [vin] (s/select (vget vin "obj") (vget vin "query")))))))
 
+
+;; `walk.log` is a single case whose expectation is the log the walk emits.
+;; The node arrives in omni's model, so it is converted before the vendored
+;; struct walks it, and the log converted back before omni compares.
 (defn run-walk-log [group node]
-  (when (s/ismap node)
+  (if-not (s/ismap node)
+    (record! group "log" false "corpus section missing")
     (try
-      (let [test-data (s/clone node)
+      (let [test-data (omni/->struct node)
             log (ArrayList.)
             walklog (fn [key val parent path]
                       (.add log (str "k=" (if (nil? key) (s/stringify) (s/stringify key))
                                      ", v=" (s/stringify val)
                                      ", p=" (if (nil? parent) (s/stringify) (s/stringify parent))
                                      ", t=" (s/pathify path)))
-                      val)]
+                      val)
+            expected (gp node "out" "after")]
         (s/walk (.get ^Map test-data "in") walklog)
-        (if (eqv (s/getprop (.get ^Map test-data "out") "after") log)
+        (if (omni/deep-equal? expected (omni/->omni log))
           (record! group "log" true nil)
-          (record! group "log" false (str "Expected: " (s/stringify (s/getprop (.get ^Map test-data "out") "after"))
-                                          ", got: " (s/stringify log)))))
-      (catch Throwable e (record! group "log" false (.getMessage e))))))
+          (record! group "log" false
+                   (str "Expected: " (omni/stringify expected)
+                        ", got: " (omni/stringify (omni/->omni log))))))
+      (catch Throwable e (record! group "log" false (or (ex-message e) (str e)))))))
 
 (defn walk-copy-subject [vin]
   (let [cur (atom (doto (ArrayList.) (.add nil)))]
@@ -336,13 +309,13 @@
       (s/walk (vget vin "src") {:before copy :maxdepth (vget vin "maxdepth")})
       (:top @state))))
 
+
 ;; Returns [pass fail failures]. Prints each failure.
 (defn run-corpus [testfile]
-  (let [raw (slurp testfile)
-        alltests (core/json-parse raw)
-        spec (.get ^Map alltests "struct")]
-    (binding [*results* (atom {:pass [] :fail []})]
-      (run-all spec)
+  (let [runpack ((omni/make-runner testfile) "struct")]
+    (binding [*results* (atom {:pass [] :fail []})
+              *runner* runpack]
+      (run-all (:spec runpack))
       (let [r @*results* np (count (:pass r)) nf (count (:fail r))]
         (doseq [f (:fail r)] (println "STRUCT-FAIL" (:group f) (:name f) "-" (:msg f)))
         [np nf (:fail r)]))))

package/project/.sdk/tm/clojure/test/sdk/test_runner.clj

@@ -1,13 +1,15 @@
 ;; ProjectName SDK test runner (tools.deps main entry point).
-;; Runs the API-agnostic suites (primary utility, pipeline, features, netsim),
-;; the generated API-specific suite, and the vendored struct corpus, then
-;; reports counts and exits non-zero on any failure.
+;; Runs the vendored omni runner's smoke test, the API-agnostic suites
+;; (primary utility, pipeline, features, netsim), the generated API-specific
+;; suite, and the vendored struct corpus, then reports counts and exits
+;; non-zero on any failure.
 (ns sdk.test-runner
   (:require [sdk.test.primary :as primary]
             [sdk.test.pipeline :as pipeline]
             [sdk.test.feature :as feature]
             [sdk.test.netsim :as netsim]
             [sdk.test.struct-corpus :as corpus]
+            [sdk.test.omni-smoke :as omnismoke]
             [sdk.gentest :as gentest]))
 
 (defn- find-corpus-file []
@@ -17,6 +19,9 @@
 (defn -main [& _args]
   (let [results (atom [])
         rec (fn [name ok? msg] (swap! results conj {:name name :ok ok? :msg msg}))]
+    ;; The vendored engine's own smoke test runs FIRST: if the runner cannot
+    ;; fail a bad entry, every corpus count below it is meaningless.
+    (omnismoke/run rec)
     (primary/run rec)
     ;; The shared corpus, driven through this SDK's utilities.
     (primary/run-corpus rec)