nx_mycorrhiza_test.nx source
↩ module page · 116 lines · 6580 B
1// nx_mycorrhiza_test.nx -- smoke for nx_mycorrhiza.
2
3import "nx_syscalls.nx"
4import "nx_mycorrhiza.nx"
5
6func main() -> i64 {
7 let now: nx_size = 1000000
8
9 // 1: enum validity
10 if nx_my_kind_is_valid(NX_MY_KIND_RAM_BYTES) != 1 { return 1 }
11 if nx_my_kind_is_valid(NX_MY_KIND_COMPUTED_VALUE) != 1 { return 2 }
12 if nx_my_kind_is_valid(-1) != 0 { return 3 }
13 if nx_my_kind_is_valid(7) != 0 { return 4 }
14 if NX_MY_KIND_N != 7 { return 5 }
15
16 if nx_my_dir_is_valid(NX_MY_DIR_NATIVE_TO_FOREIGN) != 1 { return 6 }
17 if nx_my_dir_is_valid(NX_MY_DIR_FOREIGN_TO_NATIVE) != 1 { return 7 }
18 if nx_my_dir_is_valid(-1) != 0 { return 8 }
19 if nx_my_dir_is_valid(2) != 0 { return 9 }
20
21 if nx_my_v_is_valid(NX_MY_V_OK_BALANCED) != 1 { return 10 }
22 if nx_my_v_is_valid(NX_MY_V_EXTRACTION_BY_NATIVE) != 1 { return 11 }
23
24 // 2: construction
25 let m: *NxMycorrhiza = nx_my_new(1, 100, 200, 32, 2048, now) // 2x tolerance
26 if m.partnership_id != 1 { return 12 }
27 if m.native_cell_id != 100 { return 13 }
28 if m.foreign_symbiote_id != 200 { return 14 }
29 if m.capacity != 32 { return 15 }
30 if m.severed != 0 { return 16 }
31 if m.tolerance_q10 != 2048 { return 17 }
32 if m.n_flows != 0 { return 18 }
33
34 // 3: invalid construction
35 if nx_my_new(1, 100, 200, 0, 1024, now) != (0 as *NxMycorrhiza) { return 19 }
36 if nx_my_new(1, 100, 200, 32, 0, now) != (0 as *NxMycorrhiza) { return 20 }
37 if nx_my_new(1, 0, 200, 32, 1024, now) != (0 as *NxMycorrhiza) { return 21 }
38 if nx_my_new(1, 100, 0, 32, 1024, now) != (0 as *NxMycorrhiza) { return 22 }
39
40 // 4: no flows yet -> balanced
41 if nx_my_audit_kind(m, NX_MY_KIND_RAM_BYTES) != NX_MY_V_OK_BALANCED { return 23 }
42 if nx_my_flow_count(m) != 0 { return 24 }
43
44 // 5: record balanced flows -- native gives 1000 RAM, foreign gives 1000 RAM back
45 if nx_my_record_flow(m, NX_MY_KIND_RAM_BYTES, NX_MY_DIR_NATIVE_TO_FOREIGN, 1000, 1, 0xCAFE, now) != NX_MY_V_OK_BALANCED { return 25 }
46 if nx_my_record_flow(m, NX_MY_KIND_RAM_BYTES, NX_MY_DIR_FOREIGN_TO_NATIVE, 1000, 1, 0xBEEF, now) != NX_MY_V_OK_BALANCED { return 26 }
47 if nx_my_audit_kind(m, NX_MY_KIND_RAM_BYTES) != NX_MY_V_OK_BALANCED { return 27 }
48 if nx_my_flow_count(m) != 2 { return 28 }
49
50 // 6: aggregations
51 if nx_my_total_by_kind_dir(m, NX_MY_KIND_RAM_BYTES, NX_MY_DIR_NATIVE_TO_FOREIGN) != 1000 { return 29 }
52 if nx_my_total_by_kind_dir(m, NX_MY_KIND_RAM_BYTES, NX_MY_DIR_FOREIGN_TO_NATIVE) != 1000 { return 30 }
53
54 // 7: native net giver -- only native gives, foreign hasn't reciprocated yet
55 let m2: *NxMycorrhiza = nx_my_new(2, 1, 2, 8, 2048, now)
56 nx_my_record_flow(m2, NX_MY_KIND_VRAM_BYTES, NX_MY_DIR_NATIVE_TO_FOREIGN, 5000, 1, 0, now)
57 if nx_my_audit_kind(m2, NX_MY_KIND_VRAM_BYTES) != NX_MY_V_OK_NATIVE_NET_GIVER { return 31 }
58
59 // 8: native net taker -- only foreign gives
60 let m3: *NxMycorrhiza = nx_my_new(3, 1, 2, 8, 2048, now)
61 nx_my_record_flow(m3, NX_MY_KIND_VRAM_BYTES, NX_MY_DIR_FOREIGN_TO_NATIVE, 5000, 1, 0, now)
62 if nx_my_audit_kind(m3, NX_MY_KIND_VRAM_BYTES) != NX_MY_V_OK_NATIVE_NET_TAKER { return 32 }
63
64 // 9: extraction by foreign -- we give 10x what we receive, tolerance is 2x
65 // native gives 10000, foreign gives 1000. ratio_n_over_f = 10000*1024/1000 = 10240 > 2048 -> EXTRACTION_BY_FOREIGN
66 let m4: *NxMycorrhiza = nx_my_new(4, 1, 2, 8, 2048, now)
67 nx_my_record_flow(m4, NX_MY_KIND_CPU_MICROSECONDS, NX_MY_DIR_NATIVE_TO_FOREIGN, 10000, 1, 0, now)
68 nx_my_record_flow(m4, NX_MY_KIND_CPU_MICROSECONDS, NX_MY_DIR_FOREIGN_TO_NATIVE, 1000, 1, 0, now)
69 if nx_my_audit_kind(m4, NX_MY_KIND_CPU_MICROSECONDS) != NX_MY_V_EXTRACTION_BY_FOREIGN { return 33 }
70
71 // 10: extraction by native -- WE extract from foreign (REFUSED ethically)
72 // native gives 500, foreign gives 10000. ratio_f_over_n = 10000*1024/500 = 20480 > 2048 -> EXTRACTION_BY_NATIVE
73 let m5: *NxMycorrhiza = nx_my_new(5, 1, 2, 8, 2048, now)
74 nx_my_record_flow(m5, NX_MY_KIND_GPU_MICROSECONDS, NX_MY_DIR_NATIVE_TO_FOREIGN, 500, 1, 0, now)
75 nx_my_record_flow(m5, NX_MY_KIND_GPU_MICROSECONDS, NX_MY_DIR_FOREIGN_TO_NATIVE, 10000, 1, 0, now)
76 if nx_my_audit_kind(m5, NX_MY_KIND_GPU_MICROSECONDS) != NX_MY_V_EXTRACTION_BY_NATIVE { return 34 }
77
78 // 11: within-tolerance but unequal -> NET_GIVER classification
79 // native gives 1500, foreign gives 1000. ratio_n_over_f = 1500*1024/1000 = 1536
80 // 1536 > 1024 (so not balanced), 1536 < 2048 (so not extraction) -> NET_GIVER
81 let m6: *NxMycorrhiza = nx_my_new(6, 1, 2, 8, 2048, now)
82 nx_my_record_flow(m6, NX_MY_KIND_DISK_BYTES, NX_MY_DIR_NATIVE_TO_FOREIGN, 1500, 1, 0, now)
83 nx_my_record_flow(m6, NX_MY_KIND_DISK_BYTES, NX_MY_DIR_FOREIGN_TO_NATIVE, 1000, 1, 0, now)
84 if nx_my_audit_kind(m6, NX_MY_KIND_DISK_BYTES) != NX_MY_V_OK_NATIVE_NET_GIVER { return 35 }
85
86 // 12: sever partnership
87 if nx_my_is_severed(m) != 0 { return 36 }
88 if nx_my_sever(m) != NX_MY_V_SEVERED { return 37 }
89 if nx_my_is_severed(m) != 1 { return 38 }
90
91 // 13: severed mycorrhiza refuses new flows
92 if nx_my_record_flow(m, NX_MY_KIND_RAM_BYTES, NX_MY_DIR_NATIVE_TO_FOREIGN, 100, 1, 0, now) != NX_MY_V_SEVERED { return 39 }
93 if nx_my_audit_kind(m, NX_MY_KIND_RAM_BYTES) != NX_MY_V_SEVERED { return 40 }
94
95 // 14: capacity exceeded
96 let m_full: *NxMycorrhiza = nx_my_new(7, 1, 2, 1, 1024, now)
97 nx_my_record_flow(m_full, NX_MY_KIND_RAM_BYTES, NX_MY_DIR_NATIVE_TO_FOREIGN, 100, 1, 0, now)
98 if nx_my_record_flow(m_full, NX_MY_KIND_RAM_BYTES, NX_MY_DIR_NATIVE_TO_FOREIGN, 100, 1, 0, now) != NX_MY_V_INVALID { return 41 }
99
100 // 15: invalid kind in record + audit
101 let m_v: *NxMycorrhiza = nx_my_new(8, 1, 2, 8, 1024, now)
102 if nx_my_record_flow(m_v, 99, NX_MY_DIR_NATIVE_TO_FOREIGN, 100, 1, 0, now) != NX_MY_V_INVALID { return 42 }
103 if nx_my_record_flow(m_v, NX_MY_KIND_RAM_BYTES, 99, 100, 1, 0, now) != NX_MY_V_INVALID { return 43 }
104 if nx_my_audit_kind(m_v, 99) != NX_MY_V_INVALID { return 44 }
105
106 // 16: null handling
107 let null_m: *NxMycorrhiza = (0 as i64) as *NxMycorrhiza
108 if nx_my_record_flow(null_m, NX_MY_KIND_RAM_BYTES, NX_MY_DIR_NATIVE_TO_FOREIGN, 100, 1, 0, now) != NX_MY_V_NULL { return 45 }
109 if nx_my_audit_kind(null_m, NX_MY_KIND_RAM_BYTES) != NX_MY_V_NULL { return 46 }
110 if nx_my_sever(null_m) != NX_MY_V_NULL { return 47 }
111 if nx_my_flow_count(null_m) != 0 { return 48 }
112 if nx_my_is_severed(null_m) != 0 { return 49 }
113 if nx_my_total_by_kind_dir(null_m, NX_MY_KIND_RAM_BYTES, NX_MY_DIR_NATIVE_TO_FOREIGN) != 0 { return 50 }
114
115 return 0
116}