code wiki / _hdl_build / nx_gatelib_test.nx
`nx_gatelib_test.nx` source

↩ module page · 170 lines · 9270 B
1// nx_gatelib_test.nx -- the gate the extracted library needed immediately.
2//
3// ★DE-DUPLICATING CREATED A NEW UNGATED LOAD-BEARING ORGAN.  Folding nine
4// duplicated functions into one library gave that library two consumers and
5// no test of its own -- precisely the class the consumers exist to find.  A
6// refactor that removes duplication while adding unverified code has moved
7// the debt, not paid it.
8//
9// ⚠AND MY OWN SCANNER DID NOT SURFACE IT.  With two consumers the library
10// scores severity 2, which ranks BELOW the fixed floor of 3 given to organs
11// nothing calls at all, so it sat under 5020 dead files in the ranking. A
12// load-bearing organ with two consumers matters MORE than a dead one with
13// none, and the ranking said the opposite. Filed against nx_gatescan and
14// noted here because the tool found nothing while the defect was real.
15//
16// This gate calls the library DIRECTLY.  The two consumer gates keep their
17// own independent re-derivations of the same rules, and that is deliberate:
18// a direct unit test proves the library does what it says, while a separate
19// implementation agreeing proves the rule itself is right. They answer
20// different questions and neither replaces the other.
21// expect_exit: 0   license_tier: ORIGINAL
22import "nx_syscalls.nx"
23import "nx_gatelib.nx"
24import "nx_gate.nx"
25
26func tw(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
27func tn(v: i64) -> i64 { let b: *u8 = sys_mmap(24); var m: i64 = v; if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m } let t: *u8 = sys_mmap(24); 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 { b[i] = t[k - 1 - i]; i = i + 1 } sys_write(1, b, k); return 0 }
28
29func main() -> i64 {
  var pass: i64 = 0
  var total: i64 = 0
32
  // --- T1  The .nx and gate-name predicates, both directions.  These
  //         decide which files are organs at all, so a wrong answer here
  //         shifts every downstream count. ---
  total = total + 1
  var ok1: i64 = 1
  if gl_is_nx("nx_foo.nx" as *u8, 9) != 1 { ok1 = 0 }
  if gl_is_nx("nx_foo.txt" as *u8, 10) != 0 { ok1 = 0 }
  if gl_is_nx("nx" as *u8, 2) != 0 { ok1 = 0 }
  if gl_is_gate_name("nx_foo_test.nx" as *u8, 14) != 1 { ok1 = 0 }
  if gl_is_gate_name("nx_foo_gate.nx" as *u8, 14) != 1 { ok1 = 0 }
  if gl_is_gate_name("nx_foo.nx" as *u8, 9) != 0 { ok1 = 0 }
  tw("T1 .nx and gate-name predicates correct in both directions: " as *u8)
  if ok1 == 1 { pass = pass + 1; tw("PASS\n" as *u8) } else { tw("FAIL\n" as *u8) }
46
  // --- T2  gl_ends must not read before the start of a string when the
  //         suffix is longer than the name.  An out-of-bounds compare here
  //         would be a silent memory read, not a wrong answer. ---
  total = total + 1
  var ok2: i64 = 1
  if gl_ends("a.nx" as *u8, 4, "_test.nx" as *u8) != 0 { ok2 = 0 }
  if gl_ends("" as *u8, 0, "_test.nx" as *u8) != 0 { ok2 = 0 }
  if gl_ends("nx_x_test.nx" as *u8, 12, "_test.nx" as *u8) != 1 { ok2 = 0 }
  tw("T2 ends-with refuses a suffix longer than the name (no under-read): " as *u8)
  if ok2 == 1 { pass = pass + 1; tw("PASS\n" as *u8) } else { tw("FAIL\n" as *u8) }
57
  // --- T3  ***THE ATTRIBUTION RULE -- the reason this library exists.***
  //         Both tools must agree on it, and the underscore is the whole
  //         rule: it credits the aspect-named gate to its organ while
  //         refusing to credit a different organ with a shorter name. ---
  total = total + 1
  let g: *EcoGraph = eg_new(64, 128, 8192, 256)
  let sha: i64 = eg_intern(g, "nx_sha256.nx" as *u8, 12)
  let str: i64 = eg_intern(g, "nx_str.nx" as *u8, 9)
  eg_intern(g, "nx_strategy.nx" as *u8, 14)
  eg_finalize(g)
  let buf: *u8 = sys_mmap(512)
  let a1: i64 = gl_attribute(g, "nx_sha256_kat_test.nx" as *u8, 21, buf)
  let a2: i64 = gl_attribute(g, "nx_strategy_test.nx" as *u8, 19, buf)
  let a3: i64 = gl_attribute(g, "nx_sha256_test.nx" as *u8, 17, buf)
  tw("T3 aspect gate -> organ=" as *u8); tn(a1); tw(" (want " as *u8); tn(sha)
  tw("), nx_strategy_test -> " as *u8); tn(a2); tw(" (must NOT be nx_str=" as *u8); tn(str)
  tw("), exact gate -> " as *u8); tn(a3); tw(": " as *u8)
  var ok3: i64 = 1
  if a1 != sha { ok3 = 0 }
  if a2 == str { ok3 = 0 }
  if a3 != sha { ok3 = 0 }
  if ok3 == 1 { pass = pass + 1; tw("PASS\n" as *u8) } else { tw("FAIL\n" as *u8) }
80
  // --- T4  Attribution refuses a non-gate outright, rather than guessing
  //         at an organ from a file that is not a gate at all. ---
  total = total + 1
  var ok4: i64 = 1
  if gl_attribute(g, "nx_sha256.nx" as *u8, 12, buf) != 0 - 1 { ok4 = 0 }
  if gl_attribute(g, "_test.nx" as *u8, 8, buf) != 0 - 1 { ok4 = 0 }
  tw("T4 a non-gate file attributes to nothing: " as *u8)
  if ok4 == 1 { pass = pass + 1; tw("PASS\n" as *u8) } else { tw("FAIL\n" as *u8) }
89
  // --- T5  Token matching, both over-report directions.  A longer name
  //         must not cover a shorter one and a prefix must not cover a
  //         suffix -- each is a separate way to report false coverage. ---
  total = total + 1
  var ok5: i64 = 1
  if gl_has_token("call si_class_of(1)" as *u8, 19, "si_class" as *u8, 8) != 0 { ok5 = 0 }
  if gl_has_token("call xsi_class(1)" as *u8, 17, "si_class" as *u8, 8) != 0 { ok5 = 0 }
  if gl_has_token("call si_class(1)" as *u8, 16, "si_class" as *u8, 8) != 1 { ok5 = 0 }
  if gl_has_token("si_class" as *u8, 8, "si_class" as *u8, 8) != 1 { ok5 = 0 }
  if gl_has_token("anything" as *u8, 8, "" as *u8, 0) != 0 { ok5 = 0 }
  tw("T5 token match: exact hits, longer/prefixed names and empty needle all refused: " as *u8)
  if ok5 == 1 { pass = pass + 1; tw("PASS\n" as *u8) } else { tw("FAIL\n" as *u8) }
102
  // --- T6  ***THE WALK'S TWO MODES ARE INDEPENDENT.***  The library folds
  //         edge-building and path-recording into one traversal so callers
  //         need only one; each mode must work with the other switched
  //         off, or a caller pays for work it did not ask for -- or worse,
  //         silently gets nothing. Run over this tree's own directory. ---
  total = total + 1
  let g2: *EcoGraph = eg_new(24000, 300000, 4194304, 65536)
  let path: *u8 = sys_mmap(4096)
  let fb: *u8 = sys_mmap(GL_FILECAP)
  let ao: *i64 = sys_mmap(1024 * 8) as *i64
  let al: *i64 = sys_mmap(1024 * 8) as *i64
  let st: *i64 = sys_mmap(16)
  st[0] = 0
  var rn: i64 = 0
  let root: *u8 = "runtime/_hdl_build" as *u8
  while root[rn] != (0 as u8) { path[rn] = root[rn]; rn = rn + 1 }
  gl_walk(g2, path, rn, fb, ao, al, st, 1, 0 as *u8, 0 as *i64, 0 as *i64, 0)
  eg_finalize(g2)
  tw("T6 edges-only walk: files=" as *u8); tn(st[0])
  tw(" nodes=" as *u8); tn(g2.node_count); tw(" edges=" as *u8); tn(g2.edge_count); tw(": " as *u8)
  var ok6: i64 = 1
  if st[0] <= 0 { ok6 = 0 }
  if g2.node_count <= 0 { ok6 = 0 }
  if g2.edge_count <= 0 { ok6 = 0 }
  if ok6 == 1 { pass = pass + 1; tw("PASS\n" as *u8) } else { tw("FAIL\n" as *u8) }
128
  // --- T7  Paths-only mode records a location for every file it counts,
  //         and builds NO edges.  If it built edges anyway the caller
  //         would pay a full file read per node for nothing. ---
  total = total + 1
  let g3: *EcoGraph = eg_new(24000, 8, 4194304, 65536)
  let arena: *u8 = sys_mmap(4194304)
  let poff: *i64 = sys_mmap(24000 * 8) as *i64
  let used: *i64 = sys_mmap(16)
  let st3: *i64 = sys_mmap(16)
  used[0] = 0
  st3[0] = 0
  var z: i64 = 0
  while z < 24000 { poff[z] = 0; z = z + 1 }
  var rn3: i64 = 0
  while root[rn3] != (0 as u8) { path[rn3] = root[rn3]; rn3 = rn3 + 1 }
  gl_walk(g3, path, rn3, 0 as *u8, 0 as *i64, 0 as *i64, st3, 0, arena, poff, used, 4194304)
  var withpath: i64 = 0
  var q: i64 = 0
  while q < g3.node_count { if poff[q] > 0 { withpath = withpath + 1 } q = q + 1 }
  tw("T7 paths-only walk: files=" as *u8); tn(st3[0])
  tw(" nodes-with-path=" as *u8); tn(withpath)
  tw(" edges=" as *u8); tn(g3.edge_count); tw(" (want 0 edges): " as *u8)
  var ok7: i64 = 1
  if st3[0] <= 0 { ok7 = 0 }
  if withpath != g3.node_count { ok7 = 0 }
  if g3.edge_count != 0 { ok7 = 0 }
  if ok7 == 1 { pass = pass + 1; tw("PASS\n" as *u8) } else { tw("FAIL\n" as *u8) }
156
  // --- T8  ***THE TWO MODES SEE THE SAME TREE.***  Both walks over the
  //         same directory must find the same number of .nx files. If they
  //         disagreed, the two tools built on them would silently be
  //         measuring different populations -- which is exactly the drift
  //         that having two copies of the walk invited. ---
  total = total + 1
  tw("T8 edges-mode files=" as *u8); tn(st[0])
  tw(" vs paths-mode files=" as *u8); tn(st3[0]); tw(": " as *u8)
  if st[0] == st3[0] { pass = pass + 1; tw("PASS\n" as *u8) } else { tw("FAIL\n" as *u8) }
166
  tw("GATELIB-GATE passed " as *u8); tn(pass); tw("/" as *u8); tn(total)
  if pass == total { tw(" verdict=GREEN\n" as *u8); sys_exit(0); return 0 }
  tw(" verdict=RED\n" as *u8); sys_exit(1); return 1
170}
nx_gatelib_test.nx source

`nx_gatelib_test.nx` source
