@voxgig/sdkgen 4.8.1 → 4.8.3

package/project/.sdk/tm/kotlin/test/RunnerSupport.kt

@@ -1,8 +1,14 @@
 package KOTLINPACKAGE.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 comparison helper 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.kt. The object 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.Paths
@@ -19,7 +25,6 @@ import KOTLINPACKAGE.core.SdkError
 import KOTLINPACKAGE.core.Spec
 import KOTLINPACKAGE.core.Utility
 import KOTLINPACKAGE.utility.Json
-import KOTLINPACKAGE.utility.struct.Struct
 
 @Suppress("UNCHECKED_CAST")
 object RunnerSupport {
@@ -184,118 +189,6 @@ object RunnerSupport {
     return Helpers.toMapAny(cur)
   }
 
-  fun interface RunSubject {
-    fun run(entry: MutableMap<String, Any?>): Any?
-  }
-
-  // runset drives a test.json entry set against a subject.
-  fun runset(testspec: Map<String, Any?>?, subject: RunSubject) {
-    if (testspec == null || testspec["set"] !is List<*>) {
-      return
-    }
-    val set = testspec["set"] as List<Any?>
-
-    val failures = mutableListOf<String>()
-
-    for (i in set.indices) {
-      val entry = Helpers.toMapAny(set[i]) ?: continue
-
-      val mark = if (entry["mark"] == null) "" else " (mark=" + entry["mark"] + ")"
-
-      var result: Any? = null
-      var err: Exception? = null
-      try {
-        result = subject.run(entry)
-      } catch (e: Exception) {
-        err = e
-      }
-
-      val expectedErr = entry["err"]
-
-      if (err != null) {
-        if (expectedErr != null) {
-          val errMsg = err.message ?: err.toString()
-          if (expectedErr is String && !matchString(expectedErr, errMsg)) {
-            failures.add("entry $i$mark: error mismatch: got \"$errMsg\", want contains \"$expectedErr\"")
-          }
-          val matchSpec = Helpers.toMapAny(entry["match"])
-          if (matchSpec != null) {
-            val resultMap = linkedMapOf<String, Any?>()
-            resultMap["in"] = entry["in"]
-            resultMap["out"] = jsonNormalize(result)
-            val errRec = linkedMapOf<String, Any?>()
-            errRec["message"] = errMsg
-            resultMap["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
-      }
-
-      var matched = false
-      val matchSpec = Helpers.toMapAny(entry["match"])
-      if (matchSpec != null) {
-        val resultMap = linkedMapOf<String, Any?>()
-        resultMap["in"] = entry["in"]
-        resultMap["out"] = jsonNormalize(result)
-        if (entry["args"] != null) {
-          resultMap["args"] = entry["args"]
-        } else if (entry["in"] != null) {
-          val args = mutableListOf<Any?>()
-          args.add(entry["in"])
-          resultMap["args"] = args
-        }
-        if (entry["ctx"] != null) {
-          resultMap["ctx"] = entry["ctx"]
-        }
-        matchDeep(failures, i, mark, matchSpec, resultMap, "")
-        matched = true
-      }
-
-      val expectedOut = entry["out"]
-      if (expectedOut == null && matched) {
-        continue
-      }
-      if (expectedOut != null) {
-        val normResult = jsonNormalize(result)
-        val normExpected = jsonNormalize(expectedOut)
-        if (canon(normResult) != canon(normExpected)) {
-          failures.add("entry $i$mark: output mismatch:\n  got:  ${jsonStr(normResult)}\n  want: ${jsonStr(normExpected)}")
-        }
-      }
-    }
-
-    if (failures.isNotEmpty()) {
-      throw AssertionError(failures.joinToString("\n"))
-    }
-  }
-
-  fun jsonNormalize(v: Any?): Any? {
-    if (v == null) {
-      return null
-    }
-    return try {
-      Json.parse(Struct.jsonify(v))
-    } catch (e: RuntimeException) {
-      v
-    }
-  }
-
-  fun jsonStr(v: Any?): String {
-    return try {
-      Struct.jsonify(v)
-    } catch (e: RuntimeException) {
-      v.toString()
-    }
-  }
-
   fun canon(v: Any?): Any? {
     if (v == null) {
       return null
@@ -327,68 +220,6 @@ object RunnerSupport {
     return v.toString()
   }
 
-  fun matchDeep(failures: MutableList<String>, entryIdx: Int, mark: String, check: Any?, base: Any?, path: String) {
-    if (check == null) {
-      return
-    }
-
-    if (check is Map<*, *>) {
-      for (e in (check as Map<String, Any?>).entries) {
-        val childPath = "$path.${e.key}"
-        val baseVal = if (base is Map<*, *>) (base as Map<String, Any?>)[e.key] else null
-        matchDeep(failures, entryIdx, mark, e.value, baseVal, childPath)
-      }
-    } else if (check is List<*>) {
-      for (i in check.indices) {
-        val childPath = "$path[$i]"
-        var baseVal: Any? = null
-        if (base is List<*> && i < base.size) {
-          baseVal = base[i]
-        }
-        matchDeep(failures, entryIdx, mark, check[i], baseVal, childPath)
-      }
-    } else {
-      if ("__EXISTS__" == check) {
-        if (base == null) {
-          failures.add("entry $entryIdx$mark: match $path: expected value to exist but got null")
-        }
-        return
-      }
-      if ("__UNDEF__" == check) {
-        if (base != null) {
-          failures.add("entry $entryIdx$mark: match $path: expected null but got $base")
-        }
-        return
-      }
-
-      val normCheck = jsonNormalize(check)
-      val normBase = jsonNormalize(base)
-
-      if (canon(normCheck) != canon(normBase)) {
-        if (check is String && "" != check) {
-          val baseStr = Struct.stringify(base)
-          if (matchString(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.
-  fun matchString(pattern: String, v: String): Boolean {
-    if (pattern.length >= 2 && pattern.startsWith("/") && pattern.endsWith("/")) {
-      return try {
-        Regex(pattern.substring(1, pattern.length - 1)).containsMatchIn(v)
-      } catch (e: RuntimeException) {
-        false
-      }
-    }
-    return v.lowercase().contains(pattern.lowercase())
-  }
-
   // makeCtxFromMap creates a Context from a JSON test entry's ctx or args map.
   fun makeCtxFromMap(ctxmapIn: MutableMap<String, Any?>?, client: ProjectNameSDK?, utility: Utility?): Context {
     val ctxmap = ctxmapIn ?: linkedMapOf()

package/project/.sdk/tm/kotlin/test/StructCorpusTest.kt

@@ -1,20 +1,56 @@
 package KOTLINPACKAGE.sdktest
 
-// Drives the shared struct corpus (../.sdk/test/test.json, root key "struct")
-// against the vendored Kotlin struct utility. 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 Kotlin struct utility THROUGH the vendored
+// omni runner (OmniResolver over test/vendor/omni) - the engine half of the
+// retired StructRunner. Mirrors tm/java/test/StructCorpusTest.java and 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 org.junit.jupiter.api.Assertions.assertNotNull
+import 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.TreeMap
+
 import java.util.function.Function
 
+import voxgig.omni.Flags
+
+import KOTLINPACKAGE.core.Helpers
+import KOTLINPACKAGE.core.ProjectNameSDK
 import KOTLINPACKAGE.utility.struct.Struct
 
 @Suppress("UNCHECKED_CAST")
 class StructCorpusTest {
 
+  companion object {
+    const val TEST_JSON_FILE = "../.sdk/test/test.json"
+
+    private var RUN: OmniResolver.Run? = null
+
+    @Synchronized
+    fun structRun(): OmniResolver.Run {
+      var r = RUN
+      if (null == r) {
+        r = OmniResolver
+          .makeRunner(TEST_JSON_FILE, ProjectNameSDK.testSDK())
+          .runner("struct", linkedMapOf<String, Any?>())
+        assertNotNull(r.spec, "struct section not found in test.json")
+        RUN = r
+      }
+      return r
+    }
+  }
+
+  /** A subject in the struct-corpus shape: one argument in, one value out. */
+  fun interface StructSubject {
+    fun apply(input: Any?): Any?
+  }
+
   private fun getp(input: Any?, key: String): Any? =
     if (input is Map<*, *>) (input as Map<String, Any?>)[key] else null
 
@@ -199,9 +235,12 @@ class StructCorpusTest {
     }
 
     // ===== inject =====
+    // inject.string passes the null modifier so a resolved JSON null
+    // (encoded by the runner as "__NULL__") renders as a real null / the
+    // literal text "null" (was StructRunner.NULL_MODIFIER).
     add(tests, "inject", "string", true) {
       val inj = Struct.Injection(null, null)
-      inj.modify = StructRunner.NULL_MODIFIER
+      inj.modify = NULL_MODIFIER
       Struct.inject(getp(it, "val"), getp(it, "store"), inj)
     }
     add(tests, "inject", "deep", true) { Struct.inject(getp(it, "val"), getp(it, "store")) }
@@ -252,46 +291,96 @@ 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). The vendored kotlin
+  // struct answers the canonical way on every question, list form included
+  // (measured; see docs/design/vendor-tag-rollout.md). 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
+  fun nullsem() {
+    val run = structRun()
+    val nullsem = Helpers.toMapAny(run.spec["nullsem"])
+    if (nullsem == null) {
+      Assumptions.abort<Any>(
+        "corpus predates struct.nullsem - refresh .sdk/test/struct from create-sdkgen",
+      )
+      return
+    }
+    val flags = Flags(nulls = false)
+
+    run.runsetflags(nullsem["getprop"], flags) { args ->
+      val input = args.getOrNull(0)
+      val alt = getpDef(input, "alt", Struct.UNDEF)
+      if (alt === Struct.UNDEF) {
+        Struct.getprop(getp(input, "val"), getp(input, "key"))
+      } else {
+        Struct.getprop(getp(input, "val"), getp(input, "key"), alt)
+      }
+    }
+
+    run.runsetflags(nullsem["getelem"], flags) { args ->
+      val input = args.getOrNull(0)
+      val alt = getpDef(input, "alt", Struct.UNDEF)
+      if (alt === Struct.UNDEF) {
+        Struct.getelem(getp(input, "val"), getp(input, "key"))
+      } else {
+        Struct.getelem(getp(input, "val"), getp(input, "key"), alt)
+      }
+    }
+
+    run.runsetflags(nullsem["getpath"], flags) { args ->
+      Struct.getpath(getp(args.getOrNull(0), "store"), getp(args.getOrNull(0), "path"))
+    }
+
+    run.runsetflags(nullsem["haskey"], flags) { args ->
+      Struct.haskey(getp(args.getOrNull(0), "src"), getp(args.getOrNull(0), "key"))
+    }
+
+    run.runsetflags(nullsem["keysof"], flags) { args ->
+      Struct.keysof(args.getOrNull(0))
+    }
+  }
+
   private fun add(
     tests: MutableList<DynamicTest>,
     category: String,
     name: String,
     nullFlag: Boolean,
-    subject: StructRunner.Subject,
+    subject: StructSubject,
   ) {
     tests.add(
       DynamicTest.dynamicTest("$category-$name") {
-        val spec = StructRunner.getSpec(category, name) ?: return@dynamicTest
-        val r = StructRunner.runsetflags("$category.$name", spec, nullFlag, subject)
-        SCOREBOARD["$category.$name"] = r
-        if (r.failures.isNotEmpty()) {
-          throw AssertionError(
-            "$category.$name: ${r.passed}/${r.total} passed; failures:\n  " +
-              r.failures.joinToString("\n  "),
-          )
+        val run = structRun()
+        val cat = Helpers.toMapAny(run.spec[category])
+        assertNotNull(cat, "struct corpus category missing: $category - check .sdk/test/struct/")
+        val spec = Helpers.toMapAny(cat!![name])
+        assertNotNull(spec, "struct corpus section missing: $category.$name - check .sdk/test/struct/")
+        val set = spec!!["set"]
+        assertTrue(
+          set is List<*> && set.isNotEmpty(),
+          "struct corpus section is EMPTY: $category.$name - zero cases would run",
+        )
+        run.runsetflags(spec, Flags(nulls = nullFlag, name = "$category.$name")) { args ->
+          subject.apply(if (args.isNotEmpty()) args[0] else Struct.UNDEF)
         }
       },
     )
   }
 
-  companion object {
-    private val SCOREBOARD: MutableMap<String, StructRunner.Result> = TreeMap()
-
-    @JvmStatic
-    @AfterAll
-    fun printScoreboard() {
-      var totalP = 0
-      var totalT = 0
-      val banner = StringBuilder()
-      banner.append("\n========= STRUCT CORPUS SCOREBOARD =========\n")
-      for ((key, r) in SCOREBOARD) {
-        banner.append(String.format("  %-30s %4d / %4d%n", key, r.passed, r.total))
-        totalP += r.passed
-        totalT += r.total
+  private val NULL_MODIFIER = Struct.Modify { value, key, parent, _, _ ->
+    if (value is String) {
+      val repl: Any? = when {
+        value == OmniResolver.NULLMARK -> null
+        value.contains(OmniResolver.NULLMARK) -> value.replace(OmniResolver.NULLMARK, "null")
+        else -> return@Modify
+      }
+      when {
+        parent is MutableMap<*, *> && key != null -> (parent as MutableMap<String, Any?>)[key.toString()] = repl
+        parent is MutableList<*> && key is Number -> (parent as MutableList<Any?>)[key.toInt()] = repl
       }
-      banner.append(String.format("  %-30s %4d / %4d%n", "TOTAL", totalP, totalT))
-      banner.append("============================================\n")
-      println(banner)
     }
   }
 }

package/project/.sdk/tm/kotlin/test/vendor/omni/Json.kt

@@ -0,0 +1,264 @@
+// VENDORED: @voxgig/omni sdk-20260904-1610-0 (kotlin/src/Json.kt)
+// Source: https://github.com/voxgig/omni @ 8c3e1b573a8d35796f7fc45e3226b977023cabf7  [tag: sdk-20260904-1610-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+// The omni JSON value model, with a small in-tree parser.
+//
+// The omni runner must be able to test *any* library, and must add no
+// third-party dependencies, so it carries its own JSON support rather than
+// borrowing kotlinx.serialization, Gson or the system under test.
+
+package voxgig.omni
+
+/**
+ * A JSON value. `Absent` is the marker for "no value at all", as distinct
+ * from `Null`.
+ */
+sealed class Json {
+    object Absent : Json()
+
+    object Null : Json()
+
+    data class Bool(val value: Boolean) : Json()
+
+    data class Num(val value: Double) : Json()
+
+    data class Str(val value: String) : Json()
+
+    data class JList(val value: MutableList<Json>) : Json()
+
+    data class JMap(val value: LinkedHashMap<String, Json>) : Json()
+
+    val ismap: Boolean get() = this is JMap
+    val islist: Boolean get() = this is JList
+    val isnode: Boolean get() = ismap || islist
+    val isabsent: Boolean get() = this is Absent
+    val isnull: Boolean get() = this is Null
+    val isnone: Boolean get() = isabsent || isnull
+    val isnum: Boolean get() = this is Num
+    val isstr: Boolean get() = this is Str
+    val isbool: Boolean get() = this is Bool
+
+    val asnum: Double? get() = (this as? Num)?.value
+    val asstr: String? get() = (this as? Str)?.value
+    val aslist: MutableList<Json>? get() = (this as? JList)?.value
+    val asmap: LinkedHashMap<String, Json>? get() = (this as? JMap)?.value
+
+    /** Read a map entry. Returns Absent when missing. */
+    fun get(key: String): Json = (this as? JMap)?.value?.get(key) ?: Absent
+
+    /** Is a map key present at all (even with a null value)? */
+    fun has(key: String): Boolean = (this as? JMap)?.value?.containsKey(key) ?: false
+
+    /** Set a map entry (no-op for non-maps). */
+    fun set(key: String, entry: Json) {
+        (this as? JMap)?.value?.put(key, entry)
+    }
+
+    fun push(entry: Json) {
+        (this as? JList)?.value?.add(entry)
+    }
+
+    companion object {
+        fun list(vararg entries: Json): Json = JList(entries.toMutableList())
+
+        fun map(vararg entries: Pair<String, Json>): Json {
+            val out = LinkedHashMap<String, Json>()
+            for ((key, value) in entries) {
+                out[key] = value
+            }
+            return JMap(out)
+        }
+
+        fun num(value: Number): Json = Num(value.toDouble())
+
+        fun str(value: String): Json = Str(value)
+
+        /** Parse JSON text into the omni value model. */
+        fun parse(text: String): Json {
+            val parser = Parser(text)
+            parser.skipws()
+            val val_ = parser.value()
+            parser.skipws()
+            if (!parser.done()) {
+                throw OmniError("omni: trailing JSON content at ${parser.pos}")
+            }
+            return val_
+        }
+    }
+
+    private class Parser(val text: String) {
+        var pos = 0
+
+        fun done(): Boolean = pos >= text.length
+
+        fun skipws() {
+            while (pos < text.length) {
+                val ch = text[pos]
+                if (' ' == ch || '\t' == ch || '\n' == ch || '\r' == ch) {
+                    pos++
+                } else {
+                    break
+                }
+            }
+        }
+
+        fun value(): Json {
+            if (done()) {
+                throw OmniError("omni: unexpected end of JSON")
+            }
+
+            return when (text[pos]) {
+                '{' -> map()
+                '[' -> list()
+                '"' -> Str(str())
+                't' -> { word("true"); Bool(true) }
+                'f' -> { word("false"); Bool(false) }
+                'n' -> { word("null"); Null }
+                else -> num()
+            }
+        }
+
+        fun word(want: String) {
+            if (!text.startsWith(want, pos)) {
+                throw OmniError("omni: bad JSON literal at $pos")
+            }
+            pos += want.length
+        }
+
+        fun map(): Json {
+            val out = LinkedHashMap<String, Json>()
+            pos++ // {
+
+            skipws()
+            if (!done() && '}' == text[pos]) {
+                pos++
+                return JMap(out)
+            }
+
+            while (true) {
+                skipws()
+                val key = str()
+                skipws()
+
+                if (done() || ':' != text[pos]) {
+                    throw OmniError("omni: expected ':' at $pos")
+                }
+                pos++
+
+                skipws()
+                out[key] = value()
+                skipws()
+
+                if (done()) {
+                    throw OmniError("omni: unterminated JSON object")
+                }
+                if (',' == text[pos]) {
+                    pos++
+                    continue
+                }
+                if ('}' == text[pos]) {
+                    pos++
+                    return JMap(out)
+                }
+                throw OmniError("omni: expected ',' or '}' at $pos")
+            }
+        }
+
+        fun list(): Json {
+            val out = mutableListOf<Json>()
+            pos++ // [
+
+            skipws()
+            if (!done() && ']' == text[pos]) {
+                pos++
+                return JList(out)
+            }
+
+            while (true) {
+                skipws()
+                out.add(value())
+                skipws()
+
+                if (done()) {
+                    throw OmniError("omni: unterminated JSON array")
+                }
+                if (',' == text[pos]) {
+                    pos++
+                    continue
+                }
+                if (']' == text[pos]) {
+                    pos++
+                    return JList(out)
+                }
+                throw OmniError("omni: expected ',' or ']' at $pos")
+            }
+        }
+
+        fun str(): String {
+            if (done() || '"' != text[pos]) {
+                throw OmniError("omni: expected string at $pos")
+            }
+            pos++
+
+            val out = StringBuilder()
+
+            while (pos < text.length) {
+                val ch = text[pos++]
+
+                if ('"' == ch) {
+                    return out.toString()
+                }
+
+                if ('\\' != ch) {
+                    out.append(ch)
+                    continue
+                }
+
+                if (done()) {
+                    break
+                }
+
+                when (val escape = text[pos++]) {
+                    '"' -> out.append('"')
+                    '\\' -> out.append('\\')
+                    '/' -> out.append('/')
+                    'b' -> out.append('\b')
+                    'f' -> out.append('')
+                    'n' -> out.append('\n')
+                    'r' -> out.append('\r')
+                    't' -> out.append('\t')
+                    'u' -> {
+                        if (pos + 4 > text.length) {
+                            throw OmniError("omni: bad JSON unicode escape")
+                        }
+                        out.append(text.substring(pos, pos + 4).toInt(16).toChar())
+                        pos += 4
+                    }
+                    else -> throw OmniError("omni: bad JSON escape [$escape] at $pos")
+                }
+            }
+
+            throw OmniError("omni: unterminated JSON string")
+        }
+
+        fun num(): Json {
+            val start = pos
+
+            if (pos < text.length && ('-' == text[pos] || '+' == text[pos])) {
+                pos++
+            }
+
+            while (pos < text.length) {
+                val ch = text[pos]
+                if (ch.isDigit() || '.' == ch || 'e' == ch || 'E' == ch || '-' == ch || '+' == ch) {
+                    pos++
+                } else {
+                    break
+                }
+            }
+
+            val span = text.substring(start, pos)
+            return Num(span.toDoubleOrNull() ?: throw OmniError("omni: bad JSON number [$span] at $start"))
+        }
+    }
+}