nx_seed_bank_test.nx source
↩ module page · 139 lines · 6237 B
1// nx_seed_bank_test.nx -- smoke for nx_seed_bank.
2
3import "nx_syscalls.nx"
4import "nx_seed_bank.nx"
5
6func main() -> i64 {
7 let now: nx_size = 1000000
8
9 // 1: enum validity
10 if nx_sb_kind_is_valid(NX_SB_KIND_FULL_GENOTYPE) != 1 { return 1 }
11 if nx_sb_kind_is_valid(NX_SB_KIND_HEIRLOOM_CULTIVAR) != 1 { return 2 }
12 if nx_sb_kind_is_valid(-1) != 0 { return 3 }
13 if nx_sb_kind_is_valid(7) != 0 { return 4 }
14 if NX_SB_KIND_N != 7 { return 5 }
15
16 if nx_sb_status_is_valid(NX_SB_STATUS_DORMANT) != 1 { return 6 }
17 if nx_sb_status_is_valid(NX_SB_STATUS_CORRUPTED) != 1 { return 7 }
18 if nx_sb_status_is_valid(-1) != 0 { return 8 }
19 if nx_sb_status_is_valid(4) != 0 { return 9 }
20
21 if nx_sb_v_is_valid(NX_SB_V_OK) != 1 { return 10 }
22 if nx_sb_v_is_valid(NX_SB_V_CORRUPTION_DETECTED) != 1 { return 11 }
23
24 // 2: construction with HHI threshold 70% (Q10 717)
25 let b: *NxSeedBank = nx_sb_new(32, 717, now)
26 if b.capacity != 32 { return 12 }
27 if b.n_accessions != 0 { return 13 }
28 if b.next_accession_id != 1 { return 14 }
29 if b.monoculture_threshold_q10 != 717 { return 15 }
30
31 // 3: invalid construction
32 if nx_sb_new(0, 717, now) != (0 as *NxSeedBank) { return 16 }
33 if nx_sb_new(32, 0, now) != (0 as *NxSeedBank) { return 17 }
34 if nx_sb_new(32, 1025, now) != (0 as *NxSeedBank) { return 18 }
35
36 // 4: empty bank reports healthy diversity
37 if nx_sb_audit_diversity(b) != NX_SB_V_OK_HEALTHY_DIVERSITY { return 19 }
38
39 // 5: store accessions
40 let a1: nx_int = nx_sb_store(b, NX_SB_KIND_FULL_GENOTYPE, 0xAAAA, 0xCAFE, 1024, now)
41 if a1 != 1 { return 20 }
42 let a2: nx_int = nx_sb_store(b, NX_SB_KIND_CONFIG_ONLY, 0xBBBB, 0xCAFE, 512, now)
43 if a2 != 2 { return 21 }
44 let a3: nx_int = nx_sb_store(b, NX_SB_KIND_KEY_MATERIAL, 0xCCCC, 0xBEEF, 256, now)
45 if a3 != 3 { return 22 }
46 let a4: nx_int = nx_sb_store(b, NX_SB_KIND_FAMILY_CORPUS, 0xDDDD, 0xFADE, 2048, now)
47 if a4 != 4 { return 23 }
48 if b.n_accessions != 4 { return 24 }
49
50 // 6: invalid store
51 if nx_sb_store(b, 99, 0xFF, 0, 100, now) != 0 { return 25 }
52 if nx_sb_store(b, NX_SB_KIND_FULL_GENOTYPE, 0, 0, 100, now) != 0 { return 26 } // hash=0 invalid
53
54 // 7: find
55 let acc1: *NxAccession = nx_sb_find(b, 1)
56 if acc1.accession_id != 1 { return 27 }
57 if acc1.kind != NX_SB_KIND_FULL_GENOTYPE { return 28 }
58 if acc1.content_hash != 0xAAAA { return 29 }
59 if acc1.bytes_stored != 1024 { return 30 }
60 if acc1.status != NX_SB_STATUS_VERIFIED { return 31 }
61
62 let missing: *NxAccession = nx_sb_find(b, 9999)
63 if (missing as i64) != 0 { return 32 }
64
65 // 8: verify -- matching hash ok
66 if nx_sb_verify(b, 1, 0xAAAA, now + 100) != NX_SB_V_OK { return 33 }
67 let acc1_v: *NxAccession = nx_sb_find(b, 1)
68 if acc1_v.last_verified_us != (now + 100) { return 34 }
69
70 // 9: verify -- mismatched hash -> CORRUPTION_DETECTED
71 if nx_sb_verify(b, 2, 0xBADF00D, now + 200) != NX_SB_V_CORRUPTION_DETECTED { return 35 }
72 let acc2_c: *NxAccession = nx_sb_find(b, 2)
73 if acc2_c.status != NX_SB_STATUS_CORRUPTED { return 36 }
74
75 // 10: retrieve corrupted accession refused (returns 0)
76 if nx_sb_retrieve(b, 2, now + 300) != 0 { return 37 }
77
78 // 11: retrieve good accession
79 if nx_sb_retrieve(b, 1, now + 300) != 0xAAAA { return 38 }
80 let acc1_r: *NxAccession = nx_sb_find(b, 1)
81 if acc1_r.status != NX_SB_STATUS_RETRIEVED { return 39 }
82
83 // 12: count_by_kind
84 if nx_sb_count_by_kind(b, NX_SB_KIND_FULL_GENOTYPE) != 1 { return 40 }
85 if nx_sb_count_by_kind(b, NX_SB_KIND_CONFIG_ONLY) != 1 { return 41 }
86 if nx_sb_count_by_kind(b, NX_SB_KIND_KEY_MATERIAL) != 1 { return 42 }
87 if nx_sb_count_by_kind(b, NX_SB_KIND_FAMILY_CORPUS) != 1 { return 43 }
88 if nx_sb_count_by_kind(b, NX_SB_KIND_TEK_ARCHIVE) != 0 { return 44 }
89
90 // 13: count_by_status
91 if nx_sb_count_by_status(b, NX_SB_STATUS_RETRIEVED) != 1 { return 45 }
92 if nx_sb_count_by_status(b, NX_SB_STATUS_CORRUPTED) != 1 { return 46 }
93 if nx_sb_count_by_status(b, NX_SB_STATUS_VERIFIED) != 2 { return 47 }
94
95 // 14: total bytes = 1024 + 512 + 256 + 2048 = 3840
96 if nx_sb_total_bytes(b) != 3840 { return 48 }
97
98 // 15: diversity audit -- 4 distinct kinds, 1 corrupted -> CORRUPTION_DETECTED
99 if nx_sb_audit_diversity(b) != NX_SB_V_CORRUPTION_DETECTED { return 49 }
100
101 // 16: fresh bank with monoculture -- 8 full_genotype only, threshold 717
102 // share = 8/8 * 1024 = 1024 >= 717 -> MONOCULTURE_WARNING
103 let b2: *NxSeedBank = nx_sb_new(16, 717, now)
104 var k: nx_int = 0
105 while k < 8 {
106 nx_sb_store(b2, NX_SB_KIND_FULL_GENOTYPE, 0x1000 + k, 0, 100, now)
107 k = k + 1
108 }
109 if nx_sb_audit_diversity(b2) != NX_SB_V_MONOCULTURE_WARNING { return 50 }
110
111 // 17: add diversity -- 8 full + 4 config = 12 total; share 8/12 = 682 < 717
112 nx_sb_store(b2, NX_SB_KIND_CONFIG_ONLY, 0x2001, 0, 100, now)
113 nx_sb_store(b2, NX_SB_KIND_CONFIG_ONLY, 0x2002, 0, 100, now)
114 nx_sb_store(b2, NX_SB_KIND_CONFIG_ONLY, 0x2003, 0, 100, now)
115 nx_sb_store(b2, NX_SB_KIND_CONFIG_ONLY, 0x2004, 0, 100, now)
116 if nx_sb_audit_diversity(b2) != NX_SB_V_OK_HEALTHY_DIVERSITY { return 51 }
117
118 // 18: capacity exceeded
119 let b_full: *NxSeedBank = nx_sb_new(2, 717, now)
120 nx_sb_store(b_full, NX_SB_KIND_FULL_GENOTYPE, 0x1, 0, 100, now)
121 nx_sb_store(b_full, NX_SB_KIND_FULL_GENOTYPE, 0x2, 0, 100, now)
122 if nx_sb_store(b_full, NX_SB_KIND_FULL_GENOTYPE, 0x3, 0, 100, now) != 0 { return 52 }
123
124 // 19: verify unknown id refused
125 if nx_sb_verify(b, 9999, 0, now) != NX_SB_V_INVALID { return 53 }
126
127 // 20: null handling
128 let null_b: *NxSeedBank = (0 as i64) as *NxSeedBank
129 if nx_sb_store(null_b, NX_SB_KIND_FULL_GENOTYPE, 0x1, 0, 100, now) != 0 { return 54 }
130 if (nx_sb_find(null_b, 1) as i64) != 0 { return 55 }
131 if nx_sb_verify(null_b, 1, 0, now) != NX_SB_V_NULL { return 56 }
132 if nx_sb_retrieve(null_b, 1, now) != 0 { return 57 }
133 if nx_sb_count_by_kind(null_b, NX_SB_KIND_FULL_GENOTYPE) != 0 { return 58 }
134 if nx_sb_count_by_status(null_b, NX_SB_STATUS_VERIFIED) != 0 { return 59 }
135 if nx_sb_audit_diversity(null_b) != NX_SB_V_NULL { return 60 }
136 if nx_sb_total_bytes(null_b) != 0 { return 61 }
137
138 return 0
139}