code wiki / (root) / nx_plan_svc_test.nx
`nx_plan_svc_test.nx` source

↩ module page · 237 lines · 11338 B
1// nx_plan_svc_test.nx -- gate for the production-plan facade. Drives the
2// assess verb the way an operator would -- a product concept as one argv -- and
3// proves the plan JSON names the right next gap, action, and (when legally
4// blocked) the offending ingredient. Fourth facade, same base.
5// expect_exit: 0   license_tier: ORIGINAL
6import "nx_syscalls.nx"
7import "nx_service.nx"
8import "nx_supp_ingredient.nx"
9import "nx_prodready.nx"
10import "nx_plan_svc.nx"
11
12func t_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
13func t_putn(v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64 = v; if m < 0 { m = 0 - m; sys_write(1, "-" as *u8, 1) } let t: *u8 = sys_mmap(28); var k: i64 = 0; if m == 0 { t[0] = 48 as u8; k = 1 } while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 } var i: i64 = 0; while i < k { bb[i] = t[k - 1 - i]; i = i + 1 } sys_write(1, bb, k); return 0 }
14
15func j_has(j: *NxJson, needle: *u8) -> i64 {
  var nn: i64 = 0
  while needle[nn] != (0 as u8) { nn = nn + 1 }
  if nn == 0 { return 0 }
  let b: *u8 = j.buf
  let last: i64 = j.off - nn
  var i: i64 = 0
  var found: i64 = 0
  while i <= last {
      if found == 0 {
          var m: i64 = 0
          var ok: i64 = 1
          while m < nn { if b[i + m] != needle[m] { ok = 0 } m = m + 1 }
          if ok == 1 { found = 1 }
      }
      i = i + 1
  }
  return found
33}
34
35func numstr(v: i64) -> *u8 {
  let b: *u8 = sys_mmap(24)
  var m: i64 = v
  if m < 0 { m = 0 - m }
  if m == 0 { b[0] = 48 as u8; b[1] = 0 as u8; return b }
  let t: *u8 = sys_mmap(24)
  var k: i64 = 0
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { b[i] = t[k - 1 - i]; i = i + 1 }
  b[k] = 0 as u8
  return b
47}
48
49// Full 13-token argv for assess: verb + 11 concept args.
50func mk_assess(mask: i64, market: i64, fmt: i64, retail: i64, margin: i64, servings: i64, maxu: i64, idr: i64, gmp: i64, cl: i64, coa: i64) -> *i64 {
  let av: *i64 = sys_mmap(128)
  av[0] = "nx_plan_svc" as i64
  av[1] = "assess" as i64
  av[2] = numstr(mask) as i64
  av[3] = numstr(market) as i64
  av[4] = numstr(fmt) as i64
  av[5] = numstr(retail) as i64
  av[6] = numstr(margin) as i64
  av[7] = numstr(servings) as i64
  av[8] = numstr(maxu) as i64
  av[9] = numstr(idr) as i64
  av[10] = numstr(gmp) as i64
  av[11] = numstr(cl) as i64
  av[12] = numstr(coa) as i64
  return av
66}
67
68func main() -> i64 {
  var pass: i64 = 0
  var total: i64 = 0
71
  // masks
  let mask_ready: i64 = (1 << SI_PYCNOGENOL) | (1 << SI_PANAX_GINSENG)
  let mask_drug: i64 = mask_ready | (1 << SI_OXYTOCIN)
75
  // --- T1  describe ---
  total = total + 1
  let j1: *NxJson = nx_json_new(4096)
  let av1: *i64 = sys_mmap(64)
  av1[0] = "nx_plan_svc" as i64
  av1[1] = "describe" as i64
  plan_dispatch(2, av1, j1)
  let d1: i64 = j_has(j1, "\"svc\":\"plan\"" as *u8)
  let d2: i64 = j_has(j1, "\"readiness_dimensions\":7" as *u8)
  t_puts("T1 plan describe: svc=" as *u8); t_putn(d1); t_puts(" dims7=" as *u8); t_putn(d2); t_puts(": " as *u8)
  if d1 == 1 { if d2 == 1 { pass = pass + 1; t_puts("PASS\n" as *u8) } else { t_puts("FAIL\n" as *u8) } } else { t_puts("FAIL\n" as *u8) }
87
  // --- T2  a fully-prepared powder product: PRODUCTION READY, score 1000 ---
  total = total + 1
  let j2: *NxJson = nx_json_new(4096)
  let av2: *i64 = mk_assess(mask_ready, 0, 2, 3999, 700, 30, 2, 1, 1, 1, 1)
  plan_dispatch(13, av2, j2)
  let ready: i64 = j_has(j2, "\"production_ready\":true" as *u8)
  let score: i64 = j_has(j2, "\"readiness_permil\":1000" as *u8)
  let nogap: i64 = j_has(j2, "\"next_gap\":-1" as *u8)
  t_puts("T2 prepared powder: ready=" as *u8); t_putn(ready); t_puts(" score1000=" as *u8); t_putn(score); t_puts(" nogap=" as *u8); t_putn(nogap); t_puts(": " as *u8)
  var ok2: i64 = 1
  if ready != 1 { ok2 = 0 }
  if score != 1 { ok2 = 0 }
  if nogap != 1 { ok2 = 0 }
  if ok2 == 1 { pass = pass + 1; t_puts("PASS\n" as *u8) } else { t_puts("FAIL\n" as *u8) }
102
  // --- T3  THE KILL-ORDER PLAN: a drug ingredient blocks at LEGAL and the
  //         plan NAMES the offender + the action ---
  total = total + 1
  let j3: *NxJson = nx_json_new(4096)
  let av3: *i64 = mk_assess(mask_drug, 0, 2, 3999, 700, 30, 2, 1, 1, 1, 1)
  plan_dispatch(13, av3, j3)
  let gap0: i64 = j_has(j3, "\"next_gap\":0" as *u8)
  let named: i64 = j_has(j3, "\"unlawful_ingredient\":\"Oxytocin\"" as *u8)
  let action: i64 = j_has(j3, "remove the unlawful ingredient" as *u8)
  let notready: i64 = j_has(j3, "\"production_ready\":false" as *u8)
  t_puts("T3 +oxytocin plan: gap0=" as *u8); t_putn(gap0); t_puts(" names-oxytocin=" as *u8); t_putn(named); t_puts(" action=" as *u8); t_putn(action); t_puts(" not-ready=" as *u8); t_putn(notready); t_puts(": " as *u8)
  var ok3: i64 = 1
  if gap0 != 1 { ok3 = 0 }
  if named != 1 { ok3 = 0 }
  if action != 1 { ok3 = 0 }
  if notready != 1 { ok3 = 0 }
  if ok3 == 1 { pass = pass + 1; t_puts("PASS\n" as *u8) } else { t_puts("FAIL\n" as *u8) }
120
  // --- T4  the reference stack in CAPSULES blocks at FORMAT with the
  //         switch-to-powder action ---
  total = total + 1
  let mask_full: i64 = (1 << SI_L_CITRULLINE) | (1 << SI_PYCNOGENOL) | (1 << SI_ASHWAGANDHA) | (1 << SI_MACA) | (1 << SI_TRIBULUS) | (1 << SI_PANAX_GINSENG) | (1 << SI_GINKGO)
  let j4: *NxJson = nx_json_new(4096)
  let av4: *i64 = mk_assess(mask_full, 0, 1, 3999, 700, 30, 2, 1, 1, 1, 1)
  plan_dispatch(13, av4, j4)
  let gap1: i64 = j_has(j4, "\"next_gap\":1" as *u8)
  let powder_action: i64 = j_has(j4, "switch to powder" as *u8)
  t_puts("T4 full stack in capsules: FORMAT gap=" as *u8); t_putn(gap1); t_puts(" powder-action=" as *u8); t_putn(powder_action); t_puts(": " as *u8)
  if gap1 == 1 { if powder_action == 1 { pass = pass + 1; t_puts("PASS\n" as *u8) } else { t_puts("FAIL\n" as *u8) } } else { t_puts("FAIL\n" as *u8) }
132
  // --- T5  same full stack as POWDER at a margin it actually clears (600,
  //         since the 7-ingredient powder makes ~666): format+economics pass,
  //         so the gap correctly moves to the first open attestation, IDENTITY.
  //         (At a 700 target it would block at ECONOMICS -- the engine is right,
  //         the 7-stack is a low-margin product.) ---
  total = total + 1
  let j5: *NxJson = nx_json_new(4096)
  let av5: *i64 = mk_assess(mask_full, 0, 2, 3999, 600, 30, 2, 0, 0, 0, 0)
  plan_dispatch(13, av5, j5)
  let gap3: i64 = j_has(j5, "\"next_gap\":3" as *u8)
  let id_action: i64 = j_has(j5, "identity testing" as *u8)
  let attest4: i64 = j_has(j5, "\"open_attestations\":4" as *u8)
  let noblock: i64 = j_has(j5, "\"open_computed_blockers\":0" as *u8)
  t_puts("T5 full powder, no attestations: gap3=" as *u8); t_putn(gap3); t_puts(" id-action=" as *u8); t_putn(id_action); t_puts(" 4-attest=" as *u8); t_putn(attest4); t_puts(" 0-blockers=" as *u8); t_putn(noblock); t_puts(": " as *u8)
  var ok5: i64 = 1
  if gap3 != 1 { ok5 = 0 }
  if id_action != 1 { ok5 = 0 }
  if attest4 != 1 { ok5 = 0 }
  if noblock != 1 { ok5 = 0 }
  if ok5 == 1 { pass = pass + 1; t_puts("PASS\n" as *u8) } else { t_puts("FAIL\n" as *u8) }
153
  // --- T6  ECONOMICS gap: a too-low price blocks at dimension 2 ---
  total = total + 1
  let j6: *NxJson = nx_json_new(4096)
  let av6: *i64 = mk_assess(mask_ready, 0, 2, 300, 700, 30, 2, 1, 1, 1, 1)
  plan_dispatch(13, av6, j6)
  let gap2: i64 = j_has(j6, "\"next_gap\":2" as *u8)
  let econ_action: i64 = j_has(j6, "raise price" as *u8)
  t_puts("T6 $3.00 retail: ECONOMICS gap=" as *u8); t_putn(gap2); t_puts(" action=" as *u8); t_putn(econ_action); t_puts(": " as *u8)
  if gap2 == 1 { if econ_action == 1 { pass = pass + 1; t_puts("PASS\n" as *u8) } else { t_puts("FAIL\n" as *u8) } } else { t_puts("FAIL\n" as *u8) }
163
  // --- T7  empty mask is a structured 400 ---
  total = total + 1
  let j7: *NxJson = nx_json_new(4096)
  let av7: *i64 = mk_assess(0, 0, 2, 3999, 700, 30, 2, 1, 1, 1, 1)
  plan_dispatch(13, av7, j7)
  let e400: i64 = j_has(j7, "\"status\":400" as *u8)
  t_puts("T7 empty mask -> 400=" as *u8); t_putn(e400); t_puts(": " as *u8)
  if e400 == 1 { pass = pass + 1; t_puts("PASS\n" as *u8) } else { t_puts("FAIL\n" as *u8) }
172
  // --- T8  BELARUS/EAEU: same lawful stack, ready given attestations ---
  total = total + 1
  let j8: *NxJson = nx_json_new(4096)
  let av8: *i64 = mk_assess(mask_ready, 1, 2, 3999, 700, 30, 2, 1, 1, 1, 1)
  plan_dispatch(13, av8, j8)
  let eaeu_ready: i64 = j_has(j8, "\"production_ready\":true" as *u8)
  t_puts("T8 EAEU/Belarus prepared: ready=" as *u8); t_putn(eaeu_ready); t_puts(": " as *u8)
  if eaeu_ready == 1 { pass = pass + 1; t_puts("PASS\n" as *u8) } else { t_puts("FAIL\n" as *u8) }
181
  // --- T9  unknown verb -> 404 + nonzero exit ---
  total = total + 1
  let j9: *NxJson = nx_json_new(4096)
  let av9: *i64 = sys_mmap(64)
  av9[0] = "nx_plan_svc" as i64
  av9[1] = "bogus" as i64
  let rc9: i64 = plan_dispatch(2, av9, j9)
  let e404: i64 = j_has(j9, "\"status\":404" as *u8)
  t_puts("T9 unknown verb rc=" as *u8); t_putn(rc9); t_puts(" 404=" as *u8); t_putn(e404); t_puts(": " as *u8)
  if rc9 != 0 { if e404 == 1 { pass = pass + 1; t_puts("PASS\n" as *u8) } else { t_puts("FAIL\n" as *u8) } } else { t_puts("FAIL\n" as *u8) }
192
  // --- T10  WORKFLOW: the readiness score climbs monotonically as each
  //          attestation is closed -- a progress bar toward market ---
  total = total + 1
  var flags: i64 = 0
  var prev: i64 = 0 - 1
  var ok10: i64 = 1
  var step: i64 = 0
  while step <= 4 {
      let idr: i64 = 0
      let gmp: i64 = 0
      let cl: i64 = 0
      let coa: i64 = 0
      var a: i64 = 0
      var b: i64 = 0
      var c: i64 = 0
      var d: i64 = 0
      if step >= 1 { a = 1 }
      if step >= 2 { b = 1 }
      if step >= 3 { c = 1 }
      if step >= 4 { d = 1 }
      let jx: *NxJson = nx_json_new(4096)
      let avx: *i64 = mk_assess(mask_ready, 0, 2, 3999, 700, 30, 2, a, b, c, d)
      plan_dispatch(13, avx, jx)
      // read readiness by counting: 3 computed always pass here, +step attestations
      let want: i64 = (3 + step) * 1000 / 7
      let wbuf: *u8 = numstr(want)
      let key: *u8 = sys_mmap(64)
      var ki: i64 = 0
      let pfx: *u8 = "\"readiness_permil\":" as *u8
      while pfx[ki] != (0 as u8) { key[ki] = pfx[ki]; ki = ki + 1 }
      var wi: i64 = 0
      while wbuf[wi] != (0 as u8) { key[ki] = wbuf[wi]; ki = ki + 1; wi = wi + 1 }
      key[ki] = 0 as u8
      if j_has(jx, key) != 1 { ok10 = 0 }
      if want < prev { ok10 = 0 }
      prev = want
      step = step + 1
  }
  t_puts("T10 readiness climbs monotonically as attestations close: " as *u8)
  if ok10 == 1 { pass = pass + 1; t_puts("PASS\n" as *u8) } else { t_puts("FAIL\n" as *u8) }
233
  t_puts("PLAN-SVC-GATE passed " as *u8); t_putn(pass); t_puts("/" as *u8); t_putn(total)
  if pass == total { t_puts(" verdict=GREEN\n" as *u8); sys_exit(0); return 0 }
  t_puts(" verdict=RED\n" as *u8); sys_exit(1); return 1
237}
nx_plan_svc_test.nx source

`nx_plan_svc_test.nx` source
