Debian Codegraph @

test/ioctl/identify.c

raw
1 // SPDX-License-Identifier: LGPL-2.1-or-later
2
3 #include <errno.h>
4 #include <stdlib.h>
5
6 #include <libnvme.h>
7
8 #include "mock.h"
9 #include "util.h"
10
11 #define TEST_FD 0xFD
12 #define TEST_NSID 0x12345678
13 #define TEST_NVMSETID 0xABCD
14 #define TEST_UUID 123
15 #define TEST_CSI NVME_CSI_KV
16 #define TEST_CNTID 0x4321
17 #define TEST_DOMID 0xFEDC
18 #define TEST_ENDGID 0x0123
19 #define TEST_FIDX 0xF
20 #define TEST_SC NVME_SC_INVALID_FIELD
21
22 static void test_ns(void)
23 {
24 struct nvme_id_ns expected_id, id = {};
25 struct mock_cmd mock_admin_cmd = {
26 .opcode = nvme_admin_identify,
27 .nsid = TEST_NSID,
28 .data_len = sizeof(expected_id),
29 .cdw10 = NVME_IDENTIFY_CNS_NS,
30 .out_data = &expected_id,
31 };
32 int err;
33
34 arbitrary(&expected_id, sizeof(expected_id));
35 set_mock_admin_cmds(&mock_admin_cmd, 1);
36 err = nvme_identify_ns(TEST_FD, TEST_NSID, &id);
37 end_mock_cmds();
38 check(err == 0, "identify returned error %d, errno %m", err);
39 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
40 }
41
42 static void test_ctrl(void)
43 {
44 struct nvme_id_ctrl expected_id, id = {};
45 struct mock_cmd mock_admin_cmd = {
46 .opcode = nvme_admin_identify,
47 .data_len = sizeof(expected_id),
48 .cdw10 = NVME_IDENTIFY_CNS_CTRL,
49 .out_data = &expected_id,
50 };
51 int err;
52
53 arbitrary(&expected_id, sizeof(expected_id));
54 set_mock_admin_cmds(&mock_admin_cmd, 1);
55 err = nvme_identify_ctrl(TEST_FD, &id);
56 end_mock_cmds();
57 check(err == 0, "identify returned error %d, errno %m", err);
58 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
59 }
60
61 static void test_active_ns_list(void)
62 {
63 struct nvme_ns_list expected_id, id = {};
64 struct mock_cmd mock_admin_cmd = {
65 .opcode = nvme_admin_identify,
66 .nsid = TEST_NSID,
67 .data_len = sizeof(expected_id),
68 .cdw10 = NVME_IDENTIFY_CNS_NS_ACTIVE_LIST,
69 .out_data = &expected_id,
70 };
71 int err;
72
73 arbitrary(&expected_id, sizeof(expected_id));
74 set_mock_admin_cmds(&mock_admin_cmd, 1);
75 err = nvme_identify_active_ns_list(TEST_FD, TEST_NSID, &id);
76 end_mock_cmds();
77 check(err == 0, "identify returned error %d, errno %m", err);
78 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
79 }
80
81 static void test_ns_descs(void)
82 {
83 uint8_t expected_id[NVME_IDENTIFY_DATA_SIZE];
84 struct nvme_ns_id_desc *id;
85 struct mock_cmd mock_admin_cmd = {
86 .opcode = nvme_admin_identify,
87 .nsid = TEST_NSID,
88 .data_len = sizeof(expected_id),
89 .cdw10 = NVME_IDENTIFY_CNS_NS_DESC_LIST,
90 .out_data = &expected_id,
91 };
92 int err;
93
94 arbitrary(expected_id, sizeof(expected_id));
95 id = calloc(1, NVME_IDENTIFY_DATA_SIZE);
96 check(id, "memory allocation failed");
97 set_mock_admin_cmds(&mock_admin_cmd, 1);
98 err = nvme_identify_ns_descs(TEST_FD, TEST_NSID, id);
99 end_mock_cmds();
100 check(err == 0, "identify returned error %d, errno %m", err);
101 cmp(id, expected_id, sizeof(expected_id), "incorrect identify data");
102 free(id);
103 }
104
105 static void test_nvmset_list(void)
106 {
107 struct nvme_id_nvmset_list expected_id, id = {};
108 struct mock_cmd mock_admin_cmd = {
109 .opcode = nvme_admin_identify,
110 .data_len = sizeof(expected_id),
111 .cdw10 = NVME_IDENTIFY_CNS_NVMSET_LIST,
112 .cdw11 = TEST_NVMSETID,
113 .out_data = &expected_id,
114 };
115 int err;
116
117 arbitrary(&expected_id, sizeof(expected_id));
118 set_mock_admin_cmds(&mock_admin_cmd, 1);
119 err = nvme_identify_nvmset_list(TEST_FD, TEST_NVMSETID, &id);
120 end_mock_cmds();
121 check(err == 0, "identify returned error %d, errno %m", err);
122 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
123 }
124
125 static void test_ns_csi(void)
126 {
127 uint8_t expected_id[NVME_IDENTIFY_DATA_SIZE];
128 uint8_t id[NVME_IDENTIFY_DATA_SIZE] = {};
129 struct mock_cmd mock_admin_cmd = {
130 .opcode = nvme_admin_identify,
131 .nsid = TEST_NSID,
132 .data_len = sizeof(expected_id),
133 .cdw10 = NVME_IDENTIFY_CNS_CSI_NS,
134 .cdw11 = TEST_CSI << 24,
135 .cdw14 = TEST_UUID,
136 .out_data = expected_id,
137 };
138 int err;
139
140 arbitrary(expected_id, sizeof(expected_id));
141 set_mock_admin_cmds(&mock_admin_cmd, 1);
142 err = nvme_identify_ns_csi(TEST_FD, TEST_NSID, TEST_UUID, TEST_CSI, id);
143 end_mock_cmds();
144 check(err == 0, "identify returned error %d, errno %m", err);
145 cmp(id, expected_id, sizeof(id), "incorrect identify data");
146 }
147
148 static void test_zns_identify_ns(void)
149 {
150 struct nvme_zns_id_ns expected_id, id = {};
151 struct mock_cmd mock_admin_cmd = {
152 .opcode = nvme_admin_identify,
153 .nsid = TEST_NSID,
154 .data_len = sizeof(expected_id),
155 .cdw10 = NVME_IDENTIFY_CNS_CSI_NS,
156 .cdw11 = NVME_CSI_ZNS << 24,
157 .out_data = &expected_id,
158 };
159 int err;
160
161 arbitrary(&expected_id, sizeof(expected_id));
162 set_mock_admin_cmds(&mock_admin_cmd, 1);
163 err = nvme_zns_identify_ns(TEST_FD, TEST_NSID, &id);
164 end_mock_cmds();
165 check(err == 0, "identify returned error %d, errno %m", err);
166 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
167 }
168
169 static void test_nvm_identify_ctrl(void)
170 {
171 struct nvme_id_ctrl_nvm expected_id, id = {};
172 struct mock_cmd mock_admin_cmd = {
173 .opcode = nvme_admin_identify,
174 .data_len = sizeof(expected_id),
175 .cdw10 = NVME_IDENTIFY_CNS_CSI_CTRL,
176 .cdw11 = NVME_CSI_NVM << 24,
177 .out_data = &expected_id,
178 };
179 int err;
180
181 arbitrary(&expected_id, sizeof(expected_id));
182 set_mock_admin_cmds(&mock_admin_cmd, 1);
183 err = nvme_nvm_identify_ctrl(TEST_FD, &id);
184 end_mock_cmds();
185 check(err == 0, "identify returned error %d, errno %m", err);
186 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
187 }
188
189 static void test_zns_identify_ctrl(void)
190 {
191 struct nvme_zns_id_ctrl expected_id, id = {};
192 struct mock_cmd mock_admin_cmd = {
193 .opcode = nvme_admin_identify,
194 .data_len = sizeof(expected_id),
195 .cdw10 = NVME_IDENTIFY_CNS_CSI_CTRL,
196 .cdw11 = NVME_CSI_ZNS << 24,
197 .out_data = &expected_id,
198 };
199 int err;
200
201 arbitrary(&expected_id, sizeof(expected_id));
202 set_mock_admin_cmds(&mock_admin_cmd, 1);
203 err = nvme_zns_identify_ctrl(TEST_FD, &id);
204 end_mock_cmds();
205 check(err == 0, "identify returned error %d, errno %m", err);
206 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
207 }
208
209 static void test_active_ns_list_csi(void)
210 {
211 struct nvme_ns_list expected_id, id = {};
212 struct mock_cmd mock_admin_cmd = {
213 .opcode = nvme_admin_identify,
214 .nsid = TEST_NSID,
215 .data_len = sizeof(expected_id),
216 .cdw10 = NVME_IDENTIFY_CNS_CSI_NS_ACTIVE_LIST,
217 .cdw11 = TEST_CSI << 24,
218 .out_data = &expected_id,
219 };
220 int err;
221
222 arbitrary(&expected_id, sizeof(expected_id));
223 set_mock_admin_cmds(&mock_admin_cmd, 1);
224 err = nvme_identify_active_ns_list_csi(
225 TEST_FD, TEST_NSID, TEST_CSI, &id);
226 end_mock_cmds();
227 check(err == 0, "identify returned error %d, errno %m", err);
228 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
229 }
230
231 static void test_independent_identify_ns(void)
232 {
233 struct nvme_id_independent_id_ns expected_id, id = {};
234 struct mock_cmd mock_admin_cmd = {
235 .opcode = nvme_admin_identify,
236 .nsid = TEST_NSID,
237 .data_len = sizeof(expected_id),
238 .cdw10 = NVME_IDENTIFY_CNS_CSI_INDEPENDENT_ID_NS,
239 .out_data = &expected_id,
240 };
241 int err;
242
243 arbitrary(&expected_id, sizeof(expected_id));
244 set_mock_admin_cmds(&mock_admin_cmd, 1);
245 /* That's a mouthful! */
246 err = nvme_identify_independent_identify_ns(TEST_FD, TEST_NSID, &id);
247 end_mock_cmds();
248 check(err == 0, "identify returned error %d, errno %m", err);
249 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
250 }
251
252 static void test_allocated_ns_list(void)
253 {
254 struct nvme_ns_list expected_id, id = {};
255 struct mock_cmd mock_admin_cmd = {
256 .opcode = nvme_admin_identify,
257 .nsid = TEST_NSID,
258 .data_len = sizeof(expected_id),
259 .cdw10 = NVME_IDENTIFY_CNS_ALLOCATED_NS_LIST,
260 .out_data = &expected_id,
261 };
262 int err;
263
264 arbitrary(&expected_id, sizeof(expected_id));
265 set_mock_admin_cmds(&mock_admin_cmd, 1);
266 err = nvme_identify_allocated_ns_list(TEST_FD, TEST_NSID, &id);
267 end_mock_cmds();
268 check(err == 0, "identify returned error %d, errno %m", err);
269 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
270 }
271
272 static void test_allocated_ns(void)
273 {
274 struct nvme_id_ns expected_id, id = {};
275 struct mock_cmd mock_admin_cmd = {
276 .opcode = nvme_admin_identify,
277 .nsid = TEST_NSID,
278 .data_len = sizeof(expected_id),
279 .cdw10 = NVME_IDENTIFY_CNS_ALLOCATED_NS,
280 .out_data = &expected_id,
281 };
282 int err;
283
284 arbitrary(&expected_id, sizeof(expected_id));
285 set_mock_admin_cmds(&mock_admin_cmd, 1);
286 err = nvme_identify_allocated_ns(TEST_FD, TEST_NSID, &id);
287 end_mock_cmds();
288 check(err == 0, "identify returned error %d, errno %m", err);
289 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
290 }
291
292 static void test_nsid_ctrl_list(void)
293 {
294 struct nvme_ctrl_list expected_id, id = {};
295 struct mock_cmd mock_admin_cmd = {
296 .opcode = nvme_admin_identify,
297 .nsid = TEST_NSID,
298 .data_len = sizeof(expected_id),
299 .cdw10 = TEST_CNTID << 16
300 | NVME_IDENTIFY_CNS_NS_CTRL_LIST,
301 .out_data = &expected_id,
302 };
303 int err;
304
305 arbitrary(&expected_id, sizeof(expected_id));
306 set_mock_admin_cmds(&mock_admin_cmd, 1);
307 err = nvme_identify_nsid_ctrl_list(TEST_FD, TEST_NSID, TEST_CNTID, &id);
308 end_mock_cmds();
309 check(err == 0, "identify returned error %d, errno %m", err);
310 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
311 }
312
313 static void test_ctrl_list(void)
314 {
315 struct nvme_ctrl_list expected_id, id = {};
316 struct mock_cmd mock_admin_cmd = {
317 .opcode = nvme_admin_identify,
318 .data_len = sizeof(expected_id),
319 .cdw10 = TEST_CNTID << 16
320 | NVME_IDENTIFY_CNS_CTRL_LIST,
321 .out_data = &expected_id,
322 };
323 int err;
324
325 arbitrary(&expected_id, sizeof(expected_id));
326 set_mock_admin_cmds(&mock_admin_cmd, 1);
327 err = nvme_identify_ctrl_list(TEST_FD, TEST_CNTID, &id);
328 end_mock_cmds();
329 check(err == 0, "identify returned error %d, errno %m", err);
330 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
331 }
332
333 static void test_primary_ctrl(void)
334 {
335 struct nvme_primary_ctrl_cap expected_id, id = {};
336 struct mock_cmd mock_admin_cmd = {
337 .opcode = nvme_admin_identify,
338 .data_len = sizeof(expected_id),
339 .cdw10 = TEST_CNTID << 16
340 | NVME_IDENTIFY_CNS_PRIMARY_CTRL_CAP,
341 .out_data = &expected_id,
342 };
343 int err;
344
345 arbitrary(&expected_id, sizeof(expected_id));
346 set_mock_admin_cmds(&mock_admin_cmd, 1);
347 err = nvme_identify_primary_ctrl(TEST_FD, TEST_CNTID, &id);
348 end_mock_cmds();
349 check(err == 0, "identify returned error %d, errno %m", err);
350 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
351 }
352
353 static void test_secondary_ctrl_list(void)
354 {
355 struct nvme_secondary_ctrl_list expected_id, id = {};
356 struct mock_cmd mock_admin_cmd = {
357 .opcode = nvme_admin_identify,
358 .data_len = sizeof(expected_id),
359 .cdw10 = TEST_CNTID << 16
360 | NVME_IDENTIFY_CNS_SECONDARY_CTRL_LIST,
361 .out_data = &expected_id,
362 };
363 int err;
364
365 arbitrary(&expected_id, sizeof(expected_id));
366 set_mock_admin_cmds(&mock_admin_cmd, 1);
367 err = nvme_identify_secondary_ctrl_list(TEST_FD, TEST_CNTID, &id);
368 end_mock_cmds();
369 check(err == 0, "identify returned error %d, errno %m", err);
370 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
371 }
372
373 static void test_ns_granularity(void)
374 {
375 struct nvme_id_ns_granularity_list expected_id, id = {};
376 struct mock_cmd mock_admin_cmd = {
377 .opcode = nvme_admin_identify,
378 .data_len = sizeof(expected_id),
379 .cdw10 = NVME_IDENTIFY_CNS_NS_GRANULARITY,
380 .out_data = &expected_id,
381 };
382 int err;
383
384 arbitrary(&expected_id, sizeof(expected_id));
385 set_mock_admin_cmds(&mock_admin_cmd, 1);
386 err = nvme_identify_ns_granularity(TEST_FD, &id);
387 end_mock_cmds();
388 check(err == 0, "identify returned error %d, errno %m", err);
389 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
390 }
391
392 static void test_uuid(void)
393 {
394 struct nvme_id_uuid_list expected_id, id = {};
395 struct mock_cmd mock_admin_cmd = {
396 .opcode = nvme_admin_identify,
397 .data_len = sizeof(expected_id),
398 .cdw10 = NVME_IDENTIFY_CNS_UUID_LIST,
399 .out_data = &expected_id,
400 };
401 int err;
402
403 arbitrary(&expected_id, sizeof(expected_id));
404 set_mock_admin_cmds(&mock_admin_cmd, 1);
405 err = nvme_identify_uuid(TEST_FD, &id);
406 end_mock_cmds();
407 check(err == 0, "identify returned error %d, errno %m", err);
408 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
409 }
410
411 static void test_domain_list(void)
412 {
413 struct nvme_id_domain_list expected_id, id = {};
414 struct mock_cmd mock_admin_cmd = {
415 .opcode = nvme_admin_identify,
416 .data_len = sizeof(expected_id),
417 .cdw10 = NVME_IDENTIFY_CNS_DOMAIN_LIST,
418 .cdw11 = TEST_DOMID,
419 .out_data = &expected_id,
420 };
421 int err;
422
423 arbitrary(&expected_id, sizeof(expected_id));
424 set_mock_admin_cmds(&mock_admin_cmd, 1);
425 err = nvme_identify_domain_list(TEST_FD, TEST_DOMID, &id);
426 end_mock_cmds();
427 check(err == 0, "identify returned error %d, errno %m", err);
428 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
429 }
430
431 static void test_endurance_group_list(void)
432 {
433 struct nvme_id_endurance_group_list expected_id, id = {};
434 struct mock_cmd mock_admin_cmd = {
435 .opcode = nvme_admin_identify,
436 .data_len = sizeof(expected_id),
437 .cdw10 = NVME_IDENTIFY_CNS_ENDURANCE_GROUP_ID,
438 .cdw11 = TEST_ENDGID,
439 .out_data = &expected_id,
440 };
441 int err;
442
443 arbitrary(&expected_id, sizeof(expected_id));
444 set_mock_admin_cmds(&mock_admin_cmd, 1);
445 err = nvme_identify_endurance_group_list(TEST_FD, TEST_ENDGID, &id);
446 end_mock_cmds();
447 check(err == 0, "identify returned error %d, errno %m", err);
448 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
449 }
450
451 static void test_allocated_ns_list_csi(void)
452 {
453 struct nvme_ns_list expected_id, id = {};
454 struct mock_cmd mock_admin_cmd = {
455 .opcode = nvme_admin_identify,
456 .nsid = TEST_NSID,
457 .data_len = sizeof(expected_id),
458 .cdw10 = NVME_IDENTIFY_CNS_CSI_ALLOCATED_NS_LIST,
459 .cdw11 = TEST_CSI << 24,
460 .out_data = &expected_id,
461 };
462 int err;
463
464 arbitrary(&expected_id, sizeof(expected_id));
465 set_mock_admin_cmds(&mock_admin_cmd, 1);
466 err = nvme_identify_allocated_ns_list_csi(
467 TEST_FD, TEST_NSID, TEST_CSI, &id);
468 end_mock_cmds();
469 check(err == 0, "identify returned error %d, errno %m", err);
470 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
471 }
472
473 static void test_iocs(void)
474 {
475 struct nvme_id_iocs expected_id, id = {};
476 struct mock_cmd mock_admin_cmd = {
477 .opcode = nvme_admin_identify,
478 .data_len = sizeof(expected_id),
479 .cdw10 = TEST_CNTID << 16
480 | NVME_IDENTIFY_CNS_COMMAND_SET_STRUCTURE,
481 .out_data = &expected_id,
482 };
483 int err;
484
485 arbitrary(&expected_id, sizeof(expected_id));
486 set_mock_admin_cmds(&mock_admin_cmd, 1);
487 err = nvme_identify_iocs(TEST_FD, TEST_CNTID, &id);
488 end_mock_cmds();
489 check(err == 0, "identify returned error %d, errno %m", err);
490 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
491 }
492
493 /*
494 * All identify functions tail-call nvme_identify(),
495 * so testing errors in any of them will do
496 */
497
498 static void test_status_code_error(void)
499 {
500 struct nvme_id_nvmset_list id = {};
501 struct mock_cmd mock_admin_cmd = {
502 .opcode = nvme_admin_identify,
503 .data_len = sizeof(id),
504 .cdw10 = NVME_IDENTIFY_CNS_NVMSET_LIST,
505 .cdw11 = TEST_NVMSETID,
506 .err = TEST_SC,
507 };
508 int err;
509
510 set_mock_admin_cmds(&mock_admin_cmd, 1);
511 err = nvme_identify_nvmset_list(TEST_FD, TEST_NVMSETID, &id);
512 end_mock_cmds();
513 check(err == TEST_SC, "got error %d, expected %d", err, TEST_SC);
514 }
515
516 static void test_kernel_error(void)
517 {
518 struct nvme_id_ns id = {};
519 struct mock_cmd mock_admin_cmd = {
520 .opcode = nvme_admin_identify,
521 .nsid = TEST_NSID,
522 .data_len = sizeof(id),
523 .cdw10 = NVME_IDENTIFY_CNS_NS,
524 .err = -EIO,
525 };
526 int err;
527
528 set_mock_admin_cmds(&mock_admin_cmd, 1);
529 err = nvme_identify_ns(TEST_FD, TEST_NSID, &id);
530 end_mock_cmds();
531 check(err == -1, "got error %d, expected -1", err);
532 check(errno == EIO, "unexpected error %m");
533 }
534
535 static void test_identify_ns_csi_user_data_format(void)
536 {
537 struct nvme_id_ns expected_id, id = {};
538 struct mock_cmd mock_admin_cmd = {
539 .opcode = nvme_admin_identify,
540 .nsid = NVME_NSID_NONE,
541 .data_len = sizeof(expected_id),
542 .cdw10 = NVME_IDENTIFY_CNS_NS_USER_DATA_FORMAT,
543 //TEST_CSI=NVME_CSI_KV does not implement this command
544 .cdw11 = (TEST_FIDX << 0) | (NVME_CSI_NVM << 24),
545 .cdw14 = TEST_UUID,
546 .out_data = &expected_id,
547 };
548 int err;
549
550 arbitrary(&expected_id, sizeof(expected_id));
551 set_mock_admin_cmds(&mock_admin_cmd, 1);
552 err = nvme_identify_ns_csi_user_data_format(
553 TEST_FD, TEST_FIDX, TEST_UUID, NVME_CSI_NVM, &id);
554 end_mock_cmds();
555 check(err == 0, "identify returned error %d, errno %m", err);
556 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
557 }
558
559 static void test_identify_iocs_ns_csi_user_data_format(void)
560 {
561 struct nvme_id_ns expected_id, id = {};
562 struct mock_cmd mock_admin_cmd = {
563 .opcode = nvme_admin_identify,
564 .nsid = NVME_NSID_NONE,
565 .data_len = sizeof(expected_id),
566 .cdw10 = NVME_IDENTIFY_CNS_CSI_NS_USER_DATA_FORMAT,
567 .cdw11 = (TEST_FIDX << 0) | (TEST_CSI << 24),
568 .cdw14 = TEST_UUID,
569 .out_data = &expected_id,
570 };
571 int err;
572
573 arbitrary(&expected_id, sizeof(expected_id));
574 set_mock_admin_cmds(&mock_admin_cmd, 1);
575 err = nvme_identify_iocs_ns_csi_user_data_format(
576 TEST_FD, TEST_FIDX, TEST_UUID, TEST_CSI, &id);
577 end_mock_cmds();
578 check(err == 0, "identify returned error %d, errno %m", err);
579 cmp(&id, &expected_id, sizeof(id), "incorrect identify data");
580 }
581
582 static void run_test(const char *test_name, void (*test_fn)(void))
583 {
584 printf("Running test %s...", test_name);
585 fflush(stdout);
586 test_fn();
587 puts(" OK");
588 }
589
590 #define RUN_TEST(name) run_test(#name, test_ ## name)
591
592 int main(void)
593 {
594 set_mock_fd(TEST_FD);
595 RUN_TEST(ns);
596 RUN_TEST(ctrl);
597 RUN_TEST(active_ns_list);
598 RUN_TEST(ns_descs);
599 RUN_TEST(nvmset_list);
600 RUN_TEST(ns_csi);
601 RUN_TEST(zns_identify_ns);
602 RUN_TEST(nvm_identify_ctrl);
603 RUN_TEST(zns_identify_ctrl);
604 RUN_TEST(active_ns_list_csi);
605 RUN_TEST(independent_identify_ns);
606 RUN_TEST(allocated_ns_list);
607 RUN_TEST(allocated_ns);
608 RUN_TEST(nsid_ctrl_list);
609 RUN_TEST(ctrl_list);
610 RUN_TEST(primary_ctrl);
611 RUN_TEST(secondary_ctrl_list);
612 RUN_TEST(ns_granularity);
613 RUN_TEST(uuid);
614 RUN_TEST(domain_list);
615 RUN_TEST(endurance_group_list);
616 RUN_TEST(allocated_ns_list_csi);
617 RUN_TEST(iocs);
618 RUN_TEST(status_code_error);
619 RUN_TEST(kernel_error);
620 RUN_TEST(identify_ns_csi_user_data_format);
621 RUN_TEST(identify_iocs_ns_csi_user_data_format);
622 }