nx_vitals_test.nx source
↩ module page · 146 lines · 7253 B
1// nx_vitals_test.nx -- smoke for nx_vitals.
2
3import "nx_syscalls.nx"
4import "nx_vitals.nx"
5
6func main() -> i64 {
7 // 1: source enum validity
8 if nx_vs_source_is_valid(NX_VS_DC_RAIL) != 1 { return 1 }
9 if nx_vs_source_is_valid(NX_VS_MASS) != 1 { return 2 }
10 if nx_vs_source_is_valid(-1) != 0 { return 3 }
11 if nx_vs_source_is_valid(7) != 0 { return 4 }
12 if NX_VS_N_SOURCES != 7 { return 5 }
13
14 // 2: state enum validity
15 if nx_vs_state_is_valid(NX_VS_STATE_OFF) != 1 { return 6 }
16 if nx_vs_state_is_valid(NX_VS_STATE_HEAVY_LOAD) != 1 { return 7 }
17 if nx_vs_state_is_valid(-1) != 0 { return 8 }
18 if nx_vs_state_is_valid(5) != 0 { return 9 }
19
20 // 3: verdict enum validity
21 if nx_vv_verdict_is_valid(NX_VV_WITHIN_ENVELOPE) != 1 { return 10 }
22 if nx_vv_verdict_is_valid(NX_VV_CRITICAL_DEVIATION) != 1 { return 11 }
23 if nx_vv_verdict_is_valid(-1) != 0 { return 12 }
24 if nx_vv_verdict_is_valid(4) != 0 { return 13 }
25 if nx_vv_verdict_is_valid(NX_VV_INVALID) != 0 { return 14 }
26
27 // 4: concerning predicate
28 if nx_vv_is_concerning(NX_VV_WITHIN_ENVELOPE) != 0 { return 15 }
29 if nx_vv_is_concerning(NX_VV_LOW_DEVIATION) != 1 { return 16 }
30 if nx_vv_is_concerning(NX_VV_HIGH_DEVIATION) != 1 { return 17 }
31 if nx_vv_is_concerning(NX_VV_CRITICAL_DEVIATION) != 1 { return 18 }
32
33 // 5: envelope construction
34 let e: *NxVitalsEnvelope = nx_vs_envelope_new(NX_VS_DC_RAIL,
35 NX_VS_STATE_IDLE,
36 100, 200,
37 10, 50, 100)
38 if e.source != NX_VS_DC_RAIL { return 19 }
39 if e.state != NX_VS_STATE_IDLE { return 20 }
40 if e.min_value != 100 { return 21 }
41 if e.max_value != 200 { return 22 }
42 if e.low_dev_threshold != 10 { return 23 }
43 if e.high_dev_threshold != 50 { return 24 }
44 if e.critical_dev_threshold != 100 { return 25 }
45
46 // 6: reading construction
47 let r_in: *NxVitalsReading = nx_vs_reading_new(NX_VS_DC_RAIL,
48 NX_VS_STATE_IDLE,
49 150, 1000)
50 if r_in.source != NX_VS_DC_RAIL { return 26 }
51 if r_in.state != NX_VS_STATE_IDLE { return 27 }
52 if r_in.measured_value != 150 { return 28 }
53 if r_in.measured_at_us != 1000 { return 29 }
54
55 // 7: reading within envelope -> WITHIN_ENVELOPE
56 if nx_vs_classify(r_in, e) != NX_VV_WITHIN_ENVELOPE { return 30 }
57
58 // 8: reading at boundary (min) -> WITHIN_ENVELOPE
59 let r_min: *NxVitalsReading = nx_vs_reading_new(NX_VS_DC_RAIL,
60 NX_VS_STATE_IDLE,
61 100, 1000)
62 if nx_vs_classify(r_min, e) != NX_VV_WITHIN_ENVELOPE { return 31 }
63
64 // 9: reading at boundary (max) -> WITHIN_ENVELOPE
65 let r_max: *NxVitalsReading = nx_vs_reading_new(NX_VS_DC_RAIL,
66 NX_VS_STATE_IDLE,
67 200, 1000)
68 if nx_vs_classify(r_max, e) != NX_VV_WITHIN_ENVELOPE { return 32 }
69
70 // 10: reading just under low-dev threshold -> WITHIN_ENVELOPE
71 let r_just: *NxVitalsReading = nx_vs_reading_new(NX_VS_DC_RAIL,
72 NX_VS_STATE_IDLE,
73 208, 1000)
74 // deviation = 8; low_dev_threshold = 10 -> within
75 if nx_vs_classify(r_just, e) != NX_VV_WITHIN_ENVELOPE { return 33 }
76
77 // 11: deviation at low_dev threshold -> LOW_DEVIATION
78 let r_low: *NxVitalsReading = nx_vs_reading_new(NX_VS_DC_RAIL,
79 NX_VS_STATE_IDLE,
80 230, 1000)
81 // deviation = 30; low_dev_threshold = 10 -> LOW
82 if nx_vs_classify(r_low, e) != NX_VV_LOW_DEVIATION { return 34 }
83
84 // 12: deviation at high_dev threshold -> HIGH_DEVIATION
85 let r_high: *NxVitalsReading = nx_vs_reading_new(NX_VS_DC_RAIL,
86 NX_VS_STATE_IDLE,
87 275, 1000)
88 // deviation = 75; high_dev_threshold = 50 -> HIGH
89 if nx_vs_classify(r_high, e) != NX_VV_HIGH_DEVIATION { return 35 }
90
91 // 13: deviation at critical_dev threshold -> CRITICAL_DEVIATION
92 let r_crit: *NxVitalsReading = nx_vs_reading_new(NX_VS_DC_RAIL,
93 NX_VS_STATE_IDLE,
94 400, 1000)
95 // deviation = 200; critical_dev_threshold = 100 -> CRITICAL
96 if nx_vs_classify(r_crit, e) != NX_VV_CRITICAL_DEVIATION { return 36 }
97
98 // 14: deviation below min also detected
99 let r_below: *NxVitalsReading = nx_vs_reading_new(NX_VS_DC_RAIL,
100 NX_VS_STATE_IDLE,
101 30, 1000)
102 // deviation = 70 (100 - 30); 50 <= 70 < 100 -> HIGH
103 if nx_vs_classify(r_below, e) != NX_VV_HIGH_DEVIATION { return 37 }
104
105 // 15: source mismatch -> INVALID
106 let r_wrongsrc: *NxVitalsReading = nx_vs_reading_new(NX_VS_THERMAL,
107 NX_VS_STATE_IDLE,
108 150, 1000)
109 if nx_vs_classify(r_wrongsrc, e) != NX_VV_INVALID { return 38 }
110
111 // 16: state mismatch -> INVALID
112 let r_wrongstate: *NxVitalsReading = nx_vs_reading_new(NX_VS_DC_RAIL,
113 NX_VS_STATE_HEAVY_LOAD,
114 150, 1000)
115 if nx_vs_classify(r_wrongstate, e) != NX_VV_INVALID { return 39 }
116
117 // 17: null reading -> INVALID
118 let null_r: *NxVitalsReading = (0 as i64) as *NxVitalsReading
119 if nx_vs_classify(null_r, e) != NX_VV_INVALID { return 40 }
120
121 // 18: null envelope -> INVALID
122 let null_e: *NxVitalsEnvelope = (0 as i64) as *NxVitalsEnvelope
123 if nx_vs_classify(r_in, null_e) != NX_VV_INVALID { return 41 }
124
125 // 19: verdict priority -- CRITICAL > HIGH > LOW > WITHIN
126 if nx_vs_verdict_priority(NX_VV_CRITICAL_DEVIATION) <=
127 nx_vs_verdict_priority(NX_VV_HIGH_DEVIATION) { return 42 }
128 if nx_vs_verdict_priority(NX_VV_HIGH_DEVIATION) <=
129 nx_vs_verdict_priority(NX_VV_LOW_DEVIATION) { return 43 }
130 if nx_vs_verdict_priority(NX_VV_LOW_DEVIATION) <=
131 nx_vs_verdict_priority(NX_VV_WITHIN_ENVELOPE) { return 44 }
132 if nx_vs_verdict_priority(NX_VV_INVALID) != 0 { return 45 }
133
134 // 20: canonical off-state ME check -- clean (0mA at off) -> WITHIN
135 if nx_vs_classify_off_state_active_ME(0) != NX_VV_WITHIN_ENVELOPE { return 46 }
136 if nx_vs_classify_off_state_active_ME(3) != NX_VV_WITHIN_ENVELOPE { return 47 }
137
138 // 21: ME-active signature -- 100mA at OFF -> HIGH or CRITICAL deviation
139 let me_verdict: nx_int = nx_vs_classify_off_state_active_ME(100)
140 if nx_vv_is_concerning(me_verdict) != 1 { return 48 }
141
142 // 22: extreme draw at OFF -> CRITICAL_DEVIATION
143 if nx_vs_classify_off_state_active_ME(500) != NX_VV_CRITICAL_DEVIATION { return 49 }
144
145 return 0
146}