nx_game_page_sink_gate_t221.nx source
↩ module page · 93 lines · 6295 B
1// ORIGINAL proprietary. In-bounds primitive tests only; no old-writer capacity reproduction.
2import "nx_game_page_sink_t221.nx"
3import "nx_game_page_material_schema_candidate_t181.nx"
4import "nx_gate_verdict.nx"
5func psg_same(s:*GpeSink,text:*u8,n:i64)->i64{
6 if s.error!=0||s.bytes.len!=n{return 0}
7 var i:i64=0;while i<n{if s.bytes.buf[i]!=text[i]{return 0};i=i+1};return 1
8}
9func psg_drop(s:*GpeSink,c:*i64)->i64{
10 return gv_check("owned sink descriptor and storage cleanup",gpe_sink_destroy(s)==0,c)
11}
12func psg_dump(s:*GpeSink,label:*u8,expected:i64)->i64{
13 gv_puts(label);gv_puts("\n");gv_kv("error",s.error);gv_kv("length",s.bytes.len)
14 var n:i64=s.bytes.len;if n>expected{n=expected};var i:i64=0
15 while i<n{gv_num(s.bytes.buf[i] as i64);gv_puts(" ");i=i+1};gv_puts("\n");return 0
16}
17func psg_format(c:*i64)->i64{
18 let s:*GpeSink=gpe_sink_new(0);if (s as i64)<=0{return 3}
19 gv_check("new sink has empty owned storage",s.error==0&&nx_bo_state(s.bytes)==0&&s.bytes.cap==0&&s.bytes.len==0,c)
20 gpe_sink_text(s,"Hello",6);gpe_sink_byte(s,32);gpe_sink_span(s,"world",5);gpe_sink_byte(s,10)
21 psg_dump(s,"text-byte-observation",12)
22 gv_check("text span and byte exact output",psg_same(s,"Hello world\n",12)==1,c)
23 gv_check("release clears storage",gpe_sink_release(s)==0&&s.bytes.buf==(0 as *u8)&&s.bytes.len==0&&s.bytes.cap==0,c)
24 gv_check("release is repeatable",gpe_sink_release(s)==0,c)
25 gpe_sink_num(s,0);gpe_sink_byte(s,124);gpe_sink_num(s,-42);gpe_sink_byte(s,124)
26 gpe_sink_num(s,NX_BO_I64_MAX);gpe_sink_byte(s,124);gpe_sink_num(s,GPE_SINK_I64_MIN)
27 let numbers:*u8="0|-42|9223372036854775807|-9223372036854775808"
28 psg_dump(s,"integer-observation",rk_slen(numbers))
29 gv_check("integer extrema preserve exact decimal bytes",psg_same(s,numbers,rk_slen(numbers))==1,c)
30 gpe_sink_release(s)
31 let js:*u8="A\"\\\n\rZ"
32 let expected:*u8="\"A\\\"\\\\\\nZ\""
33 gpe_sink_js(s,js,rk_slen(js))
34 gv_check("JS compatibility escaping exact bytes",psg_same(s,expected,rk_slen(expected))==1&&s.scratch_cap==0,c)
35 gpe_sink_release(s);gpe_sink_js(s,"",0)
36 gv_check("empty JS string retains quotes",psg_same(s,"\"\"",2)==1,c)
37 psg_drop(s,c);return 0
38}
39func psg_base64(c:*i64)->i64{
40 let s:*GpeSink=gpe_sink_new(0);if (s as i64)<=0{return 3}
41 gpe_sink_base64(s,"",0);gv_check("empty base64",psg_same(s,"",0)==1,c)
42 gpe_sink_base64(s,"f",1);gv_check("base64 one byte",psg_same(s,"Zg==",4)==1&&s.scratch_cap==0,c)
43 gpe_sink_release(s);gpe_sink_base64(s,"fo",2);gv_check("base64 two bytes",psg_same(s,"Zm8=",4)==1,c)
44 gpe_sink_release(s);gpe_sink_base64(s,"foo",3);gv_check("base64 full quantum",psg_same(s,"Zm9v",4)==1,c)
45 gpe_sink_release(s);gpe_sink_base64(s,"foob",4);gv_check("base64 multiple quanta",psg_same(s,"Zm9vYg==",8)==1,c)
46 let largest_input:i64=(NX_BO_I64_MAX/GPE_SINK_BASE64_OUTPUT_QUANTUM)*GPE_SINK_BASE64_INPUT_QUANTUM
47 gv_check("encoded length largest representable boundary",gpe_sink_base64_size(largest_input)==(NX_BO_I64_MAX/GPE_SINK_BASE64_OUTPUT_QUANTUM)*GPE_SINK_BASE64_OUTPUT_QUANTUM,c)
48 gv_check("encoded length arithmetic refusal without memory access",gpe_sink_base64_size(largest_input+1)==NX_BO_RANGE&&gpe_sink_base64_size(NX_BO_I64_MAX)==NX_BO_RANGE,c)
49 gv_check("negative encoded length refused",gpe_sink_base64_size(-1)==NX_BO_INVALID,c)
50 psg_drop(s,c);return 0
51}
52func psg_refusal(c:*i64)->i64{
53 let s:*GpeSink=gpe_sink_new(4);if (s as i64)<=0{return 3}
54 gpe_sink_span(s,"abc",3);let before:*u8=s.bytes.buf
55 gv_check("capacity refusal precedes scratch allocation",gpe_sink_js(s,"Z",1)==NX_BO_CAPACITY&&s.scratch_cap==0&&s.bytes.buf==before&&s.bytes.len==3,c)
56 gv_check("error stays latched across later append",gpe_sink_byte(s,81)==NX_BO_CAPACITY&&s.bytes.len==3&&s.bytes.buf[0]==(97 as u8)&&s.bytes.buf[2]==(99 as u8),c)
57 gv_check("refused sink remains releasable",gpe_sink_release(s)==0&&s.bytes.cap==0&&s.error==NX_BO_CAPACITY,c)
58 psg_drop(s,c)
59 let a:*GpeSink=gpe_sink_new(0);if (a as i64)<=0{return 3}
60 gpe_sink_span(a,"abc",3);let original:*u8=a.bytes.buf
61 gv_check("valid owned source alias refused unchanged",gpe_sink_span(a,original,2)==NX_BO_ALIAS&&a.bytes.buf==original&&a.bytes.len==3&&a.bytes.buf[0]==(97 as u8),c)
62 psg_drop(a,c)
63 let d:*GpeSink=gpe_sink_new(0);if (d as i64)<=0{return 3}
64 gv_check("valid descriptor source span refused",gpe_sink_span(d,d as *u8,1)==NX_BO_ALIAS&&d.bytes.len==0,c)
65 psg_drop(d,c)
66 let t:*GpeSink=gpe_sink_new(0);if (t as i64)<=0{return 3}
67 gv_check("bounded text requires a terminator inside declared bytes",gpe_sink_text(t,"four",4)==NX_BO_INVALID&&t.bytes.len==0,c)
68 psg_drop(t,c);return 0
69}
70func psg_growth(c:*i64)->i64{
71 // Derived from the reviewed old output allocation solely as a regression test size.
72 let count:i64=GPE_OUT_CAP+1
73 let source:*u8=sys_mmap_try(count);if (source as i64)<=0{return 3}
74 var i:i64=0;while i<count{source[i]=(i%251) as u8;i=i+1}
75 let s:*GpeSink=gpe_sink_new(0)
76 if (s as i64)<=0{sys_munmap_direct(source,count);return 3}
77 gpe_sink_span(s,"nx|",3);let initial:*u8=s.bytes.buf
78 let wrote:i64=gpe_sink_span(s,source,count)
79 var same:i64=1;i=0
80 if wrote==count+3{while i<count{if s.bytes.buf[i+3]!=source[i]{same=0};i=i+1}}else{same=0}
81 gv_check("real owned growth exceeds prior page capacity",wrote==count+3&&s.bytes.cap>GPE_OUT_CAP&&s.bytes.buf!=initial&&nx_bo_state(s.bytes)==0,c)
82 gv_check("growth retains prefix and every payload byte",same==1&&s.bytes.buf[0]==(110 as u8)&&s.bytes.buf[1]==(120 as u8)&&s.bytes.buf[2]==(124 as u8),c)
83 gv_kv("previous_page_capacity",GPE_OUT_CAP);gv_kv("source_bytes",count);gv_kv("grown_output_bytes",s.bytes.len);gv_kv("grown_output_capacity",s.bytes.cap)
84 gv_check("source mapping released",sys_munmap_direct(source,count)==0,c)
85 gv_check("large owned storage releases and can be reused",gpe_sink_release(s)==0&&gpe_sink_byte(s,65)==1&&psg_same(s,"A",1)==1,c)
86 psg_dump(s,"reuse-observation",1)
87 psg_drop(s,c);return 0
88}
89func main(argc:i64,argv:*i64)->i64{
90 let c:*i64=gv_ctr();gv_head("GAME-PAGE-OWNED-SINK primitive qualification")
91 if psg_format(c)!=0{return 3};if psg_base64(c)!=0{return 3};if psg_refusal(c)!=0{return 3};if psg_growth(c)!=0{return 3}
92 return gv_verdict("GAME-PAGE-OWNED-SINK",c,"Private primitive dependency only; template, direct writes, callers and served UI remain unmigrated. Design: knowledge/gates/page-owned-sink-design-t221.md")
93}