Block device abstraction for OCaml 5 with Eio direct-style I/O and Bytesrw integration
fix(lint): resolve E616, E320, E010 across ocaml-block, ocaml-atp, cookeio, linkedin
Replace Alcotest.fail (Fmt.str ...) with Alcotest.failf (E616) in
ocaml-block tests, hoist nested functions (E320), reduce nesting depth
(E010), and accept spaces in cookie values to match browser behavior.
+33
-34
+33
-34
test/test_block.ml
+33
-34
test/test_block.ml
···
17
17
let data = String.make sector_size 'A' in
18
18
(match Block.write blk 0L data with
19
19
| Ok () -> ()
20
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_write_error e));
20
+
| Error e -> Alcotest.failf "%a" Block.pp_write_error e);
21
21
match Block.read blk 0L with
22
22
| Ok read_data -> Alcotest.(check string) "roundtrip" data read_data
23
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_error e)
23
+
| Error e -> Alcotest.failf "%a" Block.pp_error e
24
24
25
25
let test_memory_bounds () =
26
26
let blk = Block.of_memory ~sector_size ~sectors:10L in
···
28
28
(* Valid write *)
29
29
(match Block.write blk 9L data with
30
30
| Ok () -> ()
31
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_write_error e));
31
+
| Error e -> Alcotest.failf "%a" Block.pp_write_error e);
32
32
(* Out of bounds *)
33
33
match Block.write blk 10L data with
34
34
| Ok () -> Alcotest.fail "should have failed"
35
35
| Error (`Invalid_sector 10L) -> ()
36
-
| Error e -> Alcotest.fail (Fmt.str "wrong error: %a" Block.pp_write_error e)
36
+
| Error e -> Alcotest.failf "wrong error: %a" Block.pp_write_error e
37
37
38
38
let test_memory_negative_sector () =
39
39
let blk = Block.of_memory ~sector_size ~sectors:10L in
40
40
match Block.read blk (-1L) with
41
41
| Ok _ -> Alcotest.fail "should have failed"
42
42
| Error (`Invalid_sector _) -> ()
43
-
| Error e -> Alcotest.fail (Fmt.str "wrong error: %a" Block.pp_error e)
43
+
| Error e -> Alcotest.failf "wrong error: %a" Block.pp_error e
44
44
45
45
let test_read_only () =
46
46
let blk = Block.of_memory ~sector_size ~sectors:10L in
···
48
48
(* Write before making read-only *)
49
49
(match Block.write blk 0L data with
50
50
| Ok () -> ()
51
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_write_error e));
51
+
| Error e -> Alcotest.failf "%a" Block.pp_write_error e);
52
52
let ro = Block.read_only blk in
53
53
let info = Block.info ro in
54
54
Alcotest.(check bool) "read_write" false info.read_write;
55
55
(* Read should work *)
56
56
(match Block.read ro 0L with
57
57
| Ok d -> Alcotest.(check string) "read" data d
58
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_error e));
58
+
| Error e -> Alcotest.failf "%a" Block.pp_error e);
59
59
(* Write should fail *)
60
60
match Block.write ro 0L data with
61
61
| Ok () -> Alcotest.fail "should have failed"
62
62
| Error `Read_only -> ()
63
-
| Error e -> Alcotest.fail (Fmt.str "wrong error: %a" Block.pp_write_error e)
63
+
| Error e -> Alcotest.failf "wrong error: %a" Block.pp_write_error e
64
64
65
65
let test_sub () =
66
66
let blk = Block.of_memory ~sector_size ~sectors:10L in
···
69
69
let data = String.make sector_size (Char.chr (i + 65)) in
70
70
match Block.write blk (Int64.of_int i) data with
71
71
| Ok () -> ()
72
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_write_error e)
72
+
| Error e -> Alcotest.failf "%a" Block.pp_write_error e
73
73
done;
74
74
(* Create sub-device for sectors 3-5 *)
75
75
let sub = Block.sub blk ~start:3L ~sectors:3L in
···
78
78
(* Read from sub (sector 0 of sub = sector 3 of original) *)
79
79
match Block.read sub 0L with
80
80
| Ok data -> Alcotest.(check char) "sub read" 'D' data.[0]
81
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_error e)
81
+
| Error e -> Alcotest.failf "%a" Block.pp_error e
82
82
83
83
let test_read_many () =
84
84
let blk = Block.of_memory ~sector_size ~sectors:10L in
···
86
86
let data = String.make sector_size (Char.chr (i + 65)) in
87
87
match Block.write blk (Int64.of_int i) data with
88
88
| Ok () -> ()
89
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_write_error e)
89
+
| Error e -> Alcotest.failf "%a" Block.pp_write_error e
90
90
done;
91
91
match Block.read_many blk 2L 3 with
92
92
| Ok data ->
···
94
94
Alcotest.(check char) "first" 'C' data.[0];
95
95
Alcotest.(check char) "second" 'D' data.[sector_size];
96
96
Alcotest.(check char) "third" 'E' data.[2 * sector_size]
97
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_error e)
97
+
| Error e -> Alcotest.failf "%a" Block.pp_error e
98
98
99
99
let test_crc32c () =
100
100
let blk = Block.of_memory ~sector_size ~sectors:10L in
···
106
106
let data = String.make (sector_size - 4) 'X' in
107
107
(match Block.write crc_blk 0L data with
108
108
| Ok () -> ()
109
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_write_error e));
109
+
| Error e -> Alcotest.failf "%a" Block.pp_write_error e);
110
110
match Block.read crc_blk 0L with
111
111
| Ok read_data -> Alcotest.(check string) "crc roundtrip" data read_data
112
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_error e)
112
+
| Error e -> Alcotest.failf "%a" Block.pp_error e
113
113
114
114
let test_crc32c_corruption () =
115
115
let blk = Block.of_memory ~sector_size ~sectors:10L in
···
117
117
let data = String.make (sector_size - 4) 'Y' in
118
118
(match Block.write crc_blk 0L data with
119
119
| Ok () -> ()
120
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_write_error e));
120
+
| Error e -> Alcotest.failf "%a" Block.pp_write_error e);
121
121
(* Corrupt the underlying data *)
122
122
let raw =
123
123
match Block.read blk 0L with Ok d -> d | Error _ -> Alcotest.fail "read"
···
126
126
Bytes.set corrupted 0 'Z';
127
127
(match Block.write blk 0L (Bytes.to_string corrupted) with
128
128
| Ok () -> ()
129
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_write_error e));
129
+
| Error e -> Alcotest.failf "%a" Block.pp_write_error e);
130
130
(* Read through CRC layer should fail *)
131
131
match Block.read crc_blk 0L with
132
132
| Ok _ -> Alcotest.fail "should have detected corruption"
133
133
| Error (`Read_error msg) ->
134
134
Alcotest.(check bool) "crc error" true (String.length msg > 0)
135
-
| Error e -> Alcotest.fail (Fmt.str "wrong error: %a" Block.pp_error e)
135
+
| Error e -> Alcotest.failf "wrong error: %a" Block.pp_error e
136
136
137
137
let test_of_string () =
138
138
let original =
···
146
146
| Ok data ->
147
147
let expected = String.sub original sector_size sector_size in
148
148
Alcotest.(check string) "read sector 1" expected data
149
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_error e)
149
+
| Error e -> Alcotest.failf "%a" Block.pp_error e
150
150
151
151
let test_close () =
152
152
let blk = Block.of_memory ~sector_size ~sectors:10L in
···
154
154
match Block.read blk 0L with
155
155
| Ok _ -> Alcotest.fail "should have failed after close"
156
156
| Error `Disconnected -> ()
157
-
| Error e -> Alcotest.fail (Fmt.str "wrong error: %a" Block.pp_error e)
157
+
| Error e -> Alcotest.failf "wrong error: %a" Block.pp_error e
158
158
159
159
let test_file () =
160
160
Eio_main.run @@ fun env ->
···
164
164
let data = String.make sector_size 'F' in
165
165
(match Block.write blk 5L data with
166
166
| Ok () -> ()
167
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_write_error e));
167
+
| Error e -> Alcotest.failf "%a" Block.pp_write_error e);
168
168
Block.sync blk;
169
169
(match Block.read blk 5L with
170
170
| Ok d -> Alcotest.(check string) "file roundtrip" data d
171
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_error e));
171
+
| Error e -> Alcotest.failf "%a" Block.pp_error e);
172
172
Block.close blk;
173
173
(* Cleanup *)
174
174
Eio.Path.unlink path
···
179
179
let data = String.make sector_size (Char.chr (i + 65)) in
180
180
match Block.write blk (Int64.of_int i) data with
181
181
| Ok () -> ()
182
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_write_error e)
182
+
| Error e -> Alcotest.failf "%a" Block.pp_write_error e
183
183
done;
184
184
match
185
185
Block.fold ~f:(fun _ data acc -> Ok (acc + Char.code data.[0])) blk 0
···
187
187
| Ok sum ->
188
188
(* A=65, B=66, C=67, D=68, E=69 => sum = 335 *)
189
189
Alcotest.(check int) "fold sum" 335 sum
190
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_error e)
190
+
| Error e -> Alcotest.failf "%a" Block.pp_error e
191
191
192
192
let test_compare_equal () =
193
193
let a = Block.of_memory ~sector_size ~sectors:10L in
···
200
200
done;
201
201
match Block.compare a b with
202
202
| Ok () -> ()
203
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_compare_error e)
203
+
| Error e -> Alcotest.failf "%a" Block.pp_compare_error e
204
204
205
205
let test_compare_different () =
206
206
let a = Block.of_memory ~sector_size ~sectors:10L in
···
216
216
match Block.compare a b with
217
217
| Ok () -> Alcotest.fail "should have detected difference"
218
218
| Error (`Contents_differ 5L) -> ()
219
-
| Error e ->
220
-
Alcotest.fail (Fmt.str "wrong error: %a" Block.pp_compare_error e)
219
+
| Error e -> Alcotest.failf "wrong error: %a" Block.pp_compare_error e
221
220
222
221
let test_copy () =
223
222
let src = Block.of_memory ~sector_size ~sectors:10L in
···
229
228
done;
230
229
(match Block.copy ~src ~dst with
231
230
| Ok () -> ()
232
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_copy_error e));
231
+
| Error e -> Alcotest.failf "%a" Block.pp_copy_error e);
233
232
match Block.compare src dst with
234
233
| Ok () -> ()
235
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_compare_error e)
234
+
| Error e -> Alcotest.failf "%a" Block.pp_compare_error e
236
235
237
236
let test_sparse_copy () =
238
237
let src = Block.of_memory ~sector_size ~sectors:10L in
···
245
244
let _ = Block.fill dst 'X' in
246
245
(match Block.sparse_copy ~src ~dst with
247
246
| Ok () -> ()
248
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_copy_error e));
247
+
| Error e -> Alcotest.failf "%a" Block.pp_copy_error e);
249
248
(* Check copied sectors *)
250
249
(match Block.read dst 0L with
251
250
| Ok d -> Alcotest.(check char) "sector 0" 'A' d.[0]
252
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_error e));
251
+
| Error e -> Alcotest.failf "%a" Block.pp_error e);
253
252
(match Block.read dst 5L with
254
253
| Ok d -> Alcotest.(check char) "sector 5" 'F' d.[0]
255
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_error e));
254
+
| Error e -> Alcotest.failf "%a" Block.pp_error e);
256
255
(* Check skipped sector still has X pattern *)
257
256
match Block.read dst 3L with
258
257
| Ok d -> Alcotest.(check char) "sector 3" 'X' d.[0]
259
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_error e)
258
+
| Error e -> Alcotest.failf "%a" Block.pp_error e
260
259
261
260
let test_zero () =
262
261
let blk = Block.of_memory ~sector_size ~sectors:10L in
263
262
let _ = Block.fill blk 'X' in
264
263
(match Block.zero blk with
265
264
| Ok () -> ()
266
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_write_error e));
265
+
| Error e -> Alcotest.failf "%a" Block.pp_write_error e);
267
266
for i = 0 to 9 do
268
267
match Block.read blk (Int64.of_int i) with
269
268
| Ok d -> Alcotest.(check bool) "is zero" true (Block.is_zero d)
270
-
| Error e -> Alcotest.fail (Fmt.str "%a" Block.pp_error e)
269
+
| Error e -> Alcotest.failf "%a" Block.pp_error e
271
270
done
272
271
273
272
let test_is_zero () =