nx_abortive_test.nx source
↩ module page · 161 lines · 7596 B
1// nx_abortive_test.nx -- smoke for nx_abortive.
2
3import "nx_syscalls.nx"
4import "nx_abortive.nx"
5
6func main() -> i64 {
7 let now: nx_size = 1000
8
9 // 1: state enum validity
10 if nx_ab_state_is_valid(NX_AB_HEALTHY) != 1 { return 1 }
11 if nx_ab_state_is_valid(NX_AB_TERMINATED) != 1 { return 2 }
12 if nx_ab_state_is_valid(-1) != 0 { return 3 }
13 if nx_ab_state_is_valid(5) != 0 { return 4 }
14 if nx_ab_state_is_valid(NX_AB_INVALID) != 0 { return 5 }
15 if NX_AB_N_STATES != 5 { return 6 }
16
17 // 2: trigger enum validity
18 if nx_ab_trigger_is_valid(NX_AB_TRG_NONE) != 1 { return 7 }
19 if nx_ab_trigger_is_valid(NX_AB_TRG_GERMLINE_FLUSHED) != 1 { return 8 }
20 if nx_ab_trigger_is_valid(-1) != 0 { return 9 }
21 if nx_ab_trigger_is_valid(10) != 0 { return 10 }
22
23 // 3: accepts-work predicate -- only HEALTHY
24 if nx_ab_state_accepts_work(NX_AB_HEALTHY) != 1 { return 11 }
25 if nx_ab_state_accepts_work(NX_AB_FLAGGED) != 0 { return 12 }
26 if nx_ab_state_accepts_work(NX_AB_QUARANTINED) != 0 { return 13 }
27 if nx_ab_state_accepts_work(NX_AB_TERMINATING) != 0 { return 14 }
28 if nx_ab_state_accepts_work(NX_AB_TERMINATED) != 0 { return 15 }
29
30 // 4: terminal predicate -- only TERMINATED
31 if nx_ab_state_is_terminal(NX_AB_HEALTHY) != 0 { return 16 }
32 if nx_ab_state_is_terminal(NX_AB_TERMINATED) != 1 { return 17 }
33
34 // 5: fresh cell starts HEALTHY
35 let c: *NxCellAbortiveState = nx_ab_cell_new(42)
36 if c.cell_id != 42 { return 18 }
37 if c.state != NX_AB_HEALTHY { return 19 }
38 if c.last_trigger != NX_AB_TRG_NONE { return 20 }
39 if c.indicator_count != 0 { return 21 }
40 if c.germline_preserved != 1 { return 22 }
41
42 // 6: HEALTHY -> FLAGGED is auto (no operator gate needed)
43 let v1: nx_int = nx_ab_transition(c, NX_AB_FLAGGED,
44 NX_AB_TRG_PAMP_HIT, now, 0)
45 if v1 != NX_AB_OK { return 23 }
46 if c.state != NX_AB_FLAGGED { return 24 }
47 if c.indicator_count != 1 { return 25 }
48 if c.last_trigger != NX_AB_TRG_PAMP_HIT { return 26 }
49
50 // 7: FLAGGED -> HEALTHY (false-positive clear) is auto
51 let v2: nx_int = nx_ab_transition(c, NX_AB_HEALTHY,
52 NX_AB_TRG_FALSE_POSITIVE_CLEAR,
53 now + 100, 0)
54 if v2 != NX_AB_OK { return 27 }
55 if c.state != NX_AB_HEALTHY { return 28 }
56 if c.indicator_count != 0 { return 29 } // reset on clear
57
58 // 8: FLAGGED -> QUARANTINED requires operator
59 nx_ab_transition(c, NX_AB_FLAGGED, NX_AB_TRG_PAMP_HIT, now + 200, 0)
60 let v3: nx_int = nx_ab_transition(c, NX_AB_QUARANTINED,
61 NX_AB_TRG_CRISPR_HIT,
62 now + 300, 0)
63 if v3 != NX_AB_REJECTED_OPERATOR_REQUIRED { return 30 }
64 if c.state != NX_AB_FLAGGED { return 31 } // unchanged
65
66 // 9: same with operator_authorized=1 succeeds
67 let v4: nx_int = nx_ab_transition(c, NX_AB_QUARANTINED,
68 NX_AB_TRG_CRISPR_HIT,
69 now + 400, 1)
70 if v4 != NX_AB_OK { return 32 }
71 if c.state != NX_AB_QUARANTINED { return 33 }
72
73 // 10: QUARANTINED -> TERMINATING also requires operator
74 let v5: nx_int = nx_ab_transition(c, NX_AB_TERMINATING,
75 NX_AB_TRG_DRAIN_COMPLETE,
76 now + 500, 0)
77 if v5 != NX_AB_REJECTED_OPERATOR_REQUIRED { return 34 }
78 let v6: nx_int = nx_ab_transition(c, NX_AB_TERMINATING,
79 NX_AB_TRG_DRAIN_COMPLETE,
80 now + 600, 1)
81 if v6 != NX_AB_OK { return 35 }
82 if c.state != NX_AB_TERMINATING { return 36 }
83
84 // 11: TERMINATING -> TERMINATED requires operator
85 let v7: nx_int = nx_ab_transition(c, NX_AB_TERMINATED,
86 NX_AB_TRG_GERMLINE_FLUSHED,
87 now + 700, 1)
88 if v7 != NX_AB_OK { return 37 }
89 if c.state != NX_AB_TERMINATED { return 38 }
90
91 // 12: TERMINATED is terminal -- no transitions out
92 let v8: nx_int = nx_ab_transition(c, NX_AB_HEALTHY,
93 NX_AB_TRG_NONE,
94 now + 800, 1)
95 if v8 != NX_AB_REJECTED_INVALID_TRANSITION { return 39 }
96 if c.state != NX_AB_TERMINATED { return 40 }
97
98 // 13: emergency-trigger RANSOMWARE_CONFIRMED bypasses operator gate
99 let c2: *NxCellAbortiveState = nx_ab_cell_new(100)
100 nx_ab_transition(c2, NX_AB_FLAGGED, NX_AB_TRG_PAMP_HIT, now, 0)
101 // Emergency trigger gets the cell to QUARANTINED without operator
102 let v9: nx_int = nx_ab_transition(c2, NX_AB_QUARANTINED,
103 NX_AB_TRG_RANSOMWARE_CONFIRMED,
104 now + 50, 0)
105 if v9 != NX_AB_OK { return 41 }
106 if c2.state != NX_AB_QUARANTINED { return 42 }
107
108 // 14: OPERATOR_REQUEST bypasses operator gate (operator already asked)
109 let c3: *NxCellAbortiveState = nx_ab_cell_new(200)
110 let v10: nx_int = nx_ab_transition(c3, NX_AB_FLAGGED,
111 NX_AB_TRG_OPERATOR_REQUEST,
112 now, 0)
113 if v10 != NX_AB_OK { return 43 }
114 let v11: nx_int = nx_ab_transition(c3, NX_AB_QUARANTINED,
115 NX_AB_TRG_OPERATOR_REQUEST,
116 now + 10, 0)
117 if v11 != NX_AB_OK { return 44 }
118
119 // 15: BMS_OUT_OF_SPEC also emergency
120 let c4: *NxCellAbortiveState = nx_ab_cell_new(300)
121 nx_ab_transition(c4, NX_AB_FLAGGED, NX_AB_TRG_BMS_OUT_OF_SPEC, now, 0)
122 let v12: nx_int = nx_ab_transition(c4, NX_AB_QUARANTINED,
123 NX_AB_TRG_BMS_OUT_OF_SPEC,
124 now + 5, 0)
125 if v12 != NX_AB_OK { return 45 }
126
127 // 16: invalid transitions rejected
128 let c5: *NxCellAbortiveState = nx_ab_cell_new(400)
129 let bad1: nx_int = nx_ab_transition(c5, NX_AB_TERMINATED,
130 NX_AB_TRG_GERMLINE_FLUSHED,
131 now, 1)
132 if bad1 != NX_AB_REJECTED_INVALID_TRANSITION { return 46 }
133 // HEALTHY -> TERMINATING also invalid (must go through QUARANTINED)
134 let bad2: nx_int = nx_ab_transition(c5, NX_AB_TERMINATING,
135 NX_AB_TRG_OPERATOR_REQUEST,
136 now, 0)
137 if bad2 != NX_AB_REJECTED_INVALID_TRANSITION { return 47 }
138
139 // 17: invalid state/trigger inputs rejected
140 let bad3: nx_int = nx_ab_transition(c5, 99,
141 NX_AB_TRG_PAMP_HIT, now, 1)
142 if bad3 != NX_AB_REJECTED_INVALID_TRANSITION { return 48 }
143 let bad4: nx_int = nx_ab_transition(c5, NX_AB_FLAGGED,
144 99, now, 1)
145 if bad4 != NX_AB_REJECTED_INVALID_TRANSITION { return 49 }
146
147 // 18: germline invariant holds across all transitions
148 if nx_ab_germline_invariant_holds(c) != 1 { return 50 }
149 if nx_ab_germline_invariant_holds(c2) != 1 { return 51 }
150 if nx_ab_germline_invariant_holds(c3) != 1 { return 52 }
151 if nx_ab_germline_invariant_holds(c4) != 1 { return 53 }
152 // Even on the TERMINATED cell
153 if c.state != NX_AB_TERMINATED { return 54 }
154 if nx_ab_germline_invariant_holds(c) != 1 { return 55 }
155
156 // 19: null cell -> 0
157 let null_c: *NxCellAbortiveState = (0 as i64) as *NxCellAbortiveState
158 if nx_ab_germline_invariant_holds(null_c) != 0 { return 56 }
159
160 return 0
161}