@voxgig/sdkgen 1.3.8 → 1.3.9

package/project/.sdk/tm/scala/sdktest/SdkTestMain.scala

@@ -0,0 +1,766 @@
+// Runtime test suite for the ProjectName SDK — a dependency-free scala-cli
+// main (no JUnit). Drives the operation pipeline, the enterprise features
+// (via an offline mock-transport harness mirroring the go/java feature
+// tests), feature-add ordering, and an end-to-end entity CRUD flow through
+// the in-memory test transport. Exits non-zero on any failure.
+
+import java.util.{ArrayList, Iterator => JIterator, LinkedHashMap, List => JList, Map => JMap}
+import java.util.function.{BiFunction, Consumer, Function => JFunction, IntConsumer, LongSupplier, Supplier}
+
+import SCALAPACKAGE.core._
+import SCALAPACKAGE.feature._
+import SCALAPACKAGE.utility.struct.Struct
+
+object SdkTestMain {
+
+  // ---- assertion harness ---------------------------------------------------
+
+  private var npass = 0
+  private val failures = new ArrayList[String]()
+
+  private def pass(): Unit = { npass += 1 }
+  private def fail(name: String, msg: String): Unit = failures.add(name + ": " + msg)
+  private def check(name: String, cond: Boolean, msg: String): Unit =
+    if (cond) pass() else fail(name, msg)
+
+  private def jeq(a: Object, b: Object): Boolean = (a, b) match {
+    case (null, null) => true
+    case (x: java.lang.Number, y: java.lang.Number) => x.doubleValue() == y.doubleValue()
+    case (null, _) => false
+    case _ => a.equals(b)
+  }
+  private def eq(name: String, exp: Object, act: Object): Unit =
+    check(name, jeq(exp, act), "expected " + exp + ", got " + act)
+  private def eqI(name: String, exp: Int, act: Int): Unit =
+    check(name, exp == act, "expected " + exp + ", got " + act)
+  private def eqL(name: String, exp: Long, act: Long): Unit =
+    check(name, exp == act, "expected " + exp + ", got " + act)
+
+  // ---- small builders ------------------------------------------------------
+
+  private def om(kv: (String, Object)*): JMap[String, Object] = {
+    val m = new LinkedHashMap[String, Object]()
+    kv.foreach { case (k, v) => m.put(k, v) }
+    m
+  }
+  private def jl(xs: Object*): JList[Object] = {
+    val l = new ArrayList[Object]()
+    xs.foreach(l.add)
+    l
+  }
+  private def I(n: Int): java.lang.Integer = java.lang.Integer.valueOf(n)
+  private def B(b: Boolean): java.lang.Boolean = java.lang.Boolean.valueOf(b)
+
+  // ================= feature harness (mirrors go/java feature tests) =========
+
+  final class FhClock {
+    var t: Long = 0
+    def now(): Long = t
+    def sleep(ms: Int): Unit = { t += ms }
+    def advance(ms: Int): Unit = { t += ms }
+    def sleepFn: IntConsumer = (ms: Int) => sleep(ms)
+    def nowFn: LongSupplier = () => now()
+  }
+
+  def fhResponse(status: Int, data: Object, headers: JMap[String, Object]): JMap[String, Object] = {
+    val h = new LinkedHashMap[String, Object]()
+    if (headers != null) {
+      val it = headers.entrySet().iterator()
+      while (it.hasNext) { val e = it.next(); h.put(e.getKey.toLowerCase, e.getValue) }
+    }
+    val js: Supplier[Object] = () => data
+    val out = new LinkedHashMap[String, Object]()
+    out.put("status", I(status))
+    out.put("statusText", if (status >= 400) "ERR" else "OK")
+    out.put("body", "not-used")
+    out.put("json", js)
+    out.put("headers", h)
+    out
+  }
+
+  final class FhRecorder {
+    val calls = new ArrayList[JMap[String, Object]]()
+    var reply: BiFunction[java.lang.Integer, JMap[String, Object], Object] = null
+    def fetch(ctx: Context, url: String, fetchdef: JMap[String, Object]): Object = {
+      val call = new LinkedHashMap[String, Object]()
+      call.put("url", url)
+      call.put("fetchdef", fetchdef)
+      calls.add(call)
+      if (reply != null) return reply.apply(I(calls.size()), fetchdef)
+      val data = new LinkedHashMap[String, Object]()
+      data.put("ok", B(true)); data.put("n", I(calls.size()))
+      fhResponse(200, data, null)
+    }
+    def headers(i: Int): JMap[String, Object] = {
+      val fd = Helpers.toMapAny(calls.get(i).get("fetchdef"))
+      val h = if (fd == null) null else Helpers.toMapAny(fd.get("headers"))
+      if (h == null) new LinkedHashMap[String, Object]() else h
+    }
+    def fetchdef(i: Int): JMap[String, Object] = {
+      val fd = Helpers.toMapAny(calls.get(i).get("fetchdef"))
+      if (fd == null) new LinkedHashMap[String, Object]() else fd
+    }
+    def url(i: Int): String = calls.get(i).get("url") match { case s: String => s; case _ => "" }
+  }
+
+  final class FhFeature(val f: Feature, val options: JMap[String, Object])
+  def fhF(f: Feature, options: JMap[String, Object]): FhFeature = new FhFeature(f, options)
+
+  final class FhOpSpec {
+    var entity = ""; var op = ""; var method = ""; var path = ""
+    var query: JMap[String, Object] = null
+    var headers: JMap[String, Object] = null
+    var body: Object = null
+    var ctrl: JMap[String, Object] = null
+    def withOp(o: String): FhOpSpec = { op = o; this }
+    def withPath(p: String): FhOpSpec = { path = p; this }
+    def withMethod(m: String): FhOpSpec = { method = m; this }
+    def withHeaders(h: JMap[String, Object]): FhOpSpec = { headers = h; this }
+    def withQuery(q: JMap[String, Object]): FhOpSpec = { query = q; this }
+    def withCtrl(c: JMap[String, Object]): FhOpSpec = { ctrl = c; this }
+  }
+  def fhOp(op: String): FhOpSpec = { val s = new FhOpSpec(); s.op = op; s }
+
+  final class FhOpResult {
+    var ok = false
+    var data: Object = null
+    var err: RuntimeException = null
+    var result: Result = null
+    var ctx: Context = null
+  }
+
+  def fhDefaultMethod(op: String): String = op match {
+    case "create" => "POST"; case "update" => "PATCH"; case "remove" => "DELETE"; case _ => "GET"
+  }
+
+  def fhBuildUrl(spec: Spec): String = {
+    val keys = new java.util.TreeMap[String, Object](spec.query)
+    val qs = new StringBuilder()
+    val it = keys.entrySet().iterator()
+    while (it.hasNext) {
+      val e = it.next()
+      if (e.getValue != null) {
+        if (qs.length > 0) qs.append("&")
+        qs.append(java.net.URLEncoder.encode(e.getKey, java.nio.charset.StandardCharsets.UTF_8))
+          .append("=")
+          .append(java.net.URLEncoder.encode(String.valueOf(e.getValue), java.nio.charset.StandardCharsets.UTF_8))
+      }
+    }
+    var url = spec.base + spec.path
+    if (qs.length > 0) url += "?" + qs.toString
+    url
+  }
+
+  final class FhHarness {
+    var client: ProjectNameSDK = null
+    var utility: Utility = null
+    var rootctx: Context = null
+    var base = "http://api.test"
+
+    def op(o: FhOpSpec): FhOpResult = {
+      val entity = if ("" == o.entity) "widget" else o.entity
+      val opname = if ("" == o.op) "load" else o.op
+      val method = if ("" == o.method) fhDefaultMethod(opname) else o.method
+      val ctrl = if (o.ctrl == null) new LinkedHashMap[String, Object]() else o.ctrl
+
+      val ctxmap = new LinkedHashMap[String, Object]()
+      ctxmap.put("opname", opname)
+      ctxmap.put("ctrl", ctrl)
+      val ctx = utility.makeContext(ctxmap, rootctx)
+      val opdef = new LinkedHashMap[String, Object]()
+      opdef.put("entity", entity); opdef.put("name", opname)
+      ctx.op = new Operation(opdef)
+
+      utility.featureHook(ctx, "PostConstructEntity")
+
+      utility.featureHook(ctx, "PrePoint")
+      ctx.out.get("point") match { case e: RuntimeException => return failOp(ctx, e); case _ => }
+
+      utility.featureHook(ctx, "PreSpec")
+      val path = if (o.path == null || "" == o.path) "/" + entity else o.path
+      val headers = new LinkedHashMap[String, Object]()
+      if (o.headers != null) headers.putAll(o.headers)
+      val query = new LinkedHashMap[String, Object]()
+      if (o.query != null) query.putAll(o.query)
+      val specmap = new LinkedHashMap[String, Object]()
+      specmap.put("method", method); specmap.put("base", base); specmap.put("path", path)
+      specmap.put("headers", headers); specmap.put("query", query); specmap.put("step", "start")
+      ctx.spec = new Spec(specmap)
+      if (o.body != null) ctx.spec.body = o.body
+
+      utility.featureHook(ctx, "PreRequest")
+      ctx.spec.url = fhBuildUrl(ctx.spec)
+
+      val fetchdef = new LinkedHashMap[String, Object]()
+      fetchdef.put("url", ctx.spec.url); fetchdef.put("method", ctx.spec.method); fetchdef.put("headers", ctx.spec.headers)
+      if (ctx.spec.body != null) fetchdef.put("body", ctx.spec.body)
+
+      var response: Object = null
+      var fetchErr: RuntimeException = null
+      ctx.out.get("request") match {
+        case r if r != null => response = r
+        case _ =>
+          try response = utility.fetcher(ctx, ctx.spec.url, fetchdef)
+          catch { case e: RuntimeException => fetchErr = e }
+      }
+      response match { case m: JMap[_, _] => ctx.response = new Response(m.asInstanceOf[JMap[String, Object]]); case _ => }
+
+      utility.featureHook(ctx, "PreResponse")
+      fhPopulateResult(ctx, response, fetchErr)
+      utility.featureHook(ctx, "PreResult")
+      utility.featureHook(ctx, "PreDone")
+
+      if (ctx.result != null && ctx.result.ok) {
+        val out = new FhOpResult()
+        out.ok = true; out.data = ctx.result.resdata; out.result = ctx.result; out.ctx = ctx
+        return out
+      }
+      val err = if (ctx.result != null && ctx.result.err != null) ctx.result.err
+        else ctx.makeError("op_failed", "operation failed")
+      failOp(ctx, err)
+    }
+
+    def failOp(ctx: Context, err: RuntimeException): FhOpResult = {
+      ctx.ctrl.err = err
+      utility.featureHook(ctx, "PreUnexpected")
+      val out = new FhOpResult()
+      out.ok = false; out.err = err; out.result = ctx.result; out.ctx = ctx
+      out
+    }
+  }
+
+  def fhMake(server: FetcherFn, features: FhFeature*): FhHarness = {
+    val client = ProjectNameSDK.testSDK()
+    client.features = new ArrayList[Feature]()
+
+    val utility = client.getUtility()
+    var srv = server
+    if (srv == null) { val rec = new FhRecorder(); srv = (c, u, fd) => rec.fetch(c, u, fd) }
+    utility.fetcher = srv
+
+    val ctxmap = new LinkedHashMap[String, Object]()
+    ctxmap.put("client", client); ctxmap.put("utility", utility)
+    val rootctx = utility.makeContext(ctxmap, client.getRootCtx())
+
+    features.foreach { fs =>
+      val fopts = new LinkedHashMap[String, Object]()
+      fopts.put("active", B(true))
+      if (fs.options != null) fopts.putAll(fs.options)
+      fs.f.init(rootctx, fopts)
+      client.features.add(fs.f)
+    }
+
+    utility.featureHook(rootctx, "PostConstruct")
+
+    val h = new FhHarness()
+    h.client = client; h.utility = utility; h.rootctx = rootctx
+    h
+  }
+
+  def fhPopulateResult(ctx: Context, response: Object, fetchErr: RuntimeException): Unit = {
+    val result = new Result(new LinkedHashMap[String, Object]())
+    ctx.result = result
+    if (fetchErr != null) { result.err = fetchErr; return }
+    response match {
+      case m: JMap[_, _] =>
+        val resp = new Response(m.asInstanceOf[JMap[String, Object]])
+        result.status = resp.status; result.statusText = resp.statusText
+        val hm = Helpers.toMapAny(resp.headers); if (hm != null) result.headers = hm
+        if (resp.jsonFunc != null) result.body = resp.jsonFunc.get()
+        result.resdata = result.body
+        if (result.status >= 400) result.err = ctx.makeError("request_status", "request: " + result.status + ": " + result.statusText)
+        else if (resp.err != null) result.err = resp.err
+        if (result.err == null) result.ok = true
+      case _ => result.err = ctx.makeError("request_no_response", "response: undefined")
+    }
+  }
+
+  def fhErrCode(err: RuntimeException): String = err match { case e: SdkError => e.code; case _ => "" }
+
+  // ================= feature behavior tests =================================
+
+  private def testNetsim(): Unit = {
+    { val clk = new FhClock(); val f = new NetsimFeature()
+      val h = fhMake(null, fhF(f, om("latency" -> I(250), "sleep" -> f0(clk.sleepFn))))
+      val r = h.op(fhOp("load").withCtrl(om("explain" -> om())))
+      check("netsim.fixedLatency.ok", r.ok, "err=" + r.err); eqL("netsim.fixedLatency.t", 250, clk.t); eqI("netsim.fixedLatency.calls", 1, f.calls) }
+    { val clk = new FhClock(); val f = new NetsimFeature()
+      val h = fhMake(null, fhF(f, om("latency" -> om("min" -> I(50), "max" -> I(50)), "sleep" -> f0(clk.sleepFn))))
+      h.op(fhOp("load")); eqL("netsim.equalMinMax", 50, clk.t) }
+    { val f = new NetsimFeature()
+      val h = fhMake(null, fhF(f, om("failTimes" -> I(2), "failStatus" -> I(503))))
+      eqI("netsim.fail1", 503, h.op(fhOp("load")).result.status)
+      eqI("netsim.fail2", 503, h.op(fhOp("load")).result.status)
+      check("netsim.fail3ok", h.op(fhOp("load")).ok, "expected 3rd ok") }
+    { val f = new NetsimFeature()
+      val h = fhMake(null, fhF(f, om("failEvery" -> I(2))))
+      check("netsim.every1", h.op(fhOp("load")).ok, "call1"); check("netsim.every2", !h.op(fhOp("load")).ok, "call2"); check("netsim.every3", h.op(fhOp("load")).ok, "call3") }
+    { val f = new NetsimFeature()
+      val h = fhMake(null, fhF(f, om("failRate" -> I(1), "seed" -> I(5))))
+      check("netsim.failRateSeed", !h.op(fhOp("load")).ok, "expected deterministic fail") }
+    { val f = new NetsimFeature()
+      val h = fhMake(null, fhF(f, om("errorTimes" -> I(1))))
+      eq("netsim.connErr", "netsim_conn", fhErrCode(h.op(fhOp("load")).err)) }
+    { val f = new NetsimFeature()
+      val h = fhMake(null, fhF(f, om("offline" -> B(true))))
+      eq("netsim.offline", "netsim_offline", fhErrCode(h.op(fhOp("load")).err)) }
+    { val f = new NetsimFeature()
+      val h = fhMake(null, fhF(f, om("rateLimitTimes" -> I(1), "retryAfter" -> I(3))))
+      val r = h.op(fhOp("load")); eqI("netsim.429", 429, r.result.status); eq("netsim.retryAfter", "3", r.result.headers.get("retry-after")) }
+    { val f = new NetsimFeature()
+      val h = fhMake(null, fhF(f, om("active" -> B(false), "offline" -> B(true))))
+      val r = h.op(fhOp("load")); check("netsim.inactive.ok", r.ok, "err=" + r.err); eqI("netsim.inactive.calls", 0, f.calls) }
+    { val clk = new FhClock(); val f = new NetsimFeature()
+      val h = fhMake(null, fhF(f, om("latency" -> om("min" -> I(100), "max" -> I(300)), "seed" -> I(7), "sleep" -> f0(clk.sleepFn))))
+      h.op(fhOp("load")); check("netsim.ranged", clk.t >= 100 && clk.t < 300, "expected latency in [100,300), got " + clk.t) }
+  }
+
+  private def testRetry(): Unit = {
+    { val clk = new FhClock(); val rf = new RetryFeature()
+      val h = fhMake(null, fhF(new NetsimFeature(), om("failTimes" -> I(2), "failStatus" -> I(503))),
+        fhF(rf, om("retries" -> I(3), "minDelay" -> I(10), "jitter" -> B(false), "sleep" -> f0(clk.sleepFn))))
+      val r = h.op(fhOp("load")); check("retry.succeeds", r.ok, "err=" + r.err); eqI("retry.attempts", 2, rf.attempts) }
+    { val clk = new FhClock(); val rf = new RetryFeature()
+      val h = fhMake(null, fhF(new NetsimFeature(), om("failTimes" -> I(9), "failStatus" -> I(500))),
+        fhF(rf, om("retries" -> I(2), "minDelay" -> I(1), "jitter" -> B(false), "sleep" -> f0(clk.sleepFn))))
+      eqI("retry.givesUp", 500, h.op(fhOp("load")).result.status) }
+    { val rec = new FhRecorder(); rec.reply = (n, fd) => fhResponse(404, null, null)
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new RetryFeature(), om("retries" -> I(3), "minDelay" -> I(0))))
+      h.op(fhOp("load")); eqI("retry.nonRetryable", 1, rec.calls.size()) }
+    { val clk = new FhClock()
+      val h = fhMake(null, fhF(new NetsimFeature(), om("rateLimitTimes" -> I(1), "retryAfter" -> I(2))),
+        fhF(new RetryFeature(), om("retries" -> I(2), "minDelay" -> I(10), "maxDelay" -> I(60000), "jitter" -> B(false), "sleep" -> f0(clk.sleepFn))))
+      val r = h.op(fhOp("load")); check("retry.retryAfter.ok", r.ok, "err=" + r.err); eqL("retry.retryAfter.wait", 2000, clk.t) }
+    { val rec = new FhRecorder(); rec.reply = (n, fd) => fhResponse(503, null, null)
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new RetryFeature(), om("active" -> B(false))))
+      h.op(fhOp("load")); eqI("retry.inactive", 1, rec.calls.size()) }
+    { val clk = new FhClock(); val n = new Array[Int](1)
+      val srv: FetcherFn = (c, u, fd) => { n(0) += 1; throw c.makeError("boom", "boom") }
+      val h = fhMake(srv, fhF(new RetryFeature(), om("retries" -> I(2), "minDelay" -> I(1), "jitter" -> B(false), "sleep" -> f0(clk.sleepFn))))
+      val r = h.op(fhOp("load")); check("retry.transportError.fail", !r.ok, "expected failure"); eqI("retry.transportError.attempts", 3, n(0)) }
+    { val n = new Array[Int](1)
+      val srv: FetcherFn = (c, u, fd) => { n(0) += 1; if (n(0) < 2) null else fhResponse(200, om("ok" -> B(true)), null) }
+      val h = fhMake(srv, fhF(new RetryFeature(), om("retries" -> I(3), "minDelay" -> I(0))))
+      val r = h.op(fhOp("load")); check("retry.nilTransport.ok", r.ok, "err=" + r.err); eqI("retry.nilTransport.attempts", 2, n(0)) }
+  }
+
+  private def testTimeout(): Unit = {
+    { val f = new TimeoutFeature()
+      val h = fhMake((c, u, fd) => { Thread.sleep(60); fhResponse(200, om("ok" -> B(true)), null) }, fhF(f, om("ms" -> I(10))))
+      val r = h.op(fhOp("load")); eq("timeout.err", "timeout", fhErrCode(r.err)); eqI("timeout.count", 1, f.count) }
+    { val h = fhMake(null, fhF(new TimeoutFeature(), om("ms" -> I(1000))))
+      check("timeout.fast", h.op(fhOp("load")).ok, "expected ok") }
+    { val h = fhMake(null, fhF(new TimeoutFeature(), om("ms" -> I(0))))
+      check("timeout.zero", h.op(fhOp("load")).ok, "expected ok") }
+    { val h = fhMake(null, fhF(new TimeoutFeature(), om("active" -> B(false))))
+      check("timeout.inactive", h.op(fhOp("load")).ok, "expected ok") }
+  }
+
+  private def testRatelimit(): Unit = {
+    { val clk = new FhClock(); val f = new RatelimitFeature()
+      val h = fhMake(null, fhF(f, om("rate" -> I(1), "burst" -> I(2), "now" -> f0(clk.nowFn), "sleep" -> f0(clk.sleepFn))))
+      h.op(fhOp("load")); h.op(fhOp("load")); h.op(fhOp("load"))
+      eqI("ratelimit.throttled", 1, f.throttled); check("ratelimit.clockAdvanced", clk.t > 0, "clock should advance") }
+    { val clk = new FhClock(); val f = new RatelimitFeature()
+      val h = fhMake(null, fhF(f, om("rate" -> I(2), "now" -> f0(clk.nowFn), "sleep" -> f0(clk.sleepFn))))
+      h.op(fhOp("load")); h.op(fhOp("load")); clk.advance(1000); h.op(fhOp("load"))
+      eqI("ratelimit.refill", 0, f.throttled) }
+    { val f = new RatelimitFeature()
+      val h = fhMake(null, fhF(f, om("active" -> B(false))))
+      check("ratelimit.inactive.ok", h.op(fhOp("load")).ok, "expected ok"); eqI("ratelimit.inactive.throttled", 0, f.throttled) }
+  }
+
+  private def testCache(): Unit = {
+    { val rec = new FhRecorder(); val f = new CacheFeature()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(f, om("ttl" -> I(10000))))
+      val a = h.op(fhOp("load").withPath("/w/1")); val b = h.op(fhOp("load").withPath("/w/1"))
+      eqI("cache.oneCall", 1, rec.calls.size()); eqI("cache.hit", 1, f.hit) }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new CacheFeature(), null))
+      h.op(fhOp("create").withPath("/w")); h.op(fhOp("create").withPath("/w")); eqI("cache.nonGet", 2, rec.calls.size()) }
+    { val rec = new FhRecorder(); rec.reply = (n, fd) => fhResponse(500, null, null); val f = new CacheFeature()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(f, null))
+      h.op(fhOp("load").withPath("/w")); h.op(fhOp("load").withPath("/w")); eqI("cache.non2xx", 2, rec.calls.size()); eqI("cache.bypass", 2, f.bypass) }
+    { val clk = new FhClock(); val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new CacheFeature(), om("ttl" -> I(1000), "now" -> f0(clk.nowFn))))
+      h.op(fhOp("load").withPath("/w")); clk.advance(1500); h.op(fhOp("load").withPath("/w")); eqI("cache.ttl", 2, rec.calls.size()) }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new CacheFeature(), om("ttl" -> I(10000), "max" -> I(1))))
+      h.op(fhOp("load").withPath("/a")); h.op(fhOp("load").withPath("/b")); h.op(fhOp("load").withPath("/a"))
+      eqI("cache.evict", 3, rec.calls.size()) }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new CacheFeature(), om("active" -> B(false))))
+      h.op(fhOp("load").withPath("/x")); h.op(fhOp("load").withPath("/x")); eqI("cache.inactive", 2, rec.calls.size()) }
+  }
+
+  private def testIdempotency(): Unit = {
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new IdempotencyFeature(), null))
+      h.op(fhOp("create").withPath("/w")); check("idem.create", rec.headers(0).get("Idempotency-Key") != null, "expected key") }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new IdempotencyFeature(), null))
+      h.op(fhOp("load").withPath("/w/1")); check("idem.load", rec.headers(0).get("Idempotency-Key") == null, "expected none") }
+    { val rec = new FhRecorder(); val f = new IdempotencyFeature()
+      val ks: Supplier[Object] = () => "K1"
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(f, om("keygen" -> ks)))
+      h.op(fhOp("create").withPath("/w")); eq("idem.injected", "K1", rec.headers(0).get("Idempotency-Key")); eqI("idem.issued", 1, f.issued) }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new IdempotencyFeature(), null))
+      h.op(fhOp("act").withMethod("PUT").withPath("/w")); check("idem.byMethod", rec.headers(0).get("Idempotency-Key") != null, "expected key on PUT") }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new IdempotencyFeature(), om("header" -> "X-Idem")))
+      h.op(fhOp("create").withPath("/w").withHeaders(om("X-Idem" -> "caller-1"))); eq("idem.preserveCaller", "caller-1", rec.headers(0).get("X-Idem")) }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new IdempotencyFeature(), om("active" -> B(false))))
+      h.op(fhOp("create").withPath("/w")); check("idem.inactive", rec.headers(0).get("Idempotency-Key") == null, "expected no key") }
+  }
+
+  private def testRbac(): Unit = {
+    { val rec = new FhRecorder(); val f = new RbacFeature()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(f, om("rules" -> om("widget.remove" -> "admin"), "permissions" -> jl())))
+      val r = h.op(fhOp("remove").withPath("/w/1")); eq("rbac.denied", "rbac_denied", fhErrCode(r.err)); eqI("rbac.noCalls", 0, rec.calls.size()); eqI("rbac.denied.count", 1, f.denied) }
+    { val h = fhMake(null, fhF(new RbacFeature(), om("rules" -> om("widget.remove" -> "admin"), "permissions" -> jl("admin"))))
+      check("rbac.allow", h.op(fhOp("remove").withPath("/w/1")).ok, "expected allow") }
+    { val h = fhMake(null, fhF(new RbacFeature(), om("rules" -> om("load" -> "read"), "permissions" -> jl("*"))))
+      check("rbac.wildcard", h.op(fhOp("load")).ok, "expected wildcard grant") }
+    { val allow = fhMake(null, fhF(new RbacFeature(), om("permissions" -> jl())))
+      check("rbac.defaultAllow", allow.op(fhOp("load")).ok, "expected default allow")
+      val deny = fhMake(null, fhF(new RbacFeature(), om("deny" -> B(true), "permissions" -> jl())))
+      eq("rbac.defaultDeny", "rbac_denied", fhErrCode(deny.op(fhOp("load")).err)) }
+    { val h = fhMake(null, fhF(new RbacFeature(), om("active" -> B(false), "deny" -> B(true))))
+      check("rbac.inactive", h.op(fhOp("load")).ok, "inactive rbac must not deny") }
+  }
+
+  private def testMetrics(): Unit = {
+    { val f = new MetricsFeature()
+      val h = fhMake(null, fhF(new NetsimFeature(), om("failTimes" -> I(1), "failStatus" -> I(500))), fhF(f, null))
+      h.op(fhOp("load")); h.op(fhOp("load")); h.op(fhOp("list"))
+      eqI("metrics.count", 3, f.total.count); eqI("metrics.ok", 2, f.total.ok); eqI("metrics.err", 1, f.total.err)
+      check("metrics.bucket", f.ops.get("widget.load") != null, "expected widget.load bucket") }
+    { val clk = new FhClock(); val f = new MetricsFeature()
+      val h = fhMake(null, fhF(f, om("now" -> f0(clk.nowFn))))
+      h.op(fhOp("load")); eqI("metrics.injected.count", 1, f.total.count); eqL("metrics.injected.ms", 0, f.total.totalMs) }
+    { val f = new MetricsFeature()
+      val h = fhMake(null, fhF(f, om("active" -> B(false))))
+      h.op(fhOp("load")); eqI("metrics.inactive", 0, f.total.count) }
+  }
+
+  private def testTelemetry(): Unit = {
+    { val rec = new FhRecorder(); val exported = new ArrayList[JMap[String, Object]](); val f = new TelemetryFeature()
+      val exp: Consumer[JMap[String, Object]] = (m) => exported.add(m)
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(f, om("exporter" -> exp)))
+      val r = h.op(fhOp("load")); check("telemetry.ok", r.ok, "err=" + r.err); eqI("telemetry.spans", 1, f.spans.size()); eqI("telemetry.export", 1, exported.size())
+      eq("telemetry.traceId", f.spans.get(0).get("traceId"), rec.headers(0).get("X-Trace-Id"))
+      val tp = rec.headers(0).get("traceparent") match { case s: String => s; case _ => "" }
+      check("telemetry.traceparent", tp.matches("^00-.+-.+-01$"), "expected W3C traceparent, got " + tp) }
+    { val f = new TelemetryFeature()
+      val h = fhMake(null, fhF(new NetsimFeature(), om("failTimes" -> I(1), "failStatus" -> I(500))), fhF(f, null))
+      h.op(fhOp("load")); eqI("telemetry.failSpan.n", 1, f.spans.size()); eq("telemetry.failSpan.ok", B(false), f.spans.get(0).get("ok")) }
+    { val clk = new FhClock(); val f = new TelemetryFeature()
+      val idg: JFunction[String, String] = (k) => k + "-X"
+      val h = fhMake(null, fhF(f, om("idgen" -> idg, "now" -> f0(clk.nowFn))))
+      h.op(fhOp("load")); eq("telemetry.injId", "trace-X", f.spans.get(0).get("traceId")); eq("telemetry.injDur", java.lang.Long.valueOf(0L), f.spans.get(0).get("durationMs")) }
+    { val f = new TelemetryFeature()
+      val h = fhMake(null, fhF(f, om("active" -> B(false))))
+      h.op(fhOp("load")); eqI("telemetry.inactive", 0, f.spans.size()) }
+  }
+
+  private def testDebug(): Unit = {
+    { val seen = new ArrayList[JMap[String, Object]](); val f = new DebugFeature()
+      val oe: Consumer[JMap[String, Object]] = (m) => seen.add(m)
+      val h = fhMake(null, fhF(f, om("max" -> I(1), "onEntry" -> oe)))
+      h.op(fhOp("load").withHeaders(om("authorization" -> "Bearer secret"))); h.op(fhOp("list"))
+      eqI("debug.ring", 1, f.entries.size()); eqI("debug.onEntry", 2, seen.size())
+      eq("debug.redacted", "<redacted>", Helpers.toMapAny(seen.get(0).get("headers")).get("authorization")) }
+    { val f = new DebugFeature()
+      val h = fhMake(null, fhF(new NetsimFeature(), om("failTimes" -> I(1), "failStatus" -> I(500))), fhF(f, null))
+      h.op(fhOp("load")); eqI("debug.fail.n", 1, f.entries.size()); eq("debug.fail.ok", B(false), f.entries.get(0).get("ok")) }
+    { val clk = new FhClock(); val f = new DebugFeature()
+      val h = fhMake(null, fhF(f, om("now" -> f0(clk.nowFn), "redact" -> jl("x-secret"))))
+      h.op(fhOp("load").withHeaders(om("x-secret" -> "hide", "x-ok" -> "show")))
+      val dh = Helpers.toMapAny(f.entries.get(0).get("headers"))
+      eq("debug.redact.secret", "<redacted>", dh.get("x-secret")); eq("debug.redact.ok", "show", dh.get("x-ok")) }
+    { val f = new DebugFeature()
+      val h = fhMake(null, fhF(f, om("active" -> B(false))))
+      h.op(fhOp("load")); eqI("debug.inactive", 0, f.entries.size()) }
+  }
+
+  private def testAudit(): Unit = {
+    { val sunk = new ArrayList[JMap[String, Object]](); val f = new AuditFeature()
+      val sink: Consumer[JMap[String, Object]] = (m) => sunk.add(m)
+      val h = fhMake(null, fhF(new NetsimFeature(), om("failTimes" -> I(1), "failStatus" -> I(500))), fhF(f, om("actor" -> "svc", "max" -> I(5), "sink" -> sink)))
+      h.op(fhOp("remove").withPath("/w/1")); h.op(fhOp("load").withCtrl(om("actor" -> "per-call")))
+      eqI("audit.records", 2, f.records.size()); eq("audit.outcome", "error", f.records.get(0).get("outcome"))
+      eq("audit.actor", "svc", f.records.get(0).get("actor")); eq("audit.perCall", "per-call", f.records.get(1).get("actor")); eqI("audit.sunk", 2, sunk.size()) }
+    { val f = new AuditFeature()
+      val ns: LongSupplier = () => 42L
+      val h = fhMake(null, fhF(f, om("now" -> ns)))
+      h.op(fhOp("load")); eq("audit.ts", java.lang.Long.valueOf(42L), f.records.get(0).get("ts")) }
+    { val f = new AuditFeature()
+      val h = fhMake(null, fhF(f, null))
+      h.op(fhOp("load")); eq("audit.defaultActor", "anonymous", f.records.get(0).get("actor")) }
+    { val f = new AuditFeature()
+      val h = fhMake(null, fhF(f, om("active" -> B(false))))
+      h.op(fhOp("load")); eqI("audit.inactive", 0, f.records.size()) }
+  }
+
+  private def testClienttrack(): Unit = {
+    { val rec = new FhRecorder(); val f = new ClienttrackFeature()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(f, om("clientName" -> "Acme", "clientVersion" -> "2.0.0")))
+      h.op(fhOp("load")); h.op(fhOp("load"))
+      eq("clienttrack.ua", "Acme/2.0.0", rec.headers(0).get("User-Agent"))
+      eq("clienttrack.clientId", rec.headers(0).get("X-Client-Id"), rec.headers(1).get("X-Client-Id"))
+      check("clienttrack.reqId", !jeq(rec.headers(0).get("X-Request-Id"), rec.headers(1).get("X-Request-Id")), "req ids should differ") }
+    { val rec = new FhRecorder(); val idg: JFunction[String, String] = (k) => k + "-1"
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new ClienttrackFeature(), om("sessionId" -> "S1", "idgen" -> idg)))
+      h.op(fhOp("load")); eq("clienttrack.session", "S1", rec.headers(0).get("X-Client-Id")); eq("clienttrack.injReq", "request-1", rec.headers(0).get("X-Request-Id")) }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new ClienttrackFeature(), null))
+      h.op(fhOp("load").withHeaders(om("User-Agent" -> "mine"))); eq("clienttrack.noClobber", "mine", rec.headers(0).get("User-Agent")) }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new ClienttrackFeature(), om("active" -> B(false))))
+      h.op(fhOp("load")); check("clienttrack.inactive", rec.headers(0).get("X-Client-Id") == null, "inactive must not stamp") }
+  }
+
+  private def testPaging(): Unit = {
+    { val rec = new FhRecorder()
+      rec.reply = (n, fd) => fhResponse(200, om("items" -> jl(I(1), I(2))),
+        om("x-next-page" -> "2", "x-total-count" -> "5", "link" -> "</w?page=2>; rel=\"next\""))
+      val f = new PagingFeature()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(f, om("limit" -> I(2))))
+      val r = h.op(fhOp("list").withPath("/w"))
+      check("paging.page1", rec.url(0).contains("page=1"), "url=" + rec.url(0))
+      check("paging.limit2", rec.url(0).contains("limit=2"), "url=" + rec.url(0))
+      eq("paging.nextPage", I(2), r.result.paging.get("nextPage")); eq("paging.total", I(5), r.result.paging.get("totalCount")); eq("paging.next", "/w?page=2", r.result.paging.get("next")) }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new PagingFeature(), null))
+      h.op(fhOp("load").withPath("/w/1")); check("paging.nonList", !rec.url(0).contains("page="), "url=" + rec.url(0)) }
+    { val rec = new FhRecorder()
+      rec.reply = (n, fd) => fhResponse(200, om("nextCursor" -> "abc", "hasMore" -> B(true)), null)
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new PagingFeature(), null))
+      val r = h.op(fhOp("list").withPath("/w").withCtrl(om("paging" -> om("cursor" -> "xyz"))))
+      check("paging.cursorStamp", rec.url(0).contains("cursor=xyz"), "url=" + rec.url(0))
+      eq("paging.bodyCursor", "abc", r.result.paging.get("cursor")); eq("paging.hasMore", B(true), r.result.paging.get("hasMore")) }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new PagingFeature(), om("active" -> B(false))))
+      h.op(fhOp("list").withPath("/w")); check("paging.inactive", !rec.url(0).contains("page="), "url=" + rec.url(0)) }
+  }
+
+  private def testStreaming(): Unit = {
+    { val clk = new FhClock(); val rec = new FhRecorder()
+      rec.reply = (n, fd) => fhResponse(200, jl("a", "b", "c"), null)
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new StreamingFeature(), om("chunkDelay" -> I(5), "sleep" -> f0(clk.sleepFn))))
+      val r = h.op(fhOp("list").withPath("/w")); check("streaming.on", r.result.streaming, "expected streaming")
+      val seen = new ArrayList[Object](); val it = r.result.stream.get()
+      while (it.hasNext) seen.add(it.next())
+      eq("streaming.items", jl("a", "b", "c"), seen); eqL("streaming.delay", 15, clk.t) }
+    { val h = fhMake(null, fhF(new StreamingFeature(), null))
+      val r = h.op(fhOp("load")); check("streaming.nonList", !r.result.streaming, "expected no stream") }
+    { val rec = new FhRecorder()
+      rec.reply = (n, fd) => fhResponse(200, jl(I(1), I(2), I(3), I(4), I(5)), null)
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new StreamingFeature(), om("chunkSize" -> I(2))))
+      val r = h.op(fhOp("list").withPath("/w"))
+      val seen = new ArrayList[Object](); val it = r.result.stream.get()
+      while (it.hasNext) seen.add(it.next())
+      eq("streaming.batches", jl(jl(I(1), I(2)), jl(I(3), I(4)), jl(I(5))), seen) }
+    { val f = new StreamingFeature()
+      val h = fhMake(null, fhF(f, om("active" -> B(false))))
+      val r = h.op(fhOp("list").withPath("/w")); check("streaming.inactive.nostream", !r.result.streaming, "inactive must not attach"); eqI("streaming.inactive.opened", 0, f.opened) }
+  }
+
+  private def testProxy(): Unit = {
+    { val rec = new FhRecorder(); val f = new ProxyFeature()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(f, om("url" -> "http://proxy:8080")))
+      h.op(fhOp("load")); eq("proxy.route", "http://proxy:8080", rec.fetchdef(0).get("proxy")); eqI("proxy.routed", 1, f.routed) }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new ProxyFeature(), om("url" -> "http://proxy:8080", "noProxy" -> jl("api.test"))))
+      h.op(fhOp("load")); check("proxy.bypass", rec.fetchdef(0).get("proxy") == null, "expected bypass") }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new ProxyFeature(), null))
+      h.op(fhOp("load")); check("proxy.noUrl", rec.fetchdef(0).get("proxy") == null, "expected no annotation") }
+    { val rec = new FhRecorder()
+      val h = fhMake((c, u, fd) => rec.fetch(c, u, fd), fhF(new ProxyFeature(), om("active" -> B(false), "url" -> "http://proxy:8080")))
+      h.op(fhOp("load")); check("proxy.inactive", rec.fetchdef(0).get("proxy") == null, "inactive must not route") }
+  }
+
+  private def testComposition(): Unit = {
+    val nf = new NetsimFeature()
+    val h = fhMake(null, fhF(nf, om("failEvery" -> I(2))), fhF(new CacheFeature(), om("ttl" -> I(10000))))
+    val a = h.op(fhOp("load").withPath("/w")); check("composition.a", a.ok, "err=" + a.err)
+    val b = h.op(fhOp("load").withPath("/w")); check("composition.b", b.ok, "err=" + b.err)
+    eqI("composition.calls", 1, nf.calls)
+  }
+
+  // ---- pipeline / featureAdd ----------------------------------------------
+
+  private def testFeatureAdd(): Unit = {
+    val client = ProjectNameSDK.testSDK()
+    val utility = client.getUtility()
+    val ctxmap = new LinkedHashMap[String, Object]()
+    ctxmap.put("opname", "load"); ctxmap.put("client", client); ctxmap.put("utility", utility)
+    val ctx = utility.makeContext(ctxmap, client.getRootCtx())
+    client.features = new ArrayList[Feature]()
+
+    def named(n: String): BaseFeature = { val f = new BaseFeature(); f.name = n; f }
+    def names(): String = {
+      val sb = new StringBuilder()
+      var i = 0
+      while (i < client.features.size()) { if (i > 0) sb.append(","); sb.append(client.features.get(i).getName()); i += 1 }
+      sb.toString
+    }
+
+    utility.featureAdd(ctx, named("a")); utility.featureAdd(ctx, named("b"))
+    eq("featureAdd.setup", "a,b", names())
+    val before = named("z1"); before.addOpts = om("__before__" -> "b"); utility.featureAdd(ctx, before)
+    eq("featureAdd.before", "a,z1,b", names())
+    val after = named("z2"); after.addOpts = om("__after__" -> "a"); utility.featureAdd(ctx, after)
+    eq("featureAdd.after", "a,z2,z1,b", names())
+    val repl = named("z3"); repl.addOpts = om("__replace__" -> "z1"); utility.featureAdd(ctx, repl)
+    eq("featureAdd.replace", "a,z2,z3,b", names())
+    val miss = named("z4"); miss.addOpts = om("__before__" -> "missing"); utility.featureAdd(ctx, miss)
+    eq("featureAdd.fallback", "a,z2,z3,b,z4", names())
+  }
+
+  // ---- end-to-end entity CRUD through the mock transport -------------------
+
+  private def testEntityCrud(): Unit = {
+    val fixtures = om("planet" -> om(
+      "mars" -> om("id" -> "mars", "name" -> "Mars"),
+      "venus" -> om("id" -> "venus", "name" -> "Venus")))
+    val sdk = ProjectNameSDK.testSDK(om("entity" -> fixtures), null)
+
+    val planet = sdk.planet(null)
+
+    // load
+    val loaded = planet.load(om("id" -> "mars"), null)
+    val lm = Helpers.toMapAny(loaded)
+    check("e2e.load.map", lm != null, "expected map, got " + loaded)
+    if (lm != null) eq("e2e.load.name", "Mars", lm.get("name"))
+
+    // list
+    val listed = planet.list(new LinkedHashMap[String, Object](), null)
+    check("e2e.list.islist", listed.isInstanceOf[JList[_]], "expected list, got " + listed)
+
+    // create
+    val created = planet.create(om("name" -> "Neptune"), null)
+    val cm = Helpers.toMapAny(created)
+    check("e2e.create.map", cm != null, "expected map, got " + created)
+    if (cm != null) { check("e2e.create.id", cm.get("id") != null, "expected id"); eq("e2e.create.name", "Neptune", cm.get("name")) }
+
+    // update
+    val updated = planet.update(om("id" -> "venus", "name" -> "Venus2"), null)
+    val um = Helpers.toMapAny(updated)
+    check("e2e.update.map", um != null, "expected map, got " + updated)
+    if (um != null) eq("e2e.update.name", "Venus2", um.get("name"))
+
+    // remove (no throw)
+    planet.remove(om("id" -> "mars"), null)
+    pass()
+  }
+
+  // ---- feature order (PR #2) -----------------------------------------------
+
+  private def testFeatureOrder(): Unit = {
+    val client = ProjectNameSDK.testSDK()
+    val utility = client.getUtility()
+
+    def resolve(feature: Object): JMap[String, Object] = {
+      val options = om("feature" -> feature)
+      val cfg = om("options" -> new LinkedHashMap[String, Object]())
+      val ctxmap = new LinkedHashMap[String, Object]()
+      ctxmap.put("client", client); ctxmap.put("utility", utility)
+      ctxmap.put("options", options); ctxmap.put("config", cfg)
+      val ctx = utility.makeContext(ctxmap, client.getRootCtx())
+      utility.makeOptions(ctx)
+    }
+    def order(opts: JMap[String, Object]): String = {
+      Struct.getpath(opts, java.util.List.of("__derived__", "featureorder")) match {
+        case l: JList[_] =>
+          val sb = new StringBuilder(); var i = 0
+          val li = l.asInstanceOf[JList[Object]]
+          while (i < li.size()) {
+            if (i > 0) sb.append(",")
+            sb.append(li.get(i) match { case s: String => s; case _ => "" }); i += 1
+          }
+          sb.toString
+        case _ => ""
+      }
+    }
+
+    // map form -> ordered test-first (test is the base transport).
+    eq("featureOrder.mapTestFirst", "test,metrics",
+      order(resolve(om("metrics" -> om("active" -> B(true)), "test" -> om("active" -> B(true))))))
+
+    // list form -> the explicit developer-specified order is preserved.
+    val listForm = jl(om("name" -> "metrics", "active" -> B(true)),
+      om("name" -> "test", "active" -> B(true)))
+    val lo = resolve(listForm)
+    eq("featureOrder.listExplicit", "metrics,test", order(lo))
+    // The list is normalized to a map for merge/init; opts are preserved.
+    eq("featureOrder.listNormMetrics", B(true),
+      Struct.getpath(lo, java.util.List.of("feature", "metrics", "active")))
+    eq("featureOrder.listNormTest", B(true),
+      Struct.getpath(lo, java.util.List.of("feature", "test", "active")))
+
+    // map form without test -> names ordered deterministically.
+    eq("featureOrder.mapNoTest", "cache,retry",
+      order(resolve(om("retry" -> om("active" -> B(true)), "cache" -> om("active" -> B(true))))))
+  }
+
+  // ---- entity stream() through the mock transport (PR #4) ------------------
+
+  private def testEntityStream(): Unit = {
+    val fixtures = om("planet" -> om(
+      "mars" -> om("id" -> "mars", "name" -> "Mars"),
+      "venus" -> om("id" -> "venus", "name" -> "Venus")))
+
+    // Streaming active: stream("list") yields from the streaming feature's
+    // incremental iterator.
+    val sdk = ProjectNameSDK.testSDK(om("entity" -> fixtures),
+      om("feature" -> om("streaming" -> om("active" -> B(true)))))
+    val planet = sdk.planet(null)
+
+    val listed = planet.list(new LinkedHashMap[String, Object](), null)
+    val listedN = listed match { case l: JList[_] => l.size(); case _ => 0 }
+
+    val streamed = new ArrayList[Object]()
+    val it = planet.stream("list", new LinkedHashMap[String, Object](), null)
+    while (it.hasNext) streamed.add(it.next())
+    check("stream.yields", streamed.size() > 0, "expected stream to yield items")
+    eqI("stream.count", listedN, streamed.size())
+
+    // Fallback: with streaming inactive, stream still yields the materialised
+    // items.
+    val sdk2 = ProjectNameSDK.testSDK(om("entity" -> fixtures), null)
+    val planet2 = sdk2.planet(null)
+    val streamed2 = new ArrayList[Object]()
+    val it2 = planet2.stream("list", new LinkedHashMap[String, Object](), null)
+    while (it2.hasNext) streamed2.add(it2.next())
+    eqI("stream.fallback.count", listedN, streamed2.size())
+  }
+
+  // Small identity wrapper so IntConsumer/LongSupplier land in the map as-is.
+  private def f0(o: Object): Object = o
+
+  def main(args: Array[String]): Unit = {
+    val suites: Seq[(String, () => Unit)] = Seq(
+      "netsim" -> testNetsim, "retry" -> testRetry, "timeout" -> testTimeout,
+      "ratelimit" -> testRatelimit, "cache" -> testCache, "idempotency" -> testIdempotency,
+      "rbac" -> testRbac, "metrics" -> testMetrics, "telemetry" -> testTelemetry,
+      "debug" -> testDebug, "audit" -> testAudit, "clienttrack" -> testClienttrack,
+      "paging" -> testPaging, "streaming" -> testStreaming, "proxy" -> testProxy,
+      "composition" -> testComposition, "featureAdd" -> testFeatureAdd,
+      "featureOrder" -> testFeatureOrder, "entityCrud" -> testEntityCrud,
+      "entityStream" -> testEntityStream)
+
+    suites.foreach { case (name, fn) =>
+      try fn()
+      catch { case e: Throwable => fail(name, "SUITE THREW: " + e) }
+    }
+
+    val it = failures.iterator()
+    while (it.hasNext) println("FAIL " + it.next())
+    println("\nRUNTIME PASS " + npass + "  FAIL " + failures.size())
+    if (failures.size() > 0) System.exit(1)
+  }
+}