CCSDS File Delivery Protocol (CCSDS 727.0-B-5) for space file transfer
refactor(crowbar): Alcotest-style API with suite exports and grouped run
- Change `run` signature to `string -> (string * test_case list) list -> unit`
matching Alcotest's grouping convention
- Fix `_name` bug: pass the name through to Alcotest.run_with_args
- Each fuzz module now exports `let suite = ("name", [test_case ...])`
- Entry points (fuzz.ml) collect suites: `Crowbar.run "pkg" [Fuzz_X.suite]`
- Remove stale `add_test`/`suite` API, keep only `test_case`/`run`
- Remove `let run () = ()` from fuzz_common.ml files
- Update merlint E725 rule to match new `let suite = ("name", ...)` pattern
- Update E725 test fixtures and expected output
+133
-133
+133
-133
fuzz/fuzz_cfdp.ml
+133
-133
fuzz/fuzz_cfdp.ml
···
10
10
let small_bytes = map [ bytes ] (fun s -> Bytes.of_string s)
11
11
12
12
(* {1 Checksum Computation} *)
13
+
(* {1 NAK Segment Request Validation} *)
14
+
(* {1 Sender1 State Machine} *)
13
15
14
-
let () =
15
-
add_test ~name:"cfdp: checksum_modular no crash" [ small_bytes ]
16
-
@@ fun data ->
16
+
let sender1_event =
17
+
choose
18
+
[
19
+
const Cfdp.Sender1.Ev_cancel;
20
+
map [ uint8 ] (fun c ->
21
+
Cfdp.Sender1.Ev_fault
22
+
(match c mod 5 with
23
+
| 0 -> Cfdp.No_error
24
+
| 1 -> Cfdp.Inactivity_detected
25
+
| 2 -> Cfdp.File_checksum_failure
26
+
| 3 -> Cfdp.Cancel_received
27
+
| _ -> Cfdp.Nak_limit_reached));
28
+
map [ int64 ] (fun p -> Cfdp.Sender1.Ev_segment_sent (Int64.abs p));
29
+
const Cfdp.Sender1.Ev_eof_sent;
30
+
]
31
+
(* {1 Sender2 State Machine} *)
32
+
33
+
let sender2_event =
34
+
choose
35
+
[
36
+
const Cfdp.Sender2.Ev_cancel;
37
+
map [ uint8 ] (fun c ->
38
+
Cfdp.Sender2.Ev_fault
39
+
(match c mod 5 with
40
+
| 0 -> Cfdp.No_error
41
+
| 1 -> Cfdp.Inactivity_detected
42
+
| 2 -> Cfdp.File_checksum_failure
43
+
| 3 -> Cfdp.Cancel_received
44
+
| _ -> Cfdp.Nak_limit_reached));
45
+
map [ int64 ] (fun p -> Cfdp.Sender2.Ev_segment_sent (Int64.abs p));
46
+
const Cfdp.Sender2.Ev_eof_sent;
47
+
map [ uint8 ] (fun c ->
48
+
Cfdp.Sender2.Ev_timer_expired
49
+
(match c mod 5 with
50
+
| 0 -> Cfdp.Timer_nak
51
+
| 1 -> Cfdp.Timer_eof
52
+
| 2 -> Cfdp.Timer_finished
53
+
| 3 -> Cfdp.Timer_inactivity
54
+
| _ -> Cfdp.Timer_keep_alive));
55
+
]
56
+
(* {1 Receiver1 State Machine} *)
57
+
(* {1 Receiver2 State Machine} *)
58
+
59
+
let receiver2_event =
60
+
choose
61
+
[
62
+
const Cfdp.Receiver2.Ev_cancel;
63
+
const Cfdp.Receiver2.Ev_inactivity_timeout;
64
+
map [ uint8 ] (fun c ->
65
+
Cfdp.Receiver2.Ev_timer_expired
66
+
(match c mod 5 with
67
+
| 0 -> Cfdp.Timer_nak
68
+
| 1 -> Cfdp.Timer_eof
69
+
| 2 -> Cfdp.Timer_finished
70
+
| 3 -> Cfdp.Timer_inactivity
71
+
| _ -> Cfdp.Timer_keep_alive));
72
+
]
73
+
(* {1 PDU Header Parsing} *)
74
+
(* {1 Condition Code Conversion} *)
75
+
(* {1 Checksum Type Conversion} *)
76
+
(* {1 Directive Code Conversion} *)
77
+
(* {1 Entity ID} *)
78
+
79
+
let test_checksum_modular data =
17
80
let _ = Cfdp.compute_checksum Cfdp.Checksum_modular data in
18
81
check true
19
82
20
-
let () =
21
-
add_test ~name:"cfdp: checksum_crc32 no crash" [ small_bytes ] @@ fun data ->
83
+
let test_checksum_crc32 data =
22
84
let _ = Cfdp.compute_checksum Cfdp.Checksum_crc32 data in
23
85
check true
24
86
25
-
let () =
26
-
add_test ~name:"cfdp: checksum_crc32c no crash" [ small_bytes ] @@ fun data ->
87
+
let test_checksum_crc32c data =
27
88
let _ = Cfdp.compute_checksum Cfdp.Checksum_crc32c data in
28
89
check true
29
90
30
-
let () =
31
-
add_test ~name:"cfdp: checksum_null zero" [ small_bytes ] @@ fun data ->
91
+
let test_checksum_null data =
32
92
let csum = Cfdp.compute_checksum Cfdp.Checksum_null data in
33
93
if csum <> 0l then fail "null checksum not zero" else check true
34
94
35
-
let () =
36
-
add_test ~name:"cfdp: checksum deterministic" [ uint8; bytes ]
37
-
@@ fun typ_byte buf ->
95
+
let test_checksum_deterministic typ_byte buf =
38
96
let data = Bytes.of_string buf in
39
97
let typ =
40
98
match typ_byte mod 4 with
···
47
105
let c2 = Cfdp.compute_checksum typ data in
48
106
if c1 <> c2 then fail "checksum not deterministic" else check true
49
107
50
-
let () =
51
-
add_test ~name:"cfdp: verify_checksum consistency" [ uint8; bytes ]
52
-
@@ fun typ_byte buf ->
108
+
let test_verify_checksum typ_byte buf =
53
109
let data = Bytes.of_string buf in
54
110
let typ =
55
111
match typ_byte mod 4 with
···
63
119
fail "verify_checksum failed for computed checksum"
64
120
else check true
65
121
66
-
(* {1 NAK Segment Request Validation} *)
67
-
68
-
let () =
69
-
add_test ~name:"cfdp: segment_request" [ int64; int64 ] @@ fun s e ->
122
+
let test_segment_request s e =
70
123
let start_offset = Int64.abs s in
71
124
let end_offset = Int64.abs e in
72
125
let seg = Cfdp.segment_request start_offset end_offset in
···
74
127
else if seg.end_offset <> end_offset then fail "end_offset mismatch"
75
128
else check true
76
129
77
-
let () =
78
-
add_test ~name:"cfdp: nak crafted segments" [ list (pair int64 int64) ]
79
-
@@ fun pairs ->
130
+
let test_nak_crafted pairs =
80
131
let segments =
81
132
List.map
82
133
(fun (s, e) ->
···
88
139
let _nak = Cfdp.nak ~start_scope:0L ~end_scope:1000000L segments in
89
140
check true
90
141
91
-
(* {1 Sender1 State Machine} *)
92
-
93
-
let sender1_event =
94
-
choose
95
-
[
96
-
const Cfdp.Sender1.Ev_cancel;
97
-
map [ uint8 ] (fun c ->
98
-
Cfdp.Sender1.Ev_fault
99
-
(match c mod 5 with
100
-
| 0 -> Cfdp.No_error
101
-
| 1 -> Cfdp.Inactivity_detected
102
-
| 2 -> Cfdp.File_checksum_failure
103
-
| 3 -> Cfdp.Cancel_received
104
-
| _ -> Cfdp.Nak_limit_reached));
105
-
map [ int64 ] (fun p -> Cfdp.Sender1.Ev_segment_sent (Int64.abs p));
106
-
const Cfdp.Sender1.Ev_eof_sent;
107
-
]
108
-
109
-
let () =
110
-
add_test ~name:"cfdp: sender1 step" [ sender1_event ] @@ fun event ->
142
+
let test_sender1_step event =
111
143
let eid = Cfdp.Entity_id.of_int64_exn 1L in
112
144
let sender = Cfdp.Sender1.initial eid in
113
145
let _sender', _actions = Cfdp.Sender1.step sender event in
114
146
check true
115
147
116
-
let () =
117
-
add_test ~name:"cfdp: sender1 multi" [ list sender1_event ] @@ fun events ->
148
+
let test_sender1_multi events =
118
149
let eid = Cfdp.Entity_id.of_int64_exn 1L in
119
-
let rec run sender = function
150
+
let rec loop sender = function
120
151
| [] -> ()
121
152
| event :: rest ->
122
153
let sender', _actions = Cfdp.Sender1.step sender event in
123
-
run sender' rest
154
+
loop sender' rest
124
155
in
125
-
run (Cfdp.Sender1.initial eid) events;
156
+
loop (Cfdp.Sender1.initial eid) events;
126
157
check true
127
158
128
-
(* {1 Sender2 State Machine} *)
129
-
130
-
let sender2_event =
131
-
choose
132
-
[
133
-
const Cfdp.Sender2.Ev_cancel;
134
-
map [ uint8 ] (fun c ->
135
-
Cfdp.Sender2.Ev_fault
136
-
(match c mod 5 with
137
-
| 0 -> Cfdp.No_error
138
-
| 1 -> Cfdp.Inactivity_detected
139
-
| 2 -> Cfdp.File_checksum_failure
140
-
| 3 -> Cfdp.Cancel_received
141
-
| _ -> Cfdp.Nak_limit_reached));
142
-
map [ int64 ] (fun p -> Cfdp.Sender2.Ev_segment_sent (Int64.abs p));
143
-
const Cfdp.Sender2.Ev_eof_sent;
144
-
map [ uint8 ] (fun c ->
145
-
Cfdp.Sender2.Ev_timer_expired
146
-
(match c mod 5 with
147
-
| 0 -> Cfdp.Timer_nak
148
-
| 1 -> Cfdp.Timer_eof
149
-
| 2 -> Cfdp.Timer_finished
150
-
| 3 -> Cfdp.Timer_inactivity
151
-
| _ -> Cfdp.Timer_keep_alive));
152
-
]
153
-
154
-
let () =
155
-
add_test ~name:"cfdp: sender2 step" [ sender2_event ] @@ fun event ->
159
+
let test_sender2_step event =
156
160
let eid = Cfdp.Entity_id.of_int64_exn 1L in
157
161
let sender = Cfdp.Sender2.initial eid in
158
162
let _sender', _actions = Cfdp.Sender2.step sender event in
159
163
check true
160
164
161
-
let () =
162
-
add_test ~name:"cfdp: sender2 multi" [ list sender2_event ] @@ fun events ->
165
+
let test_sender2_multi events =
163
166
let eid = Cfdp.Entity_id.of_int64_exn 1L in
164
-
let rec run sender = function
167
+
let rec loop sender = function
165
168
| [] -> ()
166
169
| event :: rest ->
167
170
let sender', _actions = Cfdp.Sender2.step sender event in
168
-
run sender' rest
171
+
loop sender' rest
169
172
in
170
-
run (Cfdp.Sender2.initial eid) events;
173
+
loop (Cfdp.Sender2.initial eid) events;
171
174
check true
172
175
173
-
(* {1 Receiver1 State Machine} *)
174
-
175
-
let () =
176
-
add_test ~name:"cfdp: receiver1 step" [ bool ] @@ fun is_cancel ->
176
+
let test_receiver1_step is_cancel =
177
177
let eid = Cfdp.Entity_id.of_int64_exn 2L in
178
178
let receiver = Cfdp.Receiver1.initial eid in
179
179
let event =
···
183
183
let _receiver', _actions = Cfdp.Receiver1.step receiver event in
184
184
check true
185
185
186
-
(* {1 Receiver2 State Machine} *)
187
-
188
-
let receiver2_event =
189
-
choose
190
-
[
191
-
const Cfdp.Receiver2.Ev_cancel;
192
-
const Cfdp.Receiver2.Ev_inactivity_timeout;
193
-
map [ uint8 ] (fun c ->
194
-
Cfdp.Receiver2.Ev_timer_expired
195
-
(match c mod 5 with
196
-
| 0 -> Cfdp.Timer_nak
197
-
| 1 -> Cfdp.Timer_eof
198
-
| 2 -> Cfdp.Timer_finished
199
-
| 3 -> Cfdp.Timer_inactivity
200
-
| _ -> Cfdp.Timer_keep_alive));
201
-
]
202
-
203
-
let () =
204
-
add_test ~name:"cfdp: receiver2 step" [ receiver2_event ] @@ fun event ->
186
+
let test_receiver2_step event =
205
187
let eid = Cfdp.Entity_id.of_int64_exn 2L in
206
188
let receiver = Cfdp.Receiver2.initial eid in
207
189
let _receiver', _actions = Cfdp.Receiver2.step receiver event in
208
190
check true
209
191
210
-
let () =
211
-
add_test ~name:"cfdp: receiver2 multi" [ list receiver2_event ]
212
-
@@ fun events ->
192
+
let test_receiver2_multi events =
213
193
let eid = Cfdp.Entity_id.of_int64_exn 2L in
214
-
let rec run receiver = function
194
+
let rec loop receiver = function
215
195
| [] -> ()
216
196
| event :: rest ->
217
197
let receiver', _actions = Cfdp.Receiver2.step receiver event in
218
-
run receiver' rest
198
+
loop receiver' rest
219
199
in
220
-
run (Cfdp.Receiver2.initial eid) events;
200
+
loop (Cfdp.Receiver2.initial eid) events;
221
201
check true
222
202
223
-
(* {1 PDU Header Parsing} *)
224
-
225
-
let () =
226
-
add_test ~name:"cfdp: header parse no crash" [ bytes ] @@ fun buf ->
203
+
let test_header_parse buf =
227
204
(match Cfdp.decode_header buf with Ok _ -> () | Error _ -> ());
228
205
check true
229
206
230
-
(* {1 Condition Code Conversion} *)
231
-
232
-
let () =
233
-
add_test ~name:"cfdp: condition roundtrip" [ uint8 ] @@ fun n ->
207
+
let test_condition_roundtrip n =
234
208
match Cfdp.condition_of_int n with
235
209
| Some cond ->
236
210
let n' = Cfdp.int_of_condition cond in
237
211
if n <> n' then fail "condition roundtrip mismatch" else check true
238
212
| None -> check true
239
213
240
-
(* {1 Checksum Type Conversion} *)
241
-
242
-
let () =
243
-
add_test ~name:"cfdp: checksum_type roundtrip" [ uint8 ] @@ fun n ->
214
+
let test_checksum_type_roundtrip n =
244
215
match Cfdp.checksum_type_of_int n with
245
216
| Some typ ->
246
217
let n' = Cfdp.int_of_checksum_type typ in
247
218
if n <> n' then fail "checksum_type roundtrip mismatch" else check true
248
219
| None -> check true
249
220
250
-
(* {1 Directive Code Conversion} *)
251
-
252
-
let () =
253
-
add_test ~name:"cfdp: directive_code roundtrip" [ uint8 ] @@ fun n ->
221
+
let test_directive_code_roundtrip n =
254
222
match Cfdp.directive_code_of_int n with
255
223
| Some code ->
256
224
let n' = Cfdp.int_of_directive_code code in
257
225
if n <> n' then fail "directive_code roundtrip mismatch" else check true
258
226
| None -> check true
259
227
260
-
(* {1 Entity ID} *)
261
-
262
-
let () =
263
-
add_test ~name:"cfdp: entity_id of_int negative" [ int ] @@ fun n ->
228
+
let test_entity_id_of_int_negative n =
264
229
if n < 0 then
265
230
match Cfdp.Entity_id.of_int n with
266
231
| Some _ -> fail "negative entity_id accepted"
267
232
| None -> check true
268
233
else check true
269
234
270
-
let () =
271
-
add_test ~name:"cfdp: entity_id of_int64 negative" [ int64 ] @@ fun n ->
235
+
let test_entity_id_of_int64_negative n =
272
236
if n < 0L then
273
237
match Cfdp.Entity_id.of_int64 n with
274
238
| Some _ -> fail "negative entity_id accepted"
275
239
| None -> check true
276
240
else check true
277
241
278
-
let () =
279
-
add_test ~name:"cfdp: entity_id roundtrip" [ int64 ] @@ fun n ->
242
+
let test_entity_id_roundtrip n =
280
243
let n = Int64.abs n in
281
244
if n < 0L then check true
282
245
else
···
285
248
let n' = Cfdp.Entity_id.to_int64 eid in
286
249
if n <> n' then fail "entity_id roundtrip mismatch" else check true
287
250
| None -> fail "valid entity_id rejected"
251
+
252
+
let suite =
253
+
( "cfdp",
254
+
[
255
+
test_case "checksum_modular no crash" [ small_bytes ]
256
+
test_checksum_modular;
257
+
test_case "checksum_crc32 no crash" [ small_bytes ] test_checksum_crc32;
258
+
test_case "checksum_crc32c no crash" [ small_bytes ] test_checksum_crc32c;
259
+
test_case "checksum_null zero" [ small_bytes ] test_checksum_null;
260
+
test_case "checksum deterministic" [ uint8; bytes ]
261
+
test_checksum_deterministic;
262
+
test_case "verify_checksum consistency" [ uint8; bytes ]
263
+
test_verify_checksum;
264
+
test_case "segment_request" [ int64; int64 ] test_segment_request;
265
+
test_case "nak crafted segments"
266
+
[ list (pair int64 int64) ]
267
+
test_nak_crafted;
268
+
test_case "sender1 step" [ sender1_event ] test_sender1_step;
269
+
test_case "sender1 multi" [ list sender1_event ] test_sender1_multi;
270
+
test_case "sender2 step" [ sender2_event ] test_sender2_step;
271
+
test_case "sender2 multi" [ list sender2_event ] test_sender2_multi;
272
+
test_case "receiver1 step" [ bool ] test_receiver1_step;
273
+
test_case "receiver2 step" [ receiver2_event ] test_receiver2_step;
274
+
test_case "receiver2 multi" [ list receiver2_event ] test_receiver2_multi;
275
+
test_case "header parse no crash" [ bytes ] test_header_parse;
276
+
test_case "condition roundtrip" [ uint8 ] test_condition_roundtrip;
277
+
test_case "checksum_type roundtrip" [ uint8 ] test_checksum_type_roundtrip;
278
+
test_case "directive_code roundtrip" [ uint8 ]
279
+
test_directive_code_roundtrip;
280
+
test_case "entity_id of_int negative" [ int ]
281
+
test_entity_id_of_int_negative;
282
+
test_case "entity_id of_int64 negative" [ int64 ]
283
+
test_entity_id_of_int64_negative;
284
+
test_case "entity_id roundtrip" [ int64 ] test_entity_id_roundtrip;
285
+
] )
286
+
287
+
let () = run "cfdp" [ suite ]