d/numam-spdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

ut: make use of CUnit macro to reduce duplications

Browse Source 
CUnit provides a helper macro CU_ADD_TEST() that
simplifies usage of CU_add_test() function.
Test name no longer needs to be provided,
as it will be inherited from function name.

This is a follow up to
https://review.spdk.io/gerrit/c/spdk/spdk/+/931

Change-Id: I8078f02e08b14f12328ae022d7090ba13fbd64e4
Signed-off-by: Vitaliy Mysak <vitaliy.mysak@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/1239
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
This commit is contained in:
Vitaliy Mysak 2020-03-11 20:15:39 +01:00 committed by Tomasz Zawadzki
parent 78b696bca5
commit dcf0ca15c9
83 changed files with 691 additions and 963 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
test/unit/lib/bdev/bdev.c/bdev_ut.c
View File

@ -3128,32 +3128,31 @@ main(int argc, char **argv)
suite = CU_add_suite("bdev", null_init, null_clean);
CU_add_test(suite, "bytes_to_blocks_test", bytes_to_blocks_test);
CU_add_test(suite, "num_blocks_test", num_blocks_test);
CU_add_test(suite, "io_valid", io_valid_test);
CU_add_test(suite, "open_write", open_write_test);
CU_add_test(suite, "alias_add_del", alias_add_del_test);
CU_add_test(suite, "get_device_stat", get_device_stat_test);
CU_add_test(suite, "bdev_io_types", bdev_io_types_test);
CU_add_test(suite, "bdev_io_wait", bdev_io_wait_test);
CU_add_test(suite, "bdev_io_spans_boundary", bdev_io_spans_boundary_test);
CU_add_test(suite, "bdev_io_split", bdev_io_split_test);
CU_add_test(suite, "bdev_io_split_with_io_wait", bdev_io_split_with_io_wait);
CU_add_test(suite, "bdev_io_alignment_with_boundary", bdev_io_alignment_with_boundary);
CU_add_test(suite, "bdev_io_alignment", bdev_io_alignment);
CU_add_test(suite, "bdev_histograms", bdev_histograms);
CU_add_test(suite, "bdev_write_zeroes", bdev_write_zeroes);
CU_add_test(suite, "bdev_compare_and_write", bdev_compare_and_write);
CU_add_test(suite, "bdev_compare", bdev_compare);
CU_add_test(suite, "bdev_open_while_hotremove", bdev_open_while_hotremove);
CU_add_test(suite, "bdev_close_while_hotremove", bdev_close_while_hotremove);
CU_add_test(suite, "bdev_open_ext", bdev_open_ext);
CU_add_test(suite, "bdev_set_io_timeout", bdev_set_io_timeout);
CU_add_test(suite, "lba_range_overlap", lba_range_overlap);
CU_add_test(suite, "lock_lba_range_check_ranges", lock_lba_range_check_ranges);
CU_add_test(suite, "lock_lba_range_with_io_outstanding",
lock_lba_range_with_io_outstanding);
CU_add_test(suite, "lock_lba_range_overlapped", lock_lba_range_overlapped);
CU_ADD_TEST(suite, bytes_to_blocks_test);
CU_ADD_TEST(suite, num_blocks_test);
CU_ADD_TEST(suite, io_valid_test);
CU_ADD_TEST(suite, open_write_test);
CU_ADD_TEST(suite, alias_add_del_test);
CU_ADD_TEST(suite, get_device_stat_test);
CU_ADD_TEST(suite, bdev_io_types_test);
CU_ADD_TEST(suite, bdev_io_wait_test);
CU_ADD_TEST(suite, bdev_io_spans_boundary_test);
CU_ADD_TEST(suite, bdev_io_split_test);
CU_ADD_TEST(suite, bdev_io_split_with_io_wait);
CU_ADD_TEST(suite, bdev_io_alignment_with_boundary);
CU_ADD_TEST(suite, bdev_io_alignment);
CU_ADD_TEST(suite, bdev_histograms);
CU_ADD_TEST(suite, bdev_write_zeroes);
CU_ADD_TEST(suite, bdev_compare_and_write);
CU_ADD_TEST(suite, bdev_compare);
CU_ADD_TEST(suite, bdev_open_while_hotremove);
CU_ADD_TEST(suite, bdev_close_while_hotremove);
CU_ADD_TEST(suite, bdev_open_ext);
CU_ADD_TEST(suite, bdev_set_io_timeout);
CU_ADD_TEST(suite, lba_range_overlap);
CU_ADD_TEST(suite, lock_lba_range_check_ranges);
CU_ADD_TEST(suite, lock_lba_range_with_io_outstanding);
CU_ADD_TEST(suite, lock_lba_range_overlapped);
allocate_threads(1);
set_thread(0);

10
test/unit/lib/bdev/bdev_ocssd.c/bdev_ocssd_ut.c
View File

@ -1167,11 +1167,11 @@ main(int argc, const char **argv)
suite = CU_add_suite("ocssd", NULL, NULL);
CU_add_test(suite, "test_create_controller", test_create_controller);
CU_add_test(suite, "test_device_geometry", test_device_geometry);
CU_add_test(suite, "test_lba_translation", test_lba_translation);
CU_add_test(suite, "test_parallel_unit_range", test_parallel_unit_range);
CU_add_test(suite, "test_get_zone_info", test_get_zone_info);
CU_ADD_TEST(suite, test_create_controller);
CU_ADD_TEST(suite, test_device_geometry);
CU_ADD_TEST(suite, test_lba_translation);
CU_ADD_TEST(suite, test_parallel_unit_range);
CU_ADD_TEST(suite, test_get_zone_info);
g_thread = spdk_thread_create("test", NULL);
spdk_set_thread(g_thread);

12
test/unit/lib/bdev/bdev_zone.c/bdev_zone_ut.c
View File

@ -414,12 +414,12 @@ main(int argc, char **argv)
CU_initialize_registry();
suite = CU_add_suite("zone", test_setup, test_cleanup);
CU_add_test(suite, "test_zone_get_operation", test_zone_get_operation);
CU_add_test(suite, "test_bdev_zone_get_info", test_bdev_zone_get_info);
CU_add_test(suite, "test_bdev_zone_management", test_bdev_zone_management);
CU_add_test(suite, "test_bdev_zone_append", test_bdev_zone_append);
CU_add_test(suite, "test_bdev_zone_append_with_md", test_bdev_zone_append_with_md);
CU_add_test(suite, "test_bdev_io_get_append_location", test_bdev_io_get_append_location);
CU_ADD_TEST(suite, test_zone_get_operation);
CU_ADD_TEST(suite, test_bdev_zone_get_info);
CU_ADD_TEST(suite, test_bdev_zone_management);
CU_ADD_TEST(suite, test_bdev_zone_append);
CU_ADD_TEST(suite, test_bdev_zone_append_with_md);
CU_ADD_TEST(suite, test_bdev_io_get_append_location);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

24
test/unit/lib/bdev/compress.c/compress_ut.c
View File

@ -1105,22 +1105,14 @@ main(int argc, char **argv)
CU_initialize_registry();
suite = CU_add_suite("compress", test_setup, test_cleanup);
CU_add_test(suite, "test_compress_operation",
test_compress_operation);
CU_add_test(suite, "test_compress_operation_cross_boundary",
test_compress_operation_cross_boundary);
CU_add_test(suite, "vbdev_compress_submit_request",
test_vbdev_compress_submit_request);
CU_add_test(suite, "test_passthru",
test_passthru);
CU_add_test(suite, "test_initdrivers",
test_initdrivers);
CU_add_test(suite, "test_supported_io",
test_supported_io);
CU_add_test(suite, "test_poller",
test_poller);
CU_add_test(suite, "test_reset",
test_reset);
CU_ADD_TEST(suite, test_compress_operation);
CU_ADD_TEST(suite, test_compress_operation_cross_boundary);
CU_ADD_TEST(suite, test_vbdev_compress_submit_request);
CU_ADD_TEST(suite, test_passthru);
CU_ADD_TEST(suite, test_initdrivers);
CU_ADD_TEST(suite, test_supported_io);
CU_ADD_TEST(suite, test_poller);
CU_ADD_TEST(suite, test_reset);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

39
test/unit/lib/bdev/crypto.c/crypto_ut.c
View File

@ -1062,32 +1062,19 @@ main(int argc, char **argv)
CU_initialize_registry();
suite = CU_add_suite("crypto", test_setup, test_cleanup);
CU_add_test(suite, "test_error_paths",
test_error_paths);
CU_add_test(suite, "test_simple_write",
test_simple_write);
CU_add_test(suite, "test_simple_read",
test_simple_read);
CU_add_test(suite, "test_large_rw",
test_large_rw);
CU_add_test(suite, "test_dev_full",
test_dev_full);
CU_add_test(suite, "test_crazy_rw",
test_crazy_rw);
CU_add_test(suite, "test_passthru",
test_passthru);
CU_add_test(suite, "test_initdrivers",
test_initdrivers);
CU_add_test(suite, "test_crypto_op_complete",
test_crypto_op_complete);
CU_add_test(suite, "test_supported_io",
test_supported_io);
CU_add_test(suite, "test_reset",
test_reset);
CU_add_test(suite, "test_poller",
test_poller);
CU_add_test(suite, "test_assign_device_qp",
test_assign_device_qp);
CU_ADD_TEST(suite, test_error_paths);
CU_ADD_TEST(suite, test_simple_write);
CU_ADD_TEST(suite, test_simple_read);
CU_ADD_TEST(suite, test_large_rw);
CU_ADD_TEST(suite, test_dev_full);
CU_ADD_TEST(suite, test_crazy_rw);
CU_ADD_TEST(suite, test_passthru);
CU_ADD_TEST(suite, test_initdrivers);
CU_ADD_TEST(suite, test_crypto_op_complete);
CU_ADD_TEST(suite, test_supported_io);
CU_ADD_TEST(suite, test_reset);
CU_ADD_TEST(suite, test_poller);
CU_ADD_TEST(suite, test_assign_device_qp);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

15
test/unit/lib/bdev/gpt/gpt.c/gpt_ut.c
View File

@ -349,16 +349,11 @@ main(int argc, char **argv)
suite = CU_add_suite("gpt_parse", NULL, NULL);
CU_add_test(suite, "parse",
test_parse_mbr_and_primary);
CU_add_test(suite, "parse secondary",
test_parse_secondary);
CU_add_test(suite, "check mbr",
test_check_mbr);
CU_add_test(suite, "read header",
test_read_header);
CU_add_test(suite, "read partitions",
test_read_partitions);
CU_ADD_TEST(suite, test_parse_mbr_and_primary);
CU_ADD_TEST(suite, test_parse_secondary);
CU_ADD_TEST(suite, test_check_mbr);
CU_ADD_TEST(suite, test_read_header);
CU_ADD_TEST(suite, test_read_partitions);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

30
test/unit/lib/bdev/mt/bdev.c/bdev_ut.c
View File

@ -1904,21 +1904,21 @@ main(int argc, char **argv)
suite = CU_add_suite("bdev", NULL, NULL);
CU_add_test(suite, "basic", basic);
CU_add_test(suite, "unregister_and_close", unregister_and_close);
CU_add_test(suite, "basic_qos", basic_qos);
CU_add_test(suite, "put_channel_during_reset", put_channel_during_reset);
CU_add_test(suite, "aborted_reset", aborted_reset);
CU_add_test(suite, "io_during_reset", io_during_reset);
CU_add_test(suite, "io_during_qos_queue", io_during_qos_queue);
CU_add_test(suite, "io_during_qos_reset", io_during_qos_reset);
CU_add_test(suite, "enomem", enomem);
CU_add_test(suite, "enomem_multi_bdev", enomem_multi_bdev);
CU_add_test(suite, "enomem_multi_io_target", enomem_multi_io_target);
CU_add_test(suite, "qos_dynamic_enable", qos_dynamic_enable);
CU_add_test(suite, "bdev_histograms_mt", bdev_histograms_mt);
CU_add_test(suite, "bdev_set_io_timeout_mt", bdev_set_io_timeout_mt);
CU_add_test(suite, "lock_lba_range_then_submit_io", lock_lba_range_then_submit_io);
CU_ADD_TEST(suite, basic);
CU_ADD_TEST(suite, unregister_and_close);
CU_ADD_TEST(suite, basic_qos);
CU_ADD_TEST(suite, put_channel_during_reset);
CU_ADD_TEST(suite, aborted_reset);
CU_ADD_TEST(suite, io_during_reset);
CU_ADD_TEST(suite, io_during_qos_queue);
CU_ADD_TEST(suite, io_during_qos_reset);
CU_ADD_TEST(suite, enomem);
CU_ADD_TEST(suite, enomem_multi_bdev);
CU_ADD_TEST(suite, enomem_multi_io_target);
CU_ADD_TEST(suite, qos_dynamic_enable);
CU_ADD_TEST(suite, bdev_histograms_mt);
CU_ADD_TEST(suite, bdev_set_io_timeout_mt);
CU_ADD_TEST(suite, lock_lba_range_then_submit_io);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

2
test/unit/lib/bdev/part.c/part_ut.c
View File

@ -157,7 +157,7 @@ main(int argc, char **argv)
suite = CU_add_suite("bdev_part", NULL, NULL);
CU_add_test(suite, "part", part_test);
CU_ADD_TEST(suite, part_test);
allocate_threads(1);
set_thread(0);

12
test/unit/lib/bdev/pmem/bdev_pmem_ut.c
View File

@ -756,12 +756,12 @@ main(int argc, char **argv)
suite = CU_add_suite("bdev_pmem", ut_pmem_blk_init, ut_pmem_blk_clean);
CU_add_test(suite, "ut_pmem_init", ut_pmem_init);
CU_add_test(suite, "ut_pmem_open_close", ut_pmem_open_close);
CU_add_test(suite, "ut_pmem_write_read", ut_pmem_write_read);
CU_add_test(suite, "ut_pmem_reset", ut_pmem_reset);
CU_add_test(suite, "ut_pmem_write_zero", ut_pmem_write_zero);
CU_add_test(suite, "ut_pmem_unmap", ut_pmem_unmap);
CU_ADD_TEST(suite, ut_pmem_init);
CU_ADD_TEST(suite, ut_pmem_open_close);
CU_ADD_TEST(suite, ut_pmem_write_read);
CU_ADD_TEST(suite, ut_pmem_reset);
CU_ADD_TEST(suite, ut_pmem_write_zero);
CU_ADD_TEST(suite, ut_pmem_unmap);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

39
test/unit/lib/bdev/raid/bdev_raid.c/bdev_raid_ut.c
View File

@ -2224,27 +2224,24 @@ int main(int argc, char **argv)
suite = CU_add_suite("raid", NULL, NULL);
CU_add_test(suite, "test_create_raid", test_create_raid);
CU_add_test(suite, "test_delete_raid", test_delete_raid);
CU_add_test(suite, "test_create_raid_invalid_args",
test_create_raid_invalid_args);
CU_add_test(suite, "test_delete_raid_invalid_args",
test_delete_raid_invalid_args);
CU_add_test(suite, "test_io_channel", test_io_channel);
CU_add_test(suite, "test_reset_io", test_reset_io);
CU_add_test(suite, "test_write_io", test_write_io);
CU_add_test(suite, "test_read_io", test_read_io);
CU_add_test(suite, "test_unmap_io", test_unmap_io);
CU_add_test(suite, "test_io_failure", test_io_failure);
CU_add_test(suite, "test_multi_raid_no_io", test_multi_raid_no_io);
CU_add_test(suite, "test_multi_raid_with_io", test_multi_raid_with_io);
CU_add_test(suite, "test_io_type_supported", test_io_type_supported);
CU_add_test(suite, "test_create_raid_from_config", test_create_raid_from_config);
CU_add_test(suite, "test_create_raid_from_config_invalid_params",
test_create_raid_from_config_invalid_params);
CU_add_test(suite, "test_raid_json_dump_info", test_raid_json_dump_info);
CU_add_test(suite, "test_context_size", test_context_size);
CU_add_test(suite, "test_raid_level_conversions", test_raid_level_conversions);
CU_ADD_TEST(suite, test_create_raid);
CU_ADD_TEST(suite, test_delete_raid);
CU_ADD_TEST(suite, test_create_raid_invalid_args);
CU_ADD_TEST(suite, test_delete_raid_invalid_args);
CU_ADD_TEST(suite, test_io_channel);
CU_ADD_TEST(suite, test_reset_io);
CU_ADD_TEST(suite, test_write_io);
CU_ADD_TEST(suite, test_read_io);
CU_ADD_TEST(suite, test_unmap_io);
CU_ADD_TEST(suite, test_io_failure);
CU_ADD_TEST(suite, test_multi_raid_no_io);
CU_ADD_TEST(suite, test_multi_raid_with_io);
CU_ADD_TEST(suite, test_io_type_supported);
CU_ADD_TEST(suite, test_create_raid_from_config);
CU_ADD_TEST(suite, test_create_raid_from_config_invalid_params);
CU_ADD_TEST(suite, test_raid_json_dump_info);
CU_ADD_TEST(suite, test_context_size);
CU_ADD_TEST(suite, test_raid_level_conversions);
allocate_threads(1);
set_thread(0);

2
test/unit/lib/bdev/raid/raid5.c/raid5_ut.c
View File

@ -204,7 +204,7 @@ main(int argc, char **argv)
CU_initialize_registry();
suite = CU_add_suite("raid5", test_setup, test_cleanup);
CU_add_test(suite, "test_raid5_start", test_raid5_start);
CU_ADD_TEST(suite, test_raid5_start);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

3
test/unit/lib/bdev/scsi_nvme.c/scsi_nvme_ut.c
View File

@ -121,8 +121,7 @@ main(int argc, char **argv)
suite = CU_add_suite("scsi_nvme_suite", null_init, null_clean);
CU_add_test(suite, "scsi_nvme - translate nvme error to scsi error",
scsi_nvme_translate_test);
CU_ADD_TEST(suite, scsi_nvme_translate_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

34
test/unit/lib/bdev/vbdev_lvol.c/vbdev_lvol_ut.c
View File

@ -1402,23 +1402,23 @@ int main(int argc, char **argv)
suite = CU_add_suite("lvol", NULL, NULL);
CU_add_test(suite, "ut_lvs_init", ut_lvs_init);
CU_add_test(suite, "ut_lvol_init", ut_lvol_init);
CU_add_test(suite, "ut_lvol_snapshot", ut_lvol_snapshot);
CU_add_test(suite, "ut_lvol_clone", ut_lvol_clone);
CU_add_test(suite, "ut_lvs_destroy", ut_lvs_destroy);
CU_add_test(suite, "ut_lvs_unload", ut_lvs_unload);
CU_add_test(suite, "ut_lvol_resize", ut_lvol_resize);
CU_add_test(suite, "ut_lvol_set_read_only", ut_lvol_set_read_only);
CU_add_test(suite, "lvol_hotremove", ut_lvol_hotremove);
CU_add_test(suite, "ut_vbdev_lvol_get_io_channel", ut_vbdev_lvol_get_io_channel);
CU_add_test(suite, "ut_vbdev_lvol_io_type_supported", ut_vbdev_lvol_io_type_supported);
CU_add_test(suite, "ut_lvol_read_write", ut_lvol_read_write);
CU_add_test(suite, "ut_vbdev_lvol_submit_request", ut_vbdev_lvol_submit_request);
CU_add_test(suite, "lvol_examine", ut_lvol_examine);
CU_add_test(suite, "ut_lvol_rename", ut_lvol_rename);
CU_add_test(suite, "ut_lvol_destroy", ut_lvol_destroy);
CU_add_test(suite, "ut_lvs_rename", ut_lvs_rename);
CU_ADD_TEST(suite, ut_lvs_init);
CU_ADD_TEST(suite, ut_lvol_init);
CU_ADD_TEST(suite, ut_lvol_snapshot);
CU_ADD_TEST(suite, ut_lvol_clone);
CU_ADD_TEST(suite, ut_lvs_destroy);
CU_ADD_TEST(suite, ut_lvs_unload);
CU_ADD_TEST(suite, ut_lvol_resize);
CU_ADD_TEST(suite, ut_lvol_set_read_only);
CU_ADD_TEST(suite, ut_lvol_hotremove);
CU_ADD_TEST(suite, ut_vbdev_lvol_get_io_channel);
CU_ADD_TEST(suite, ut_vbdev_lvol_io_type_supported);
CU_ADD_TEST(suite, ut_lvol_read_write);
CU_ADD_TEST(suite, ut_vbdev_lvol_submit_request);
CU_ADD_TEST(suite, ut_lvol_examine);
CU_ADD_TEST(suite, ut_lvol_rename);
CU_ADD_TEST(suite, ut_lvol_destroy);
CU_ADD_TEST(suite, ut_lvs_rename);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

22
test/unit/lib/bdev/vbdev_zone_block.c/vbdev_zone_block_ut.c
View File

@ -1470,17 +1470,17 @@ int main(int argc, char **argv)
suite = CU_add_suite("zone_block", NULL, NULL);
CU_add_test(suite, "test_zone_block_create", test_zone_block_create);
CU_add_test(suite, "test_zone_block_create_invalid", test_zone_block_create_invalid);
CU_add_test(suite, "test_get_zone_info", test_get_zone_info);
CU_add_test(suite, "test_supported_io_types", test_supported_io_types);
CU_add_test(suite, "test_reset_zone", test_reset_zone);
CU_add_test(suite, "test_open_zone", test_open_zone);
CU_add_test(suite, "test_zone_write", test_zone_write);
CU_add_test(suite, "test_zone_read", test_zone_read);
CU_add_test(suite, "test_close_zone", test_close_zone);
CU_add_test(suite, "test_finish_zone", test_finish_zone);
CU_add_test(suite, "test_append_zone", test_append_zone);
CU_ADD_TEST(suite, test_zone_block_create);
CU_ADD_TEST(suite, test_zone_block_create_invalid);
CU_ADD_TEST(suite, test_get_zone_info);
CU_ADD_TEST(suite, test_supported_io_types);
CU_ADD_TEST(suite, test_reset_zone);
CU_ADD_TEST(suite, test_open_zone);
CU_ADD_TEST(suite, test_zone_write);
CU_ADD_TEST(suite, test_zone_read);
CU_ADD_TEST(suite, test_close_zone);
CU_ADD_TEST(suite, test_finish_zone);
CU_ADD_TEST(suite, test_append_zone);
g_thread = spdk_thread_create("test", NULL);
spdk_set_thread(g_thread);

20
test/unit/lib/blobfs/blobfs_async_ut/blobfs_async_ut.c
View File

@ -677,16 +677,16 @@ int main(int argc, char **argv)
suite = CU_add_suite("blobfs_async_ut", NULL, NULL);
CU_add_test(suite, "fs_init", fs_init);
CU_add_test(suite, "fs_open", fs_open);
CU_add_test(suite, "fs_create", fs_create);
CU_add_test(suite, "fs_truncate", fs_truncate);
CU_add_test(suite, "fs_rename", fs_rename);
CU_add_test(suite, "fs_rw_async", fs_rw_async);
CU_add_test(suite, "fs_writev_readv_async", fs_writev_readv_async);
CU_add_test(suite, "tree_find_buffer", tree_find_buffer_ut);
CU_add_test(suite, "channel_ops", channel_ops);
CU_add_test(suite, "channel_ops_sync", channel_ops_sync);
CU_ADD_TEST(suite, fs_init);
CU_ADD_TEST(suite, fs_open);
CU_ADD_TEST(suite, fs_create);
CU_ADD_TEST(suite, fs_truncate);
CU_ADD_TEST(suite, fs_rename);
CU_ADD_TEST(suite, fs_rw_async);
CU_ADD_TEST(suite, fs_writev_readv_async);
CU_ADD_TEST(suite, tree_find_buffer_ut);
CU_ADD_TEST(suite, channel_ops);
CU_ADD_TEST(suite, channel_ops_sync);
allocate_threads(1);
set_thread(0);

6
test/unit/lib/blobfs/blobfs_bdev.c/blobfs_bdev_ut.c
View File

@ -335,9 +335,9 @@ int main(int argc, char **argv)
suite = CU_add_suite("blobfs_bdev_ut", NULL, NULL);
CU_add_test(suite, "spdk_blobfs_bdev_detect_test", spdk_blobfs_bdev_detect_test);
CU_add_test(suite, "spdk_blobfs_bdev_create_test", spdk_blobfs_bdev_create_test);
CU_add_test(suite, "spdk_blobfs_bdev_mount_test", spdk_blobfs_bdev_mount_test);
CU_ADD_TEST(suite, spdk_blobfs_bdev_detect_test);
CU_ADD_TEST(suite, spdk_blobfs_bdev_create_test);
CU_ADD_TEST(suite, spdk_blobfs_bdev_mount_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

18
test/unit/lib/blobfs/blobfs_sync_ut/blobfs_sync_ut.c
View File

@ -634,15 +634,15 @@ int main(int argc, char **argv)
suite = CU_add_suite("blobfs_sync_ut", NULL, NULL);
CU_add_test(suite, "cache read after write", cache_read_after_write);
CU_add_test(suite, "file length", file_length);
CU_add_test(suite, "append write to extend blob", append_write_to_extend_blob);
CU_add_test(suite, "partial buffer", partial_buffer);
CU_add_test(suite, "write_null_buffer", cache_write_null_buffer);
CU_add_test(suite, "create_sync", fs_create_sync);
CU_add_test(suite, "rename_sync", fs_rename_sync);
CU_add_test(suite, "append_no_cache", cache_append_no_cache);
CU_add_test(suite, "delete_file_without_close", fs_delete_file_without_close);
CU_ADD_TEST(suite, cache_read_after_write);
CU_ADD_TEST(suite, file_length);
CU_ADD_TEST(suite, append_write_to_extend_blob);
CU_ADD_TEST(suite, partial_buffer);
CU_ADD_TEST(suite, cache_write_null_buffer);
CU_ADD_TEST(suite, fs_create_sync);
CU_ADD_TEST(suite, fs_rename_sync);
CU_ADD_TEST(suite, cache_append_no_cache);
CU_ADD_TEST(suite, fs_delete_file_without_close);
spdk_thread_lib_init(NULL, 0);

2
test/unit/lib/blobfs/tree.c/tree_ut.c
View File

@ -139,7 +139,7 @@ int main(int argc, char **argv)
CU_initialize_registry();
suite = CU_add_suite("tree", NULL, NULL);
CU_add_test(suite, "blobfs_tree_op_test", blobfs_tree_op_test);
CU_ADD_TEST(suite, blobfs_tree_op_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

3
test/unit/lib/event/app.c/app_ut.c
View File

@ -182,8 +182,7 @@ main(int argc, char **argv)
suite = CU_add_suite("app_suite", NULL, NULL);
CU_add_test(suite, "test_spdk_app_parse_args",
test_spdk_app_parse_args);
CU_ADD_TEST(suite, test_spdk_app_parse_args);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

12
test/unit/lib/event/reactor.c/reactor_ut.c
View File

@ -310,12 +310,12 @@ main(int argc, char **argv)
suite = CU_add_suite("app_suite", NULL, NULL);
CU_add_test(suite, "test_create_reactor", test_create_reactor);
CU_add_test(suite, "test_init_reactors", test_init_reactors);
CU_add_test(suite, "test_event_call", test_event_call);
CU_add_test(suite, "test_schedule_thread", test_schedule_thread);
CU_add_test(suite, "test_reschedule_thread", test_reschedule_thread);
CU_add_test(suite, "test_for_each_reactor", test_for_each_reactor);
CU_ADD_TEST(suite, test_create_reactor);
CU_ADD_TEST(suite, test_init_reactors);
CU_ADD_TEST(suite, test_event_call);
CU_ADD_TEST(suite, test_schedule_thread);
CU_ADD_TEST(suite, test_reschedule_thread);
CU_ADD_TEST(suite, test_for_each_reactor);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

9
test/unit/lib/event/subsystem.c/subsystem_ut.c
View File

@ -242,12 +242,9 @@ main(int argc, char **argv)
suite = CU_add_suite("subsystem_suite", NULL, NULL);
CU_add_test(suite, "subsystem_sort_test_depends_on_single",
subsystem_sort_test_depends_on_single);
CU_add_test(suite, "subsystem_sort_test_depends_on_multiple",
subsystem_sort_test_depends_on_multiple);
CU_add_test(suite, "subsystem_sort_test_missing_dependency",
subsystem_sort_test_missing_dependency);
CU_ADD_TEST(suite, subsystem_sort_test_depends_on_single);
CU_ADD_TEST(suite, subsystem_sort_test_depends_on_multiple);
CU_ADD_TEST(suite, subsystem_sort_test_missing_dependency);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

18
test/unit/lib/ftl/ftl_band.c/ftl_band_ut.c
View File

@ -291,18 +291,12 @@ main(int argc, char **argv)
suite = CU_add_suite("ftl_band_suite", NULL, NULL);
CU_add_test(suite, "test_band_block_offset_from_addr_base",
test_band_block_offset_from_addr_base);
CU_add_test(suite, "test_band_block_offset_from_addr_offset",
test_band_block_offset_from_addr_offset);
CU_add_test(suite, "test_band_addr_from_block_offset",
test_band_addr_from_block_offset);
CU_add_test(suite, "test_band_set_addr",
test_band_set_addr);
CU_add_test(suite, "test_invalidate_addr",
test_invalidate_addr);
CU_add_test(suite, "test_next_xfer_addr",
test_next_xfer_addr);
CU_ADD_TEST(suite, test_band_block_offset_from_addr_base);
CU_ADD_TEST(suite, test_band_block_offset_from_addr_offset);
CU_ADD_TEST(suite, test_band_addr_from_block_offset);
CU_ADD_TEST(suite, test_band_set_addr);
CU_ADD_TEST(suite, test_invalidate_addr);
CU_ADD_TEST(suite, test_next_xfer_addr);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

27
test/unit/lib/ftl/ftl_io.c/ftl_io_ut.c
View File

@ -1047,24 +1047,15 @@ main(int argc, char **argv)
suite = CU_add_suite("ftl_io_suite", NULL, NULL);
CU_add_test(suite, "test_completion",
test_completion);
CU_add_test(suite, "test_alloc_free",
test_alloc_free);
CU_add_test(suite, "test_child_requests",
test_child_requests);
CU_add_test(suite, "test_child_status",
test_child_status);
CU_add_test(suite, "test_multi_generation",
test_multi_generation);
CU_add_test(suite, "test_io_channel_create",
test_io_channel_create);
CU_add_test(suite, "test_acquire_entry",
test_acquire_entry);
CU_add_test(suite, "test_submit_batch",
test_submit_batch);
CU_add_test(suite, "test_entry_address",
test_entry_address);
CU_ADD_TEST(suite, test_completion);
CU_ADD_TEST(suite, test_alloc_free);
CU_ADD_TEST(suite, test_child_requests);
CU_ADD_TEST(suite, test_child_status);
CU_ADD_TEST(suite, test_multi_generation);
CU_ADD_TEST(suite, test_io_channel_create);
CU_ADD_TEST(suite, test_acquire_entry);
CU_ADD_TEST(suite, test_submit_batch);
CU_ADD_TEST(suite, test_entry_address);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

6
test/unit/lib/ftl/ftl_md/ftl_md_ut.c
View File

@ -138,10 +138,8 @@ main(int argc, char **argv)
suite = CU_add_suite("ftl_meta_suite", NULL, NULL);
CU_add_test(suite, "test_md_unpack",
test_md_unpack);
CU_add_test(suite, "test_md_unpack_fail",
test_md_unpack_fail);
CU_ADD_TEST(suite, test_md_unpack);
CU_ADD_TEST(suite, test_md_unpack_fail);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

15
test/unit/lib/ftl/ftl_ppa/ftl_ppa_ut.c
View File

@ -211,16 +211,11 @@ main(int argc, char **argv)
suite64 = CU_add_suite("ftl_addr64_suite", setup_l2p_64bit, cleanup);
CU_add_test(suite32, "test_addr_pack",
test_addr_pack32);
CU_add_test(suite32, "test_addr32_invalid",
test_addr_invalid);
CU_add_test(suite32, "test_addr32_cached",
test_addr_cached);
CU_add_test(suite64, "test_addr64_invalid",
test_addr_invalid);
CU_add_test(suite64, "test_addr64_cached",
test_addr_cached);
CU_ADD_TEST(suite32, test_addr_pack32);
CU_ADD_TEST(suite32, test_addr_invalid);
CU_ADD_TEST(suite32, test_addr_cached);
CU_ADD_TEST(suite64, test_addr_invalid);
CU_ADD_TEST(suite64, test_addr_cached);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

18
test/unit/lib/ftl/ftl_reloc.c/ftl_reloc_ut.c
View File

@ -490,18 +490,12 @@ main(int argc, char **argv)
suite = CU_add_suite("ftl_band_suite", NULL, NULL);
CU_add_test(suite, "test_reloc_iter_full",
test_reloc_iter_full);
CU_add_test(suite, "test_reloc_empty_band",
test_reloc_empty_band);
CU_add_test(suite, "test_reloc_full_band",
test_reloc_full_band);
CU_add_test(suite, "test_reloc_scatter_band",
test_reloc_scatter_band);
CU_add_test(suite, "test_reloc_zone",
test_reloc_zone);
CU_add_test(suite, "test_reloc_single_block",
test_reloc_single_block);
CU_ADD_TEST(suite, test_reloc_iter_full);
CU_ADD_TEST(suite, test_reloc_empty_band);
CU_ADD_TEST(suite, test_reloc_full_band);
CU_ADD_TEST(suite, test_reloc_scatter_band);
CU_ADD_TEST(suite, test_reloc_zone);
CU_ADD_TEST(suite, test_reloc_single_block);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

3
test/unit/lib/ftl/ftl_wptr/ftl_wptr_ut.c
View File

@ -211,8 +211,7 @@ main(int argc, char **argv)
suite = CU_add_suite("ftl_wptr_suite", NULL, NULL);
CU_add_test(suite, "test_wptr",
test_wptr);
CU_ADD_TEST(suite, test_wptr);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

2
test/unit/lib/ioat/ioat.c/ioat_ut.c
View File

@ -134,7 +134,7 @@ int main(int argc, char **argv)
suite = CU_add_suite("ioat", NULL, NULL);
CU_add_test(suite, "ioat_state_check", ioat_state_check);
CU_ADD_TEST(suite, ioat_state_check);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

19
test/unit/lib/iscsi/conn.c/conn_ut.c
View File

@ -895,17 +895,14 @@ main(int argc, char **argv)
suite = CU_add_suite("conn_suite", NULL, NULL);
CU_add_test(suite, "read task split in order", read_task_split_in_order_case);
CU_add_test(suite, "read task split reverse order",
read_task_split_reverse_order_case);
CU_add_test(suite, "propagate_scsi_error_status_for_split_read_tasks",
propagate_scsi_error_status_for_split_read_tasks);
CU_add_test(suite, "process_non_read_task_completion_test",
process_non_read_task_completion_test);
CU_add_test(suite, "free_tasks_on_connection", free_tasks_on_connection);
CU_add_test(suite, "free_tasks_with_queued_datain", free_tasks_with_queued_datain);
CU_add_test(suite, "abort_queued_datain_task_test", abort_queued_datain_task_test);
CU_add_test(suite, "abort_queued_datain_tasks_test", abort_queued_datain_tasks_test);
CU_ADD_TEST(suite, read_task_split_in_order_case);
CU_ADD_TEST(suite, read_task_split_reverse_order_case);
CU_ADD_TEST(suite, propagate_scsi_error_status_for_split_read_tasks);
CU_ADD_TEST(suite, process_non_read_task_completion_test);
CU_ADD_TEST(suite, free_tasks_on_connection);
CU_ADD_TEST(suite, free_tasks_with_queued_datain);
CU_ADD_TEST(suite, abort_queued_datain_task_test);
CU_ADD_TEST(suite, abort_queued_datain_tasks_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

54
test/unit/lib/iscsi/init_grp.c/init_grp_ut.c
View File

@ -647,42 +647,24 @@ main(int argc, char **argv)
suite = CU_add_suite("init_grp_suite", test_setup, NULL);
CU_add_test(suite, "create from config file cases",
create_from_config_file_cases);
CU_add_test(suite, "create initiator group success case",
create_initiator_group_success_case);
CU_add_test(suite, "find initiator group success case",
find_initiator_group_success_case);
CU_add_test(suite, "register initiator group twice case",
register_initiator_group_twice_case);
CU_add_test(suite, "add initiator name success case",
add_initiator_name_success_case);
CU_add_test(suite, "add initiator name fail case",
add_initiator_name_fail_case);
CU_add_test(suite, "delete all initiator names success case",
delete_all_initiator_names_success_case);
CU_add_test(suite, "add initiator netmask success case",
add_netmask_success_case);
CU_add_test(suite, "add initiator netmask fail case",
add_netmask_fail_case);
CU_add_test(suite, "delete all initiator netmasks success case",
delete_all_netmasks_success_case);
CU_add_test(suite, "overwrite all to any for name case",
initiator_name_overwrite_all_to_any_case);
CU_add_test(suite, "overwrite all to any for netmask case",
netmask_overwrite_all_to_any_case);
CU_add_test(suite, "add/delete initiator names case",
add_delete_initiator_names_case);
CU_add_test(suite, "add duplicated initiator names case",
add_duplicated_initiator_names_case);
CU_add_test(suite, "delete nonexisting initiator names case",
delete_nonexisting_initiator_names_case);
CU_add_test(suite, "add/delete netmasks case",
add_delete_netmasks_case);
CU_add_test(suite, "add duplicated netmasks case",
add_duplicated_netmasks_case);
CU_add_test(suite, "delete nonexisting netmasks case",
delete_nonexisting_netmasks_case);
CU_ADD_TEST(suite, create_from_config_file_cases);
CU_ADD_TEST(suite, create_initiator_group_success_case);
CU_ADD_TEST(suite, find_initiator_group_success_case);
CU_ADD_TEST(suite, register_initiator_group_twice_case);
CU_ADD_TEST(suite, add_initiator_name_success_case);
CU_ADD_TEST(suite, add_initiator_name_fail_case);
CU_ADD_TEST(suite, delete_all_initiator_names_success_case);
CU_ADD_TEST(suite, add_netmask_success_case);
CU_ADD_TEST(suite, add_netmask_fail_case);
CU_ADD_TEST(suite, delete_all_netmasks_success_case);
CU_ADD_TEST(suite, initiator_name_overwrite_all_to_any_case);
CU_ADD_TEST(suite, netmask_overwrite_all_to_any_case);
CU_ADD_TEST(suite, add_delete_initiator_names_case);
CU_ADD_TEST(suite, add_duplicated_initiator_names_case);
CU_ADD_TEST(suite, delete_nonexisting_initiator_names_case);
CU_ADD_TEST(suite, add_delete_netmasks_case);
CU_ADD_TEST(suite, add_duplicated_netmasks_case);
CU_ADD_TEST(suite, delete_nonexisting_netmasks_case);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

45
test/unit/lib/iscsi/iscsi.c/iscsi_ut.c
View File

@ -1974,31 +1974,26 @@ main(int argc, char **argv)
suite = CU_add_suite("iscsi_suite", NULL, NULL);
CU_add_test(suite, "login check target test", op_login_check_target_test);
CU_add_test(suite, "login_session_normal_test", op_login_session_normal_test);
CU_add_test(suite, "maxburstlength test", maxburstlength_test);
CU_add_test(suite, "underflow for read transfer test",
underflow_for_read_transfer_test);
CU_add_test(suite, "underflow for zero read transfer test",
underflow_for_zero_read_transfer_test);
CU_add_test(suite, "underflow for request sense test",
underflow_for_request_sense_test);
CU_add_test(suite, "underflow for check condition test",
underflow_for_check_condition_test);
CU_add_test(suite, "add transfer task test", add_transfer_task_test);
CU_add_test(suite, "get transfer task test", get_transfer_task_test);
CU_add_test(suite, "del transfer task test", del_transfer_task_test);
CU_add_test(suite, "clear all transfer tasks test",
clear_all_transfer_tasks_test);
CU_add_test(suite, "build_iovs_test", build_iovs_test);
CU_add_test(suite, "build_iovs_with_md_test", build_iovs_with_md_test);
CU_add_test(suite, "pdu_hdr_op_login_test", pdu_hdr_op_login_test);
CU_add_test(suite, "pdu_hdr_op_text_test", pdu_hdr_op_text_test);
CU_add_test(suite, "pdu_hdr_op_logout_test", pdu_hdr_op_logout_test);
CU_add_test(suite, "pdu_hdr_op_scsi_test", pdu_hdr_op_scsi_test);
CU_add_test(suite, "pdu_hdr_op_task_mgmt_test", pdu_hdr_op_task_mgmt_test);
CU_add_test(suite, "pdu_hdr_op_nopout_test", pdu_hdr_op_nopout_test);
CU_add_test(suite, "pdu_hdr_op_data_test", pdu_hdr_op_data_test);
CU_ADD_TEST(suite, op_login_check_target_test);
CU_ADD_TEST(suite, op_login_session_normal_test);
CU_ADD_TEST(suite, maxburstlength_test);
CU_ADD_TEST(suite, underflow_for_read_transfer_test);
CU_ADD_TEST(suite, underflow_for_zero_read_transfer_test);
CU_ADD_TEST(suite, underflow_for_request_sense_test);
CU_ADD_TEST(suite, underflow_for_check_condition_test);
CU_ADD_TEST(suite, add_transfer_task_test);
CU_ADD_TEST(suite, get_transfer_task_test);
CU_ADD_TEST(suite, del_transfer_task_test);
CU_ADD_TEST(suite, clear_all_transfer_tasks_test);
CU_ADD_TEST(suite, build_iovs_test);
CU_ADD_TEST(suite, build_iovs_with_md_test);
CU_ADD_TEST(suite, pdu_hdr_op_login_test);
CU_ADD_TEST(suite, pdu_hdr_op_text_test);
CU_ADD_TEST(suite, pdu_hdr_op_logout_test);
CU_ADD_TEST(suite, pdu_hdr_op_scsi_test);
CU_ADD_TEST(suite, pdu_hdr_op_task_mgmt_test);
CU_ADD_TEST(suite, pdu_hdr_op_nopout_test);
CU_ADD_TEST(suite, pdu_hdr_op_data_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

12
test/unit/lib/iscsi/param.c/param_ut.c
View File

@ -387,14 +387,10 @@ main(int argc, char **argv)
suite = CU_add_suite("iscsi_suite", NULL, NULL);
CU_add_test(suite, "param negotiation test",
param_negotiation_test);
CU_add_test(suite, "list negotiation test",
list_negotiation_test);
CU_add_test(suite, "parse valid test",
parse_valid_test);
CU_add_test(suite, "parse invalid test",
parse_invalid_test);
CU_ADD_TEST(suite, param_negotiation_test);
CU_ADD_TEST(suite, list_negotiation_test);
CU_ADD_TEST(suite, parse_valid_test);
CU_ADD_TEST(suite, parse_invalid_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

39
test/unit/lib/iscsi/portal_grp.c/portal_grp_ut.c
View File

@ -398,32 +398,19 @@ main(int argc, char **argv)
suite = CU_add_suite("portal_grp_suite", test_setup, NULL);
CU_add_test(suite, "portal create ipv4 normal case",
portal_create_ipv4_normal_case);
CU_add_test(suite, "portal create ipv6 normal case",
portal_create_ipv6_normal_case);
CU_add_test(suite, "portal create ipv4 wildcard case",
portal_create_ipv4_wildcard_case);
CU_add_test(suite, "portal create ipv6 wildcard case",
portal_create_ipv6_wildcard_case);
CU_add_test(suite, "portal create twice case",
portal_create_twice_case);
CU_add_test(suite, "parse portal ipv4 normal case",
parse_portal_ipv4_normal_case);
CU_add_test(suite, "parse portal ipv6 normal case",
parse_portal_ipv6_normal_case);
CU_add_test(suite, "parse portal ipv4 skip port case",
parse_portal_ipv4_skip_port_case);
CU_add_test(suite, "parse portal ipv6 skip port case",
parse_portal_ipv6_skip_port_case);
CU_add_test(suite, "portal group register/unregister case",
portal_grp_register_unregister_case);
CU_add_test(suite, "portal group register twice case",
portal_grp_register_twice_case);
CU_add_test(suite, "portal group add/delete case",
portal_grp_add_delete_case);
CU_add_test(suite, "portal group add/delete twice case",
portal_grp_add_delete_twice_case);
CU_ADD_TEST(suite, portal_create_ipv4_normal_case);
CU_ADD_TEST(suite, portal_create_ipv6_normal_case);
CU_ADD_TEST(suite, portal_create_ipv4_wildcard_case);
CU_ADD_TEST(suite, portal_create_ipv6_wildcard_case);
CU_ADD_TEST(suite, portal_create_twice_case);
CU_ADD_TEST(suite, parse_portal_ipv4_normal_case);
CU_ADD_TEST(suite, parse_portal_ipv6_normal_case);
CU_ADD_TEST(suite, parse_portal_ipv4_skip_port_case);
CU_ADD_TEST(suite, parse_portal_ipv6_skip_port_case);
CU_ADD_TEST(suite, portal_grp_register_unregister_case);
CU_ADD_TEST(suite, portal_grp_register_twice_case);
CU_ADD_TEST(suite, portal_grp_add_delete_case);
CU_ADD_TEST(suite, portal_grp_add_delete_twice_case);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

31
test/unit/lib/iscsi/tgt_node.c/tgt_node_ut.c
View File

@ -809,23 +809,20 @@ main(int argc, char **argv)
suite = CU_add_suite("iscsi_target_node_suite", NULL, NULL);
CU_add_test(suite, "add lun test cases", add_lun_test_cases);
CU_add_test(suite, "config file fail cases", config_file_fail_cases);
CU_add_test(suite, "allow any allowed case", allow_any_allowed);
CU_add_test(suite, "allow ipv6 allowed case", allow_ipv6_allowed);
CU_add_test(suite, "allow ipv6 denied case", allow_ipv6_denied);
CU_add_test(suite, "allow ipv6 invalid case", allow_ipv6_invalid);
CU_add_test(suite, "allow ipv4 allowed case", allow_ipv4_allowed);
CU_add_test(suite, "allow ipv4 denied case", allow_ipv4_denied);
CU_add_test(suite, "allow ipv4 invalid case", allow_ipv4_invalid);
CU_add_test(suite, "node access allowed case", node_access_allowed);
CU_add_test(suite, "node access denied case (empty netmask)",
node_access_denied_by_empty_netmask);
CU_add_test(suite, "node access multiple initiator groups cases",
node_access_multi_initiator_groups_cases);
CU_add_test(suite, "allow iscsi name case",
allow_iscsi_name_multi_maps_case);
CU_add_test(suite, "chap param test cases", chap_param_test_cases);
CU_ADD_TEST(suite, add_lun_test_cases);
CU_ADD_TEST(suite, config_file_fail_cases);
CU_ADD_TEST(suite, allow_any_allowed);
CU_ADD_TEST(suite, allow_ipv6_allowed);
CU_ADD_TEST(suite, allow_ipv6_denied);
CU_ADD_TEST(suite, allow_ipv6_invalid);
CU_ADD_TEST(suite, allow_ipv4_allowed);
CU_ADD_TEST(suite, allow_ipv4_denied);
CU_ADD_TEST(suite, allow_ipv4_invalid);
CU_ADD_TEST(suite, node_access_allowed);
CU_ADD_TEST(suite, node_access_denied_by_empty_netmask);
CU_ADD_TEST(suite, node_access_multi_initiator_groups_cases);
CU_ADD_TEST(suite, allow_iscsi_name_multi_maps_case);
CU_ADD_TEST(suite, chap_param_test_cases);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

22
test/unit/lib/json/json_parse.c/json_parse_ut.c
View File

@ -908,17 +908,17 @@ int main(int argc, char **argv)
suite = CU_add_suite("json", NULL, NULL);
CU_add_test(suite, "parse_literal", test_parse_literal);
CU_add_test(suite, "parse_string_simple", test_parse_string_simple);
CU_add_test(suite, "parse_string_control_chars", test_parse_string_control_chars);
CU_add_test(suite, "parse_string_utf8", test_parse_string_utf8);
CU_add_test(suite, "parse_string_escapes_twochar", test_parse_string_escapes_twochar);
CU_add_test(suite, "parse_string_escapes_unicode", test_parse_string_escapes_unicode);
CU_add_test(suite, "parse_number", test_parse_number);
CU_add_test(suite, "parse_array", test_parse_array);
CU_add_test(suite, "parse_object", test_parse_object);
CU_add_test(suite, "parse_nesting", test_parse_nesting);
CU_add_test(suite, "parse_comment", test_parse_comment);
CU_ADD_TEST(suite, test_parse_literal);
CU_ADD_TEST(suite, test_parse_string_simple);
CU_ADD_TEST(suite, test_parse_string_control_chars);
CU_ADD_TEST(suite, test_parse_string_utf8);
CU_ADD_TEST(suite, test_parse_string_escapes_twochar);
CU_ADD_TEST(suite, test_parse_string_escapes_unicode);
CU_ADD_TEST(suite, test_parse_number);
CU_ADD_TEST(suite, test_parse_array);
CU_ADD_TEST(suite, test_parse_object);
CU_ADD_TEST(suite, test_parse_nesting);
CU_ADD_TEST(suite, test_parse_comment);
CU_basic_set_mode(CU_BRM_VERBOSE);

28
test/unit/lib/json/json_util.c/json_util_ut.c
View File

@ -928,20 +928,20 @@ int main(int argc, char **argv)
suite = CU_add_suite("json", NULL, NULL);
CU_add_test(suite, "strequal", test_strequal);
CU_add_test(suite, "num_to_uint16", test_num_to_uint16);
CU_add_test(suite, "num_to_int32", test_num_to_int32);
CU_add_test(suite, "num_to_uint64", test_num_to_uint64);
CU_add_test(suite, "decode_object", test_decode_object);
CU_add_test(suite, "decode_array", test_decode_array);
CU_add_test(suite, "decode_bool", test_decode_bool);
CU_add_test(suite, "decode_uint16", test_decode_uint16);
CU_add_test(suite, "decode_int32", test_decode_int32);
CU_add_test(suite, "decode_uint32", test_decode_uint32);
CU_add_test(suite, "decode_uint64", test_decode_uint64);
CU_add_test(suite, "decode_string", test_decode_string);
CU_add_test(suite, "find_object", test_find);
CU_add_test(suite, "iterating", test_iterating);
CU_ADD_TEST(suite, test_strequal);
CU_ADD_TEST(suite, test_num_to_uint16);
CU_ADD_TEST(suite, test_num_to_int32);
CU_ADD_TEST(suite, test_num_to_uint64);
CU_ADD_TEST(suite, test_decode_object);
CU_ADD_TEST(suite, test_decode_array);
CU_ADD_TEST(suite, test_decode_bool);
CU_ADD_TEST(suite, test_decode_uint16);
CU_ADD_TEST(suite, test_decode_int32);
CU_ADD_TEST(suite, test_decode_uint32);
CU_ADD_TEST(suite, test_decode_uint64);
CU_ADD_TEST(suite, test_decode_string);
CU_ADD_TEST(suite, test_find);
CU_ADD_TEST(suite, test_iterating);
CU_basic_set_mode(CU_BRM_VERBOSE);

24
test/unit/lib/json/json_write.c/json_write_ut.c
View File

@ -712,18 +712,18 @@ int main(int argc, char **argv)
suite = CU_add_suite("json", NULL, NULL);
CU_add_test(suite, "write_literal", test_write_literal);
CU_add_test(suite, "write_string_simple", test_write_string_simple);
CU_add_test(suite, "write_string_escapes", test_write_string_escapes);
CU_add_test(suite, "write_string_utf16le", test_write_string_utf16le);
CU_add_test(suite, "write_number_int32", test_write_number_int32);
CU_add_test(suite, "write_number_uint32", test_write_number_uint32);
CU_add_test(suite, "write_number_int64", test_write_number_int64);
CU_add_test(suite, "write_number_uint64", test_write_number_uint64);
CU_add_test(suite, "write_array", test_write_array);
CU_add_test(suite, "write_object", test_write_object);
CU_add_test(suite, "write_nesting", test_write_nesting);
CU_add_test(suite, "write_val", test_write_val);
CU_ADD_TEST(suite, test_write_literal);
CU_ADD_TEST(suite, test_write_string_simple);
CU_ADD_TEST(suite, test_write_string_escapes);
CU_ADD_TEST(suite, test_write_string_utf16le);
CU_ADD_TEST(suite, test_write_number_int32);
CU_ADD_TEST(suite, test_write_number_uint32);
CU_ADD_TEST(suite, test_write_number_int64);
CU_ADD_TEST(suite, test_write_number_uint64);
CU_ADD_TEST(suite, test_write_array);
CU_ADD_TEST(suite, test_write_object);
CU_ADD_TEST(suite, test_write_nesting);
CU_ADD_TEST(suite, test_write_val);
CU_basic_set_mode(CU_BRM_VERBOSE);

4
test/unit/lib/jsonrpc/jsonrpc_server.c/jsonrpc_server_ut.c
View File

@ -394,8 +394,8 @@ int main(int argc, char **argv)
suite = CU_add_suite("jsonrpc", NULL, NULL);
CU_add_test(suite, "parse_request", test_parse_request);
CU_add_test(suite, "parse_request_streaming", test_parse_request_streaming);
CU_ADD_TEST(suite, test_parse_request);
CU_ADD_TEST(suite, test_parse_request_streaming);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

2
test/unit/lib/log/log.c/log_ut.c
View File

@ -94,7 +94,7 @@ int main(int argc, char **argv)
suite = CU_add_suite("log", NULL, NULL);
CU_add_test(suite, "log_ut", log_test);
CU_ADD_TEST(suite, log_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

2
test/unit/lib/notify/notify.c/notify_ut.c
View File

@ -100,7 +100,7 @@ main(int argc, char **argv)
CU_initialize_registry();
suite = CU_add_suite("app_suite", NULL, NULL);
CU_add_test(suite, "notify", notify);
CU_ADD_TEST(suite, notify);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

66
test/unit/lib/nvme/nvme.c/nvme_ut.c
View File

@ -1319,50 +1319,28 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvme", NULL, NULL);
CU_add_test(suite, "test_opc_data_transfer",
test_opc_data_transfer);
CU_add_test(suite, "test_spdk_nvme_transport_id_parse_trtype",
test_spdk_nvme_transport_id_parse_trtype);
CU_add_test(suite, "test_spdk_nvme_transport_id_parse_adrfam",
test_spdk_nvme_transport_id_parse_adrfam);
CU_add_test(suite, "test_trid_parse_and_compare",
test_trid_parse_and_compare);
CU_add_test(suite, "test_trid_trtype_str",
test_trid_trtype_str);
CU_add_test(suite, "test_trid_adrfam_str",
test_trid_adrfam_str);
CU_add_test(suite, "test_nvme_ctrlr_probe",
test_nvme_ctrlr_probe);
CU_add_test(suite, "test_spdk_nvme_probe",
test_spdk_nvme_probe);
CU_add_test(suite, "test_spdk_nvme_connect",
test_spdk_nvme_connect);
CU_add_test(suite, "test_nvme_pci_probe_internal",
test_nvme_ctrlr_probe_internal);
CU_add_test(suite, "test_nvme_init_controllers",
test_nvme_init_controllers);
CU_add_test(suite, "test_nvme_driver_init",
test_nvme_driver_init);
CU_add_test(suite, "test_spdk_nvme_detach",
test_spdk_nvme_detach);
CU_add_test(suite, "test_nvme_completion_poll_cb",
test_nvme_completion_poll_cb);
CU_add_test(suite, "test_nvme_user_copy_cmd_complete",
test_nvme_user_copy_cmd_complete);
CU_add_test(suite, "test_nvme_allocate_request_null",
test_nvme_allocate_request_null);
CU_add_test(suite, "test_nvme_allocate_request",
test_nvme_allocate_request);
CU_add_test(suite, "test_nvme_free_request",
test_nvme_free_request);
CU_add_test(suite, "test_nvme_allocate_request_user_copy",
test_nvme_allocate_request_user_copy);
CU_add_test(suite, "test_nvme_robust_mutex_init_shared",
test_nvme_robust_mutex_init_shared);
CU_add_test(suite, "test_nvme_request_check_timeout",
test_nvme_request_check_timeout);
CU_add_test(suite, "test_nvme_wait_for_completion",
test_nvme_wait_for_completion);
CU_ADD_TEST(suite, test_opc_data_transfer);
CU_ADD_TEST(suite, test_spdk_nvme_transport_id_parse_trtype);
CU_ADD_TEST(suite, test_spdk_nvme_transport_id_parse_adrfam);
CU_ADD_TEST(suite, test_trid_parse_and_compare);
CU_ADD_TEST(suite, test_trid_trtype_str);
CU_ADD_TEST(suite, test_trid_adrfam_str);
CU_ADD_TEST(suite, test_nvme_ctrlr_probe);
CU_ADD_TEST(suite, test_spdk_nvme_probe);
CU_ADD_TEST(suite, test_spdk_nvme_connect);
CU_ADD_TEST(suite, test_nvme_ctrlr_probe_internal);
CU_ADD_TEST(suite, test_nvme_init_controllers);
CU_ADD_TEST(suite, test_nvme_driver_init);
CU_ADD_TEST(suite, test_spdk_nvme_detach);
CU_ADD_TEST(suite, test_nvme_completion_poll_cb);
CU_ADD_TEST(suite, test_nvme_user_copy_cmd_complete);
CU_ADD_TEST(suite, test_nvme_allocate_request_null);
CU_ADD_TEST(suite, test_nvme_allocate_request);
CU_ADD_TEST(suite, test_nvme_free_request);
CU_ADD_TEST(suite, test_nvme_allocate_request_user_copy);
CU_ADD_TEST(suite, test_nvme_robust_mutex_init_shared);
CU_ADD_TEST(suite, test_nvme_request_check_timeout);
CU_ADD_TEST(suite, test_nvme_wait_for_completion);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

68
test/unit/lib/nvme/nvme_ctrlr.c/nvme_ctrlr_ut.c
View File

@ -2082,51 +2082,33 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvme_ctrlr", NULL, NULL);
CU_add_test(suite, "test nvme_ctrlr init CC.EN = 1 CSTS.RDY = 0",
test_nvme_ctrlr_init_en_1_rdy_0);
CU_add_test(suite, "test nvme_ctrlr init CC.EN = 1 CSTS.RDY = 1",
test_nvme_ctrlr_init_en_1_rdy_1);
CU_add_test(suite, "test nvme_ctrlr init CC.EN = 0 CSTS.RDY = 0",
test_nvme_ctrlr_init_en_0_rdy_0);
CU_add_test(suite, "test nvme_ctrlr init CC.EN = 0 CSTS.RDY = 1",
test_nvme_ctrlr_init_en_0_rdy_1);
CU_add_test(suite, "test nvme_ctrlr init CC.EN = 0 CSTS.RDY = 0 AMS = RR",
test_nvme_ctrlr_init_en_0_rdy_0_ams_rr);
CU_add_test(suite, "test nvme_ctrlr init CC.EN = 0 CSTS.RDY = 0 AMS = WRR",
test_nvme_ctrlr_init_en_0_rdy_0_ams_wrr);
CU_add_test(suite, "test nvme_ctrlr init CC.EN = 0 CSTS.RDY = 0 AMS = VS",
test_nvme_ctrlr_init_en_0_rdy_0_ams_vs);
CU_add_test(suite, "test_nvme_ctrlr_init_delay",
test_nvme_ctrlr_init_delay);
CU_add_test(suite, "alloc_io_qpair_rr 1", test_alloc_io_qpair_rr_1);
CU_add_test(suite, "get_default_ctrlr_opts", test_ctrlr_get_default_ctrlr_opts);
CU_add_test(suite, "get_default_io_qpair_opts", test_ctrlr_get_default_io_qpair_opts);
CU_add_test(suite, "alloc_io_qpair_wrr 1", test_alloc_io_qpair_wrr_1);
CU_add_test(suite, "alloc_io_qpair_wrr 2", test_alloc_io_qpair_wrr_2);
CU_add_test(suite, "test nvme ctrlr function update_firmware",
test_spdk_nvme_ctrlr_update_firmware);
CU_add_test(suite, "test nvme_ctrlr function nvme_ctrlr_fail", test_nvme_ctrlr_fail);
CU_add_test(suite, "test nvme ctrlr function nvme_ctrlr_construct_intel_support_log_page_list",
test_nvme_ctrlr_construct_intel_support_log_page_list);
CU_add_test(suite, "test nvme ctrlr function nvme_ctrlr_set_supported_features",
test_nvme_ctrlr_set_supported_features);
CU_add_test(suite, "test nvme ctrlr function nvme_ctrlr_set_doorbell_buffer_config",
test_spdk_nvme_ctrlr_doorbell_buffer_config);
CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_1_rdy_0);
CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_1_rdy_1);
CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_0_rdy_0);
CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_0_rdy_1);
CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_0_rdy_0_ams_rr);
CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_0_rdy_0_ams_wrr);
CU_ADD_TEST(suite, test_nvme_ctrlr_init_en_0_rdy_0_ams_vs);
CU_ADD_TEST(suite, test_nvme_ctrlr_init_delay);
CU_ADD_TEST(suite, test_alloc_io_qpair_rr_1);
CU_ADD_TEST(suite, test_ctrlr_get_default_ctrlr_opts);
CU_ADD_TEST(suite, test_ctrlr_get_default_io_qpair_opts);
CU_ADD_TEST(suite, test_alloc_io_qpair_wrr_1);
CU_ADD_TEST(suite, test_alloc_io_qpair_wrr_2);
CU_ADD_TEST(suite, test_spdk_nvme_ctrlr_update_firmware);
CU_ADD_TEST(suite, test_nvme_ctrlr_fail);
CU_ADD_TEST(suite, test_nvme_ctrlr_construct_intel_support_log_page_list);
CU_ADD_TEST(suite, test_nvme_ctrlr_set_supported_features);
CU_ADD_TEST(suite, test_spdk_nvme_ctrlr_doorbell_buffer_config);
#if 0 /* TODO: move to PCIe-specific unit test */
CU_add_test(suite, "test nvme ctrlr function nvme_ctrlr_alloc_cmb",
test_nvme_ctrlr_alloc_cmb);
CU_ADD_TEST(suite, test_nvme_ctrlr_alloc_cmb);
#endif
CU_add_test(suite, "test nvme ctrlr function test_nvme_ctrlr_test_active_ns",
test_nvme_ctrlr_test_active_ns);
CU_add_test(suite, "test nvme ctrlr function test_nvme_ctrlr_test_active_ns_error_case",
test_nvme_ctrlr_test_active_ns_error_case);
CU_add_test(suite, "test_spdk_nvme_ctrlr_reconnect_io_qpair",
test_spdk_nvme_ctrlr_reconnect_io_qpair);
CU_add_test(suite, "test_spdk_nvme_ctrlr_set_trid", test_spdk_nvme_ctrlr_set_trid);
CU_add_test(suite, "test_nvme_ctrlr_init_set_nvmf_ioccsz",
test_nvme_ctrlr_init_set_nvmf_ioccsz);
CU_add_test(suite, "test nvme ctrlr init set num queues",
test_nvme_ctrlr_init_set_num_queues);
CU_ADD_TEST(suite, test_nvme_ctrlr_test_active_ns);
CU_ADD_TEST(suite, test_nvme_ctrlr_test_active_ns_error_case);
CU_ADD_TEST(suite, test_spdk_nvme_ctrlr_reconnect_io_qpair);
CU_ADD_TEST(suite, test_spdk_nvme_ctrlr_set_trid);
CU_ADD_TEST(suite, test_nvme_ctrlr_init_set_nvmf_ioccsz);
CU_ADD_TEST(suite, test_nvme_ctrlr_init_set_num_queues);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

39
test/unit/lib/nvme/nvme_ctrlr_cmd.c/nvme_ctrlr_cmd_ut.c
View File

@ -723,26 +723,25 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvme_ctrlr_cmd", NULL, NULL);
CU_add_test(suite, "test ctrlr cmd get_log_pages", test_get_log_pages);
CU_add_test(suite, "test ctrlr cmd set_feature", test_set_feature_cmd);
CU_add_test(suite, "test ctrlr cmd set_feature_ns", test_set_feature_ns_cmd);
CU_add_test(suite, "test ctrlr cmd get_feature", test_get_feature_cmd);
CU_add_test(suite, "test ctrlr cmd get_feature_ns", test_get_feature_ns_cmd);
CU_add_test(suite, "test ctrlr cmd abort_cmd", test_abort_cmd);
CU_add_test(suite, "test ctrlr cmd set_host_id", test_set_host_id_cmds);
CU_add_test(suite, "test ctrlr cmd io_raw_no_payload_build",
test_io_cmd_raw_no_payload_build);
CU_add_test(suite, "test ctrlr cmd io_raw_cmd", test_io_raw_cmd);
CU_add_test(suite, "test ctrlr cmd io_raw_cmd_with_md", test_io_raw_cmd_with_md);
CU_add_test(suite, "test ctrlr cmd namespace_attach", test_namespace_attach);
CU_add_test(suite, "test ctrlr cmd namespace_detach", test_namespace_detach);
CU_add_test(suite, "test ctrlr cmd namespace_create", test_namespace_create);
CU_add_test(suite, "test ctrlr cmd namespace_delete", test_namespace_delete);
CU_add_test(suite, "test ctrlr cmd doorbell_buffer_config", test_doorbell_buffer_config);
CU_add_test(suite, "test ctrlr cmd format_nvme", test_format_nvme);
CU_add_test(suite, "test ctrlr cmd fw_commit", test_fw_commit);
CU_add_test(suite, "test ctrlr cmd fw_image_download", test_fw_image_download);
CU_add_test(suite, "test ctrlr cmd sanitize", test_sanitize);
CU_ADD_TEST(suite, test_get_log_pages);
CU_ADD_TEST(suite, test_set_feature_cmd);
CU_ADD_TEST(suite, test_set_feature_ns_cmd);
CU_ADD_TEST(suite, test_get_feature_cmd);
CU_ADD_TEST(suite, test_get_feature_ns_cmd);
CU_ADD_TEST(suite, test_abort_cmd);
CU_ADD_TEST(suite, test_set_host_id_cmds);
CU_ADD_TEST(suite, test_io_cmd_raw_no_payload_build);
CU_ADD_TEST(suite, test_io_raw_cmd);
CU_ADD_TEST(suite, test_io_raw_cmd_with_md);
CU_ADD_TEST(suite, test_namespace_attach);
CU_ADD_TEST(suite, test_namespace_detach);
CU_ADD_TEST(suite, test_namespace_create);
CU_ADD_TEST(suite, test_namespace_delete);
CU_ADD_TEST(suite, test_doorbell_buffer_config);
CU_ADD_TEST(suite, test_format_nvme);
CU_ADD_TEST(suite, test_fw_commit);
CU_ADD_TEST(suite, test_fw_image_download);
CU_ADD_TEST(suite, test_sanitize);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

2
test/unit/lib/nvme/nvme_ctrlr_ocssd_cmd.c/nvme_ctrlr_ocssd_cmd_ut.c
View File

@ -96,7 +96,7 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvme_ctrlr_cmd", NULL, NULL);
CU_add_test(suite, "test ocssd ctrlr geometry cmd ", test_geometry_cmd);
CU_ADD_TEST(suite, test_geometry_cmd);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

4
test/unit/lib/nvme/nvme_ns.c/nvme_ns_ut.c
View File

@ -142,8 +142,8 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvme", NULL, NULL);
CU_add_test(suite, "test_nvme_ns", test_nvme_ns_construct);
CU_add_test(suite, "test_nvme_ns_uuid", test_nvme_ns_uuid);
CU_ADD_TEST(suite, test_nvme_ns_construct);
CU_ADD_TEST(suite, test_nvme_ns_uuid);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

49
test/unit/lib/nvme/nvme_ns_cmd.c/nvme_ns_cmd_ut.c
View File

@ -1706,33 +1706,28 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvme_ns_cmd", NULL, NULL);
CU_add_test(suite, "split_test", split_test);
CU_add_test(suite, "split_test2", split_test2);
CU_add_test(suite, "split_test3", split_test3);
CU_add_test(suite, "split_test4", split_test4);
CU_add_test(suite, "nvme_ns_cmd_flush", test_nvme_ns_cmd_flush);
CU_add_test(suite, "nvme_ns_cmd_dataset_management",
test_nvme_ns_cmd_dataset_management);
CU_add_test(suite, "io_flags", test_io_flags);
CU_add_test(suite, "nvme_ns_cmd_write_zeroes", test_nvme_ns_cmd_write_zeroes);
CU_add_test(suite, "nvme_ns_cmd_write_uncorrectable",
test_nvme_ns_cmd_write_uncorrectable);
CU_add_test(suite, "nvme_ns_cmd_reservation_register",
test_nvme_ns_cmd_reservation_register);
CU_add_test(suite, "nvme_ns_cmd_reservation_release",
test_nvme_ns_cmd_reservation_release);
CU_add_test(suite, "nvme_ns_cmd_reservation_acquire",
test_nvme_ns_cmd_reservation_acquire);
CU_add_test(suite, "nvme_ns_cmd_reservation_report", test_nvme_ns_cmd_reservation_report);
CU_add_test(suite, "test_cmd_child_request", test_cmd_child_request);
CU_add_test(suite, "nvme_ns_cmd_readv", test_nvme_ns_cmd_readv);
CU_add_test(suite, "nvme_ns_cmd_read_with_md", test_nvme_ns_cmd_read_with_md);
CU_add_test(suite, "nvme_ns_cmd_writev", test_nvme_ns_cmd_writev);
CU_add_test(suite, "nvme_ns_cmd_write_with_md", test_nvme_ns_cmd_write_with_md);
CU_add_test(suite, "nvme_ns_cmd_comparev", test_nvme_ns_cmd_comparev);
CU_add_test(suite, "nvme_ns_cmd_compare_and_write", test_nvme_ns_cmd_compare_and_write);
CU_add_test(suite, "nvme_ns_cmd_compare_with_md", test_nvme_ns_cmd_compare_with_md);
CU_add_test(suite, "nvme_ns_cmd_comparev_with_md", test_nvme_ns_cmd_comparev_with_md);
CU_ADD_TEST(suite, split_test);
CU_ADD_TEST(suite, split_test2);
CU_ADD_TEST(suite, split_test3);
CU_ADD_TEST(suite, split_test4);
CU_ADD_TEST(suite, test_nvme_ns_cmd_flush);
CU_ADD_TEST(suite, test_nvme_ns_cmd_dataset_management);
CU_ADD_TEST(suite, test_io_flags);
CU_ADD_TEST(suite, test_nvme_ns_cmd_write_zeroes);
CU_ADD_TEST(suite, test_nvme_ns_cmd_write_uncorrectable);
CU_ADD_TEST(suite, test_nvme_ns_cmd_reservation_register);
CU_ADD_TEST(suite, test_nvme_ns_cmd_reservation_release);
CU_ADD_TEST(suite, test_nvme_ns_cmd_reservation_acquire);
CU_ADD_TEST(suite, test_nvme_ns_cmd_reservation_report);
CU_ADD_TEST(suite, test_cmd_child_request);
CU_ADD_TEST(suite, test_nvme_ns_cmd_readv);
CU_ADD_TEST(suite, test_nvme_ns_cmd_read_with_md);
CU_ADD_TEST(suite, test_nvme_ns_cmd_writev);
CU_ADD_TEST(suite, test_nvme_ns_cmd_write_with_md);
CU_ADD_TEST(suite, test_nvme_ns_cmd_comparev);
CU_ADD_TEST(suite, test_nvme_ns_cmd_compare_and_write);
CU_ADD_TEST(suite, test_nvme_ns_cmd_compare_with_md);
CU_ADD_TEST(suite, test_nvme_ns_cmd_comparev_with_md);
g_spdk_nvme_driver = &_g_nvme_driver;

32
test/unit/lib/nvme/nvme_ns_ocssd_cmd.c/nvme_ns_ocssd_cmd_ut.c
View File

@ -627,26 +627,18 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvme_ns_cmd", NULL, NULL);
CU_add_test(suite, "nvme_ns_ocssd_cmd_vector_reset", test_nvme_ocssd_ns_cmd_vector_reset);
CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_reset_single_entry",
test_nvme_ocssd_ns_cmd_vector_reset_single_entry);
CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_read_with_md",
test_nvme_ocssd_ns_cmd_vector_read_with_md);
CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_read_with_md_single_entry",
test_nvme_ocssd_ns_cmd_vector_read_with_md_single_entry);
CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_read", test_nvme_ocssd_ns_cmd_vector_read);
CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_read_single_entry",
test_nvme_ocssd_ns_cmd_vector_read_single_entry);
CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_write_with_md",
test_nvme_ocssd_ns_cmd_vector_write_with_md);
CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_write_with_md_single_entry",
test_nvme_ocssd_ns_cmd_vector_write_with_md_single_entry);
CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_write", test_nvme_ocssd_ns_cmd_vector_write);
CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_write_single_entry",
test_nvme_ocssd_ns_cmd_vector_write_single_entry);
CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_copy", test_nvme_ocssd_ns_cmd_vector_copy);
CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_copy_single_entry",
test_nvme_ocssd_ns_cmd_vector_copy_single_entry);
CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_reset);
CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_reset_single_entry);
CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_read_with_md);
CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_read_with_md_single_entry);
CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_read);
CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_read_single_entry);
CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_write_with_md);
CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_write_with_md_single_entry);
CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_write);
CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_write_single_entry);
CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_copy);
CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_copy_single_entry);
g_spdk_nvme_driver = &_g_nvme_driver;

8
test/unit/lib/nvme/nvme_pcie.c/nvme_pcie_ut.c
View File

@ -484,10 +484,10 @@ int main(int argc, char **argv)
CU_initialize_registry();
suite = CU_add_suite("nvme_pcie", NULL, NULL);
CU_add_test(suite, "prp_list_append", test_prp_list_append);
CU_add_test(suite, "nvme_pcie_hotplug_monitor", test_nvme_pcie_hotplug_monitor);
CU_add_test(suite, "shadow_doorbell_update", test_shadow_doorbell_update);
CU_add_test(suite, "build_contig_hw_sgl_request", test_build_contig_hw_sgl_request);
CU_ADD_TEST(suite, test_prp_list_append);
CU_ADD_TEST(suite, test_nvme_pcie_hotplug_monitor);
CU_ADD_TEST(suite, test_shadow_doorbell_update);
CU_ADD_TEST(suite, test_build_contig_hw_sgl_request);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

22
test/unit/lib/nvme/nvme_qpair.c/nvme_qpair_ut.c
View File

@ -602,21 +602,17 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvme_qpair", NULL, NULL);
CU_add_test(suite, "test3", test3);
CU_add_test(suite, "ctrlr_failed", test_ctrlr_failed);
CU_add_test(suite, "struct_packing", struct_packing);
CU_add_test(suite, "spdk_nvme_qpair_process_completions",
test_nvme_qpair_process_completions);
CU_add_test(suite, "nvme_completion_is_retry", test_nvme_completion_is_retry);
CU_ADD_TEST(suite, test3);
CU_ADD_TEST(suite, test_ctrlr_failed);
CU_ADD_TEST(suite, struct_packing);
CU_ADD_TEST(suite, test_nvme_qpair_process_completions);
CU_ADD_TEST(suite, test_nvme_completion_is_retry);
#ifdef DEBUG
CU_add_test(suite, "get_status_string", test_get_status_string);
CU_ADD_TEST(suite, test_get_status_string);
#endif
CU_add_test(suite, "spdk_nvme_qpair_add_cmd_error_injection",
test_nvme_qpair_add_cmd_error_injection);
CU_add_test(suite, "spdk_nvme_qpair_submit_request",
test_nvme_qpair_submit_request);
CU_add_test(suite, "nvme_qpair_resubmit_request_with_transport_failed",
test_nvme_qpair_resubmit_request_with_transport_failed);
CU_ADD_TEST(suite, test_nvme_qpair_add_cmd_error_injection);
CU_ADD_TEST(suite, test_nvme_qpair_submit_request);
CU_ADD_TEST(suite, test_nvme_qpair_resubmit_request_with_transport_failed);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

3
test/unit/lib/nvme/nvme_quirks.c/nvme_quirks_ut.c
View File

@ -81,8 +81,7 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvme_quirks", NULL, NULL);
CU_add_test(suite, "test nvme_quirks striping",
test_nvme_quirks_striping);
CU_ADD_TEST(suite, test_nvme_quirks_striping);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

2
test/unit/lib/nvme/nvme_rdma.c/nvme_rdma_ut.c
View File

@ -208,7 +208,7 @@ int main(int argc, char **argv)
CU_initialize_registry();
suite = CU_add_suite("nvme_rdma", NULL, NULL);
CU_add_test(suite, "build_sgl_request", test_nvme_rdma_build_sgl_request);
CU_ADD_TEST(suite, test_nvme_rdma_build_sgl_request);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

15
test/unit/lib/nvme/nvme_tcp.c/nvme_tcp_ut.c
View File

@ -439,16 +439,11 @@ int main(int argc, char **argv)
CU_initialize_registry();
suite = CU_add_suite("nvme_tcp", NULL, NULL);
CU_add_test(suite, "nvme_tcp_pdu_set_data_buf",
test_nvme_tcp_pdu_set_data_buf);
CU_add_test(suite, "nvme_tcp_build_iovs",
test_nvme_tcp_build_iovs);
CU_add_test(suite, "build_sgl_request",
test_nvme_tcp_build_sgl_request);
CU_add_test(suite, "nvme_tcp_pdu_set_data_buf_with_md",
test_nvme_tcp_pdu_set_data_buf_with_md);
CU_add_test(suite, "nvme_tcp_build_iovs_with_md",
test_nvme_tcp_build_iovs_with_md);
CU_ADD_TEST(suite, test_nvme_tcp_pdu_set_data_buf);
CU_ADD_TEST(suite, test_nvme_tcp_build_iovs);
CU_ADD_TEST(suite, test_nvme_tcp_build_sgl_request);
CU_ADD_TEST(suite, test_nvme_tcp_pdu_set_data_buf_with_md);
CU_ADD_TEST(suite, test_nvme_tcp_build_iovs_with_md);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

3
test/unit/lib/nvme/nvme_uevent.c/nvme_uevent_ut.c
View File

@ -155,8 +155,7 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvme_uevent", NULL, NULL);
CU_add_test(suite, "test_nvme_uevent_parse_event",
test_nvme_uevent_parse_event);
CU_ADD_TEST(suite, test_nvme_uevent_parse_event);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

33
test/unit/lib/nvmf/ctrlr.c/ctrlr_ut.c
View File

@ -1603,24 +1603,21 @@ int main(int argc, char **argv)
CU_initialize_registry();
suite = CU_add_suite("nvmf", NULL, NULL);
CU_add_test(suite, "get_log_page", test_get_log_page);
CU_add_test(suite, "process_fabrics_cmd", test_process_fabrics_cmd);
CU_add_test(suite, "connect", test_connect);
CU_add_test(suite, "get_ns_id_desc_list", test_get_ns_id_desc_list);
CU_add_test(suite, "identify_ns", test_identify_ns);
CU_add_test(suite, "reservation_write_exclusive", test_reservation_write_exclusive);
CU_add_test(suite, "reservation_exclusive_access", test_reservation_exclusive_access);
CU_add_test(suite, "reservation_write_exclusive_regs_only_and_all_regs",
test_reservation_write_exclusive_regs_only_and_all_regs);
CU_add_test(suite, "reservation_exclusive_access_regs_only_and_all_regs",
test_reservation_exclusive_access_regs_only_and_all_regs);
CU_add_test(suite, "reservation_notification_log_page",
test_reservation_notification_log_page);
CU_add_test(suite, "get_dif_ctx", test_get_dif_ctx);
CU_add_test(suite, "set_get_features", test_set_get_features);
CU_add_test(suite, "identify_ctrlr", test_identify_ctrlr);
CU_add_test(suite, "custom_admin_cmd", test_custom_admin_cmd);
CU_add_test(suite, "fused_compare_and_write", test_fused_compare_and_write);
CU_ADD_TEST(suite, test_get_log_page);
CU_ADD_TEST(suite, test_process_fabrics_cmd);
CU_ADD_TEST(suite, test_connect);
CU_ADD_TEST(suite, test_get_ns_id_desc_list);
CU_ADD_TEST(suite, test_identify_ns);
CU_ADD_TEST(suite, test_reservation_write_exclusive);
CU_ADD_TEST(suite, test_reservation_exclusive_access);
CU_ADD_TEST(suite, test_reservation_write_exclusive_regs_only_and_all_regs);
CU_ADD_TEST(suite, test_reservation_exclusive_access_regs_only_and_all_regs);
CU_ADD_TEST(suite, test_reservation_notification_log_page);
CU_ADD_TEST(suite, test_get_dif_ctx);
CU_ADD_TEST(suite, test_set_get_features);
CU_ADD_TEST(suite, test_identify_ctrlr);
CU_ADD_TEST(suite, test_custom_admin_cmd);
CU_ADD_TEST(suite, test_fused_compare_and_write);
allocate_threads(1);
set_thread(0);

9
test/unit/lib/nvmf/ctrlr_bdev.c/ctrlr_bdev_ut.c
View File

@ -401,12 +401,11 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvmf", NULL, NULL);
CU_add_test(suite, "get_rw_params", test_get_rw_params);
CU_add_test(suite, "lba_in_range", test_lba_in_range);
CU_add_test(suite, "get_dif_ctx", test_get_dif_ctx);
CU_ADD_TEST(suite, test_get_rw_params);
CU_ADD_TEST(suite, test_lba_in_range);
CU_ADD_TEST(suite, test_get_dif_ctx);
CU_add_test(suite, "spdk_nvmf_bdev_ctrlr_compare_and_write_cmd",
test_spdk_nvmf_bdev_ctrlr_compare_and_write_cmd);
CU_ADD_TEST(suite, test_spdk_nvmf_bdev_ctrlr_compare_and_write_cmd);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

2
test/unit/lib/nvmf/ctrlr_discovery.c/ctrlr_discovery_ut.c
View File

@ -293,7 +293,7 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvmf", NULL, NULL);
CU_add_test(suite, "discovery_log", test_discovery_log);
CU_ADD_TEST(suite, test_discovery_log);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

24
test/unit/lib/nvmf/fc.c/fc_ut.c
View File

@ -485,23 +485,13 @@ int main(int argc, char **argv)
suite = CU_add_suite("NVMf-FC", nvmf_fc_tests_init, nvmf_fc_tests_fini);
CU_add_test(suite, "Create Target & FC Transport",
create_transport_test);
CU_add_test(suite, "Create Poll Groups",
create_poll_groups_test);
CU_add_test(suite, "Create FC Port",
create_fc_port_test);
CU_add_test(suite, "Online FC Port",
online_fc_port_test);
CU_add_test(suite, "PG poll", poll_group_poll_test);
CU_add_test(suite, "Remove HWQP's from PG's",
remove_hwqps_from_poll_groups_test);
CU_add_test(suite, "Destroy Transport & Target",
destroy_transport_test);
CU_ADD_TEST(suite, create_transport_test);
CU_ADD_TEST(suite, create_poll_groups_test);
CU_ADD_TEST(suite, create_fc_port_test);
CU_ADD_TEST(suite, online_fc_port_test);
CU_ADD_TEST(suite, poll_group_poll_test);
CU_ADD_TEST(suite, remove_hwqps_from_poll_groups_test);
CU_ADD_TEST(suite, destroy_transport_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

25
test/unit/lib/nvmf/fc_ls.c/fc_ls_ut.c
View File

@ -1033,36 +1033,35 @@ int main(int argc, char **argv)
if (test == 0) {
CU_add_test(suite, "CASS/DISC", create_single_assoc_test);
CU_ADD_TEST(suite, create_single_assoc_test);
CU_add_test(suite, "Max. Connections", create_max_conns_test);
CU_add_test(suite, "CIOC to bad assoc_id", invalid_connection_test);
CU_add_test(suite, "DISC bad assoc_id", disconnect_bad_assoc_test);
CU_ADD_TEST(suite, create_max_conns_test);
CU_ADD_TEST(suite, invalid_connection_test);
CU_ADD_TEST(suite, disconnect_bad_assoc_test);
CU_add_test(suite, "Create/delete max. assocs/conns", create_max_aq_conns_test);
CU_add_test(suite, "Xmt LS RSP ERR Cleanup", xmt_ls_rsp_failure_test);
CU_ADD_TEST(suite, create_max_aq_conns_test);
CU_ADD_TEST(suite, xmt_ls_rsp_failure_test);
} else {
switch (test) {
case 1:
CU_add_test(suite, "CASS/DISC", create_single_assoc_test);
CU_ADD_TEST(suite, create_single_assoc_test);
break;
case 2:
CU_add_test(suite, "Max. Connections", create_max_conns_test);
CU_ADD_TEST(suite, create_max_conns_test);
break;
case 3:
CU_add_test(suite, "CIOC to bad assoc_id", invalid_connection_test);
CU_ADD_TEST(suite, invalid_connection_test);
break;
case 4:
CU_add_test(suite, "Create/delete max. assocs/conns",
create_max_aq_conns_test);
CU_ADD_TEST(suite, create_max_aq_conns_test);
break;
case 5:
CU_add_test(suite, "Xmt LS RSP ERR Cleanup", xmt_ls_rsp_failure_test);
CU_ADD_TEST(suite, xmt_ls_rsp_failure_test);
break;
case 6:
CU_add_test(suite, "DISC bad assoc_id", disconnect_bad_assoc_test);
CU_ADD_TEST(suite, disconnect_bad_assoc_test);
break;
default:

8
test/unit/lib/nvmf/rdma.c/rdma_ut.c
View File

@ -1285,10 +1285,10 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvmf", NULL, NULL);
CU_add_test(suite, "test_parse_sgl", test_spdk_nvmf_rdma_request_parse_sgl);
CU_add_test(suite, "test_request_process", test_spdk_nvmf_rdma_request_process);
CU_add_test(suite, "test_optimal_pg", test_spdk_nvmf_rdma_get_optimal_poll_group);
CU_add_test(suite, "test_parse_sgl_with_md", test_spdk_nvmf_rdma_request_parse_sgl_with_md);
CU_ADD_TEST(suite, test_spdk_nvmf_rdma_request_parse_sgl);
CU_ADD_TEST(suite, test_spdk_nvmf_rdma_request_process);
CU_ADD_TEST(suite, test_spdk_nvmf_rdma_get_optimal_poll_group);
CU_ADD_TEST(suite, test_spdk_nvmf_rdma_request_parse_sgl_with_md);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

33
test/unit/lib/nvmf/subsystem.c/subsystem_ut.c
View File

@ -1313,25 +1313,20 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvmf", NULL, NULL);
CU_add_test(suite, "create_subsystem", nvmf_test_create_subsystem);
CU_add_test(suite, "nvmf_subsystem_add_ns", test_spdk_nvmf_subsystem_add_ns);
CU_add_test(suite, "nvmf_subsystem_set_sn", test_spdk_nvmf_subsystem_set_sn);
CU_add_test(suite, "reservation_register", test_reservation_register);
CU_add_test(suite, "reservation_register_with_ptpl", test_reservation_register_with_ptpl);
CU_add_test(suite, "reservation_acquire_preempt_1", test_reservation_acquire_preempt_1);
CU_add_test(suite, "reservation_acquire_release_with_ptpl",
test_reservation_acquire_release_with_ptpl);
CU_add_test(suite, "reservation_release", test_reservation_release);
CU_add_test(suite, "reservation_unregister_notification",
test_reservation_unregister_notification);
CU_add_test(suite, "reservation_release_notification",
test_reservation_release_notification);
CU_add_test(suite, "reservation_release_notification_write_exclusive",
test_reservation_release_notification_write_exclusive);
CU_add_test(suite, "reservation_clear_notification", test_reservation_clear_notification);
CU_add_test(suite, "reservation_preempt_notification",
test_reservation_preempt_notification);
CU_add_test(suite, "spdk_nvmf_ns_event", test_spdk_nvmf_ns_event);
CU_ADD_TEST(suite, nvmf_test_create_subsystem);
CU_ADD_TEST(suite, test_spdk_nvmf_subsystem_add_ns);
CU_ADD_TEST(suite, test_spdk_nvmf_subsystem_set_sn);
CU_ADD_TEST(suite, test_reservation_register);
CU_ADD_TEST(suite, test_reservation_register_with_ptpl);
CU_ADD_TEST(suite, test_reservation_acquire_preempt_1);
CU_ADD_TEST(suite, test_reservation_acquire_release_with_ptpl);
CU_ADD_TEST(suite, test_reservation_release);
CU_ADD_TEST(suite, test_reservation_unregister_notification);
CU_ADD_TEST(suite, test_reservation_release_notification);
CU_ADD_TEST(suite, test_reservation_release_notification_write_exclusive);
CU_ADD_TEST(suite, test_reservation_clear_notification);
CU_ADD_TEST(suite, test_reservation_preempt_notification);
CU_ADD_TEST(suite, test_spdk_nvmf_ns_event);
allocate_threads(1);
set_thread(0);

12
test/unit/lib/nvmf/tcp.c/tcp_ut.c
View File

@ -681,12 +681,12 @@ int main(int argc, char **argv)
suite = CU_add_suite("nvmf", NULL, NULL);
CU_add_test(suite, "nvmf_tcp_create", test_nvmf_tcp_create);
CU_add_test(suite, "nvmf_tcp_destroy", test_nvmf_tcp_destroy);
CU_add_test(suite, "nvmf_tcp_poll_group_create", test_nvmf_tcp_poll_group_create);
CU_add_test(suite, "nvmf_tcp_send_c2h_data", test_nvmf_tcp_send_c2h_data);
CU_add_test(suite, "nvmf_tcp_h2c_data_hdr_handle", test_nvmf_tcp_h2c_data_hdr_handle);
CU_add_test(suite, "nvmf_tcp_incapsule_test", test_nvmf_tcp_incapsule_data_handle);
CU_ADD_TEST(suite, test_nvmf_tcp_create);
CU_ADD_TEST(suite, test_nvmf_tcp_destroy);
CU_ADD_TEST(suite, test_nvmf_tcp_poll_group_create);
CU_ADD_TEST(suite, test_nvmf_tcp_send_c2h_data);
CU_ADD_TEST(suite, test_nvmf_tcp_h2c_data_hdr_handle);
CU_ADD_TEST(suite, test_nvmf_tcp_incapsule_data_handle);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

26
test/unit/lib/reduce/reduce.c/reduce_ut.c
View File

@ -1282,19 +1282,19 @@ main(int argc, char **argv)
suite = CU_add_suite("reduce", NULL, NULL);
CU_add_test(suite, "get_pm_file_size", get_pm_file_size);
CU_add_test(suite, "get_vol_size", get_vol_size);
CU_add_test(suite, "init_failure", init_failure);
CU_add_test(suite, "init_md", init_md);
CU_add_test(suite, "init_backing_dev", init_backing_dev);
CU_add_test(suite, "load", load);
CU_add_test(suite, "write_maps", write_maps);
CU_add_test(suite, "read_write", read_write);
CU_add_test(suite, "readv_writev", readv_writev);
CU_add_test(suite, "destroy", destroy);
CU_add_test(suite, "defer_bdev_io", defer_bdev_io);
CU_add_test(suite, "overlapped", overlapped);
CU_add_test(suite, "compress_algorithm", compress_algorithm);
CU_ADD_TEST(suite, get_pm_file_size);
CU_ADD_TEST(suite, get_vol_size);
CU_ADD_TEST(suite, init_failure);
CU_ADD_TEST(suite, init_md);
CU_ADD_TEST(suite, init_backing_dev);
CU_ADD_TEST(suite, load);
CU_ADD_TEST(suite, write_maps);
CU_ADD_TEST(suite, read_write);
CU_ADD_TEST(suite, readv_writev);
CU_ADD_TEST(suite, destroy);
CU_ADD_TEST(suite, defer_bdev_io);
CU_ADD_TEST(suite, overlapped);
CU_ADD_TEST(suite, compress_algorithm);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

75
test/unit/lib/scsi/dev.c/dev_ut.c
View File

@ -649,54 +649,33 @@ main(int argc, char **argv)
suite = CU_add_suite("dev_suite", NULL, NULL);
CU_add_test(suite, "destruct - null dev",
dev_destruct_null_dev);
CU_add_test(suite, "destruct - zero luns", dev_destruct_zero_luns);
CU_add_test(suite, "destruct - null lun", dev_destruct_null_lun);
CU_add_test(suite, "destruct - success", dev_destruct_success);
CU_add_test(suite, "construct - queue depth gt max depth",
dev_construct_num_luns_zero);
CU_add_test(suite, "construct - no lun0",
dev_construct_no_lun_zero);
CU_add_test(suite, "construct - null lun",
dev_construct_null_lun);
CU_add_test(suite, "construct - name too long", dev_construct_name_too_long);
CU_add_test(suite, "construct - success", dev_construct_success);
CU_add_test(suite, "construct - success - LUN zero not first",
dev_construct_success_lun_zero_not_first);
CU_add_test(suite, "dev queue task mgmt - success",
dev_queue_mgmt_task_success);
CU_add_test(suite, "dev queue task - success",
dev_queue_task_success);
CU_add_test(suite, "dev stop - success", dev_stop_success);
CU_add_test(suite, "dev add port - max ports",
dev_add_port_max_ports);
CU_add_test(suite, "dev add port - construct port failure 1",
dev_add_port_construct_failure1);
CU_add_test(suite, "dev add port - construct port failure 2",
dev_add_port_construct_failure2);
CU_add_test(suite, "dev add port - success 1",
dev_add_port_success1);
CU_add_test(suite, "dev add port - success 2",
dev_add_port_success2);
CU_add_test(suite, "dev add port - success 3",
dev_add_port_success3);
CU_add_test(suite, "dev find port by id - num ports zero",
dev_find_port_by_id_num_ports_zero);
CU_add_test(suite, "dev find port by id - different port id failure",
dev_find_port_by_id_id_not_found_failure);
CU_add_test(suite, "dev find port by id - success",
dev_find_port_by_id_success);
CU_add_test(suite, "dev add lun - bdev not found",
dev_add_lun_bdev_not_found);
CU_add_test(suite, "dev add lun - no free lun id",
dev_add_lun_no_free_lun_id);
CU_add_test(suite, "dev add lun - success 1",
dev_add_lun_success1);
CU_add_test(suite, "dev add lun - success 2",
dev_add_lun_success2);
CU_add_test(suite, "dev check pending tasks",
dev_check_pending_tasks);
CU_ADD_TEST(suite, dev_destruct_null_dev);
CU_ADD_TEST(suite, dev_destruct_zero_luns);
CU_ADD_TEST(suite, dev_destruct_null_lun);
CU_ADD_TEST(suite, dev_destruct_success);
CU_ADD_TEST(suite, dev_construct_num_luns_zero);
CU_ADD_TEST(suite, dev_construct_no_lun_zero);
CU_ADD_TEST(suite, dev_construct_null_lun);
CU_ADD_TEST(suite, dev_construct_name_too_long);
CU_ADD_TEST(suite, dev_construct_success);
CU_ADD_TEST(suite, dev_construct_success_lun_zero_not_first);
CU_ADD_TEST(suite, dev_queue_mgmt_task_success);
CU_ADD_TEST(suite, dev_queue_task_success);
CU_ADD_TEST(suite, dev_stop_success);
CU_ADD_TEST(suite, dev_add_port_max_ports);
CU_ADD_TEST(suite, dev_add_port_construct_failure1);
CU_ADD_TEST(suite, dev_add_port_construct_failure2);
CU_ADD_TEST(suite, dev_add_port_success1);
CU_ADD_TEST(suite, dev_add_port_success2);
CU_ADD_TEST(suite, dev_add_port_success3);
CU_ADD_TEST(suite, dev_find_port_by_id_num_ports_zero);
CU_ADD_TEST(suite, dev_find_port_by_id_id_not_found_failure);
CU_ADD_TEST(suite, dev_find_port_by_id_success);
CU_ADD_TEST(suite, dev_add_lun_bdev_not_found);
CU_ADD_TEST(suite, dev_add_lun_no_free_lun_id);
CU_ADD_TEST(suite, dev_add_lun_success1);
CU_ADD_TEST(suite, dev_add_lun_success2);
CU_ADD_TEST(suite, dev_check_pending_tasks);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

45
test/unit/lib/scsi/lun.c/lun_ut.c
View File

@ -743,35 +743,22 @@ main(int argc, char **argv)
suite = CU_add_suite("lun_suite", NULL, NULL);
CU_add_test(suite, "task management abort task - not supported",
lun_task_mgmt_execute_abort_task_not_supported);
CU_add_test(suite, "task management abort task set - success",
lun_task_mgmt_execute_abort_task_all_not_supported);
CU_add_test(suite, "task management - lun reset success",
lun_task_mgmt_execute_lun_reset);
CU_add_test(suite, "task management - invalid option",
lun_task_mgmt_execute_invalid_case);
CU_add_test(suite, "append task - null lun SPDK_SPC_INQUIRY",
lun_append_task_null_lun_task_cdb_spc_inquiry);
CU_add_test(suite, "append task - allocated length less than 4096",
lun_append_task_null_lun_alloc_len_lt_4096);
CU_add_test(suite, "append task - unsupported lun",
lun_append_task_null_lun_not_supported);
CU_add_test(suite, "execute task - scsi task pending",
lun_execute_scsi_task_pending);
CU_add_test(suite, "execute task - scsi task complete",
lun_execute_scsi_task_complete);
CU_add_test(suite, "destruct task - success", lun_destruct_success);
CU_add_test(suite, "construct - null ctx", lun_construct_null_ctx);
CU_add_test(suite, "construct - success", lun_construct_success);
CU_add_test(suite, "reset task wait for prior task completion",
lun_reset_task_wait_scsi_task_complete);
CU_add_test(suite, "reset task suspend subsequent scsi task",
lun_reset_task_suspend_scsi_task);
CU_add_test(suite, "check pending tasks only for specific initiator",
lun_check_pending_tasks_only_for_specific_initiator);
CU_add_test(suite, "abort_pending_mgmt_tasks_when_lun_is_removed",
abort_pending_mgmt_tasks_when_lun_is_removed);
CU_ADD_TEST(suite, lun_task_mgmt_execute_abort_task_not_supported);
CU_ADD_TEST(suite, lun_task_mgmt_execute_abort_task_all_not_supported);
CU_ADD_TEST(suite, lun_task_mgmt_execute_lun_reset);
CU_ADD_TEST(suite, lun_task_mgmt_execute_invalid_case);
CU_ADD_TEST(suite, lun_append_task_null_lun_task_cdb_spc_inquiry);
CU_ADD_TEST(suite, lun_append_task_null_lun_alloc_len_lt_4096);
CU_ADD_TEST(suite, lun_append_task_null_lun_not_supported);
CU_ADD_TEST(suite, lun_execute_scsi_task_pending);
CU_ADD_TEST(suite, lun_execute_scsi_task_complete);
CU_ADD_TEST(suite, lun_destruct_success);
CU_ADD_TEST(suite, lun_construct_null_ctx);
CU_ADD_TEST(suite, lun_construct_success);
CU_ADD_TEST(suite, lun_reset_task_wait_scsi_task_complete);
CU_ADD_TEST(suite, lun_reset_task_suspend_scsi_task);
CU_ADD_TEST(suite, lun_check_pending_tasks_only_for_specific_initiator);
CU_ADD_TEST(suite, abort_pending_mgmt_tasks_when_lun_is_removed);
CU_basic_set_mode(CU_BRM_VERBOSE);
allocate_threads(1);

2
test/unit/lib/scsi/scsi.c/scsi_ut.c
View File

@ -59,7 +59,7 @@ main(int argc, char **argv)
suite = CU_add_suite("scsi_suite", NULL, NULL);
CU_add_test(suite, "scsi init", scsi_init);
CU_ADD_TEST(suite, scsi_init);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

26
test/unit/lib/scsi/scsi_bdev.c/scsi_bdev_ut.c
View File

@ -1012,19 +1012,19 @@ main(int argc, char **argv)
suite = CU_add_suite("translation_suite", NULL, NULL);
CU_add_test(suite, "mode select 6 test", mode_select_6_test);
CU_add_test(suite, "mode select 6 test2", mode_select_6_test2);
CU_add_test(suite, "mode sense 6 test", mode_sense_6_test);
CU_add_test(suite, "mode sense 10 test", mode_sense_10_test);
CU_add_test(suite, "inquiry evpd test", inquiry_evpd_test);
CU_add_test(suite, "inquiry standard test", inquiry_standard_test);
CU_add_test(suite, "inquiry overflow test", inquiry_overflow_test);
CU_add_test(suite, "task complete test", task_complete_test);
CU_add_test(suite, "LBA range test", lba_range_test);
CU_add_test(suite, "transfer length test", xfer_len_test);
CU_add_test(suite, "transfer test", xfer_test);
CU_add_test(suite, "scsi name padding test", scsi_name_padding_test);
CU_add_test(suite, "get dif context test", get_dif_ctx_test);
CU_ADD_TEST(suite, mode_select_6_test);
CU_ADD_TEST(suite, mode_select_6_test2);
CU_ADD_TEST(suite, mode_sense_6_test);
CU_ADD_TEST(suite, mode_sense_10_test);
CU_ADD_TEST(suite, inquiry_evpd_test);
CU_ADD_TEST(suite, inquiry_standard_test);
CU_ADD_TEST(suite, inquiry_overflow_test);
CU_ADD_TEST(suite, task_complete_test);
CU_ADD_TEST(suite, lba_range_test);
CU_ADD_TEST(suite, xfer_len_test);
CU_ADD_TEST(suite, xfer_test);
CU_ADD_TEST(suite, scsi_name_padding_test);
CU_ADD_TEST(suite, get_dif_ctx_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

10
test/unit/lib/scsi/scsi_pr.c/scsi_pr_ut.c
View File

@ -545,11 +545,11 @@ main(int argc, char **argv)
CU_initialize_registry();
suite = CU_add_suite("reservation_suite", NULL, NULL);
CU_add_test(suite, "register", test_reservation_register);
CU_add_test(suite, "reserve", test_reservation_reserve);
CU_add_test(suite, "preempt", test_reservation_preempt_non_all_regs);
CU_add_test(suite, "preempt all regs", test_reservation_preempt_all_regs);
CU_add_test(suite, "conflict", test_reservation_cmds_conflict);
CU_ADD_TEST(suite, test_reservation_register);
CU_ADD_TEST(suite, test_reservation_reserve);
CU_ADD_TEST(suite, test_reservation_preempt_non_all_regs);
CU_ADD_TEST(suite, test_reservation_preempt_all_regs);
CU_ADD_TEST(suite, test_reservation_cmds_conflict);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

2
test/unit/lib/sock/posix.c/posix_ut.c
View File

@ -161,7 +161,7 @@ main(int argc, char **argv)
suite = CU_add_suite("posix", NULL, NULL);
CU_add_test(suite, "flush", flush);
CU_ADD_TEST(suite, flush);
CU_basic_set_mode(CU_BRM_VERBOSE);

12
test/unit/lib/sock/sock.c/sock_ut.c
View File

@ -827,12 +827,12 @@ main(int argc, char **argv)
suite = CU_add_suite("sock", NULL, NULL);
CU_add_test(suite, "posix_sock", posix_sock);
CU_add_test(suite, "ut_sock", ut_sock);
CU_add_test(suite, "posix_sock_group", posix_sock_group);
CU_add_test(suite, "ut_sock_group", ut_sock_group);
CU_add_test(suite, "posix_sock_group_fairness", posix_sock_group_fairness);
CU_add_test(suite, "posix_sock_close", posix_sock_close);
CU_ADD_TEST(suite, posix_sock);
CU_ADD_TEST(suite, ut_sock);
CU_ADD_TEST(suite, posix_sock_group);
CU_ADD_TEST(suite, ut_sock_group);
CU_ADD_TEST(suite, posix_sock_group_fairness);
CU_ADD_TEST(suite, posix_sock_close);
CU_basic_set_mode(CU_BRM_VERBOSE);

4
test/unit/lib/sock/uring.c/uring_ut.c
View File

@ -258,8 +258,8 @@ main(int argc, char **argv)
suite = CU_add_suite("uring", NULL, NULL);
CU_add_test(suite, "flush_client", flush_client);
CU_add_test(suite, "flush_server", flush_server);
CU_ADD_TEST(suite, flush_client);
CU_ADD_TEST(suite, flush_server);
CU_basic_set_mode(CU_BRM_VERBOSE);

24
test/unit/lib/thread/thread.c/thread_ut.c
View File

@ -1011,18 +1011,18 @@ main(int argc, char **argv)
suite = CU_add_suite("io_channel", NULL, NULL);
CU_add_test(suite, "thread_alloc", thread_alloc);
CU_add_test(suite, "thread_send_msg", thread_send_msg);
CU_add_test(suite, "thread_poller", thread_poller);
CU_add_test(suite, "poller_pause", poller_pause);
CU_add_test(suite, "thread_for_each", thread_for_each);
CU_add_test(suite, "for_each_channel_remove", for_each_channel_remove);
CU_add_test(suite, "for_each_channel_unreg", for_each_channel_unreg);
CU_add_test(suite, "thread_name", thread_name);
CU_add_test(suite, "channel", channel);
CU_add_test(suite, "channel_destroy_races", channel_destroy_races);
CU_add_test(suite, "thread_exit", thread_exit);
CU_add_test(suite, "thread_update_stats", thread_update_stats);
CU_ADD_TEST(suite, thread_alloc);
CU_ADD_TEST(suite, thread_send_msg);
CU_ADD_TEST(suite, thread_poller);
CU_ADD_TEST(suite, poller_pause);
CU_ADD_TEST(suite, thread_for_each);
CU_ADD_TEST(suite, for_each_channel_remove);
CU_ADD_TEST(suite, for_each_channel_unreg);
CU_ADD_TEST(suite, thread_name);
CU_ADD_TEST(suite, channel);
CU_ADD_TEST(suite, channel_destroy_races);
CU_ADD_TEST(suite, thread_exit);
CU_ADD_TEST(suite, thread_update_stats);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

13
test/unit/lib/util/base64.c/base64_ut.c
View File

@ -363,13 +363,12 @@ main(int argc, char **argv)
suite = CU_add_suite("base64", NULL, NULL);
CU_add_test(suite, "test_base64_get_encoded_strlen", test_base64_get_encoded_strlen);
CU_add_test(suite, "test_base64_get_decoded_len",
test_base64_get_decoded_len);
CU_add_test(suite, "test_base64_encode", test_base64_encode);
CU_add_test(suite, "test_base64_decode", test_base64_decode);
CU_add_test(suite, "test_base64_urlsafe_encode", test_base64_urlsafe_encode);
CU_add_test(suite, "test_base64_urlsafe_decode", test_base64_urlsafe_decode);
CU_ADD_TEST(suite, test_base64_get_encoded_strlen);
CU_ADD_TEST(suite, test_base64_get_decoded_len);
CU_ADD_TEST(suite, test_base64_encode);
CU_ADD_TEST(suite, test_base64_decode);
CU_ADD_TEST(suite, test_base64_urlsafe_encode);
CU_ADD_TEST(suite, test_base64_urlsafe_decode);
CU_basic_set_mode(CU_BRM_VERBOSE);

16
test/unit/lib/util/bit_array.c/bit_array_ut.c
View File

@ -356,14 +356,14 @@ main(int argc, char **argv)
suite = CU_add_suite("bit_array", NULL, NULL);
CU_add_test(suite, "test_1bit", test_1bit);
CU_add_test(suite, "test_64bit", test_64bit);
CU_add_test(suite, "test_find", test_find);
CU_add_test(suite, "test_resize", test_resize);
CU_add_test(suite, "test_errors", test_errors);
CU_add_test(suite, "test_count", test_count);
CU_add_test(suite, "test_mask_store_load", test_mask_store_load);
CU_add_test(suite, "test_mask_clear", test_mask_clear);
CU_ADD_TEST(suite, test_1bit);
CU_ADD_TEST(suite, test_64bit);
CU_ADD_TEST(suite, test_find);
CU_ADD_TEST(suite, test_resize);
CU_ADD_TEST(suite, test_errors);
CU_ADD_TEST(suite, test_count);
CU_ADD_TEST(suite, test_mask_store_load);
CU_ADD_TEST(suite, test_mask_clear);
CU_basic_set_mode(CU_BRM_VERBOSE);

6
test/unit/lib/util/cpuset.c/cpuset_ut.c
View File

@ -247,9 +247,9 @@ main(int argc, char **argv)
suite = CU_add_suite("cpuset", NULL, NULL);
CU_add_test(suite, "test_cpuset", test_cpuset);
CU_add_test(suite, "test_cpuset_parse", test_cpuset_parse);
CU_add_test(suite, "test_cpuset_fmt", test_cpuset_fmt);
CU_ADD_TEST(suite, test_cpuset);
CU_ADD_TEST(suite, test_cpuset_parse);
CU_ADD_TEST(suite, test_cpuset_fmt);
CU_basic_set_mode(CU_BRM_VERBOSE);

6
test/unit/lib/util/crc16.c/crc16_ut.c
View File

@ -89,9 +89,9 @@ main(int argc, char **argv)
suite = CU_add_suite("crc16", NULL, NULL);
CU_add_test(suite, "test_crc16_t10dif", test_crc16_t10dif);
CU_add_test(suite, "test_crc16_t10dif_seed", test_crc16_t10dif_seed);
CU_add_test(suite, "test_crc16_t10dif_copy", test_crc16_t10dif_copy);
CU_ADD_TEST(suite, test_crc16_t10dif);
CU_ADD_TEST(suite, test_crc16_t10dif_seed);
CU_ADD_TEST(suite, test_crc16_t10dif_copy);
CU_basic_set_mode(CU_BRM_VERBOSE);

2
test/unit/lib/util/crc32_ieee.c/crc32_ieee_ut.c
View File

@ -61,7 +61,7 @@ main(int argc, char **argv)
suite = CU_add_suite("crc32_ieee", NULL, NULL);
CU_add_test(suite, "test_crc32_ieee", test_crc32_ieee);
CU_ADD_TEST(suite, test_crc32_ieee);
CU_basic_set_mode(CU_BRM_VERBOSE);

2
test/unit/lib/util/crc32c.c/crc32c_ut.c
View File

@ -132,7 +132,7 @@ main(int argc, char **argv)
suite = CU_add_suite("crc32c", NULL, NULL);
CU_add_test(suite, "test_crc32c", test_crc32c);
CU_ADD_TEST(suite, test_crc32c);
CU_basic_set_mode(CU_BRM_VERBOSE);

145
test/unit/lib/util/dif.c/dif_ut.c
View File

@ -2605,99 +2605,58 @@ main(int argc, char **argv)
suite = CU_add_suite("dif", NULL, NULL);
CU_add_test(suite, "dif_generate_and_verify_test", dif_generate_and_verify_test);
CU_add_test(suite, "dif_disable_check_test", dif_disable_check_test);
CU_add_test(suite, "dif_sec_512_md_0_error_test", dif_sec_512_md_0_error_test);
CU_add_test(suite, "dif_guard_seed_test", dif_guard_seed_test);
CU_add_test(suite, "dif_disable_sec_512_md_8_single_iov_test",
dif_disable_sec_512_md_8_single_iov_test);
CU_add_test(suite, "dif_sec_512_md_8_prchk_0_single_iov_test",
dif_sec_512_md_8_prchk_0_single_iov_test);
CU_add_test(suite, "dif_sec_512_md_8_prchk_0_1_2_4_multi_iovs_test",
dif_sec_512_md_8_prchk_0_1_2_4_multi_iovs_test);
CU_add_test(suite, "dif_sec_4096_md_128_prchk_7_multi_iovs_test",
dif_sec_4096_md_128_prchk_7_multi_iovs_test);
CU_add_test(suite, "dif_sec_512_md_8_prchk_7_multi_iovs_split_data_and_md_test",
dif_sec_512_md_8_prchk_7_multi_iovs_split_data_and_md_test);
CU_add_test(suite, "dif_sec_512_md_8_prchk_7_multi_iovs_split_data_test",
dif_sec_512_md_8_prchk_7_multi_iovs_split_data_test);
CU_add_test(suite, "dif_sec_512_md_8_prchk_7_multi_iovs_split_guard_test",
dif_sec_512_md_8_prchk_7_multi_iovs_split_guard_test);
CU_add_test(suite, "dif_sec_512_md_8_prchk_7_multi_iovs_split_apptag_test",
dif_sec_512_md_8_prchk_7_multi_iovs_split_apptag_test);
CU_add_test(suite, "dif_sec_512_md_8_prchk_7_multi_iovs_split_reftag_test",
dif_sec_512_md_8_prchk_7_multi_iovs_split_reftag_test);
CU_add_test(suite, "dif_sec_512_md_8_prchk_7_multi_iovs_complex_splits_test",
dif_sec_512_md_8_prchk_7_multi_iovs_complex_splits_test);
CU_add_test(suite, "dif_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_test",
dif_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_test);
CU_add_test(suite, "dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test",
dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test);
CU_add_test(suite, "dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_data_and_md_test",
dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_data_and_md_test);
CU_add_test(suite, "dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_data_test",
dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_data_test);
CU_add_test(suite, "dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_guard_test",
dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_guard_test);
CU_add_test(suite, "dif_sec_4096_md_128_inject_1_2_4_8__multi_iovs_split_apptag_test",
dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_apptag_test);
CU_add_test(suite, "dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_reftag_test",
dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_reftag_test);
CU_add_test(suite, "dif_copy_sec_512_md_8_prchk_0_single_iov",
dif_copy_sec_512_md_8_prchk_0_single_iov);
CU_add_test(suite, "dif_copy_sec_512_md_8_prchk_0_1_2_4_multi_iovs",
dif_copy_sec_512_md_8_prchk_0_1_2_4_multi_iovs);
CU_add_test(suite, "dif_copy_sec_4096_md_128_prchk_7_multi_iovs",
dif_copy_sec_4096_md_128_prchk_7_multi_iovs);
CU_add_test(suite, "dif_copy_sec_512_md_8_prchk_7_multi_iovs_split_data",
dif_copy_sec_512_md_8_prchk_7_multi_iovs_split_data);
CU_add_test(suite, "dif_copy_sec_512_md_8_prchk_7_multi_iovs_complex_splits",
dif_copy_sec_512_md_8_prchk_7_multi_iovs_complex_splits);
CU_add_test(suite, "dif_copy_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test",
dif_copy_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test);
CU_add_test(suite, "dif_copy_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_test",
dif_copy_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_test);
CU_add_test(suite, "dix_sec_512_md_0_error", dix_sec_512_md_0_error);
CU_add_test(suite, "dix_sec_512_md_8_prchk_0_single_iov",
dix_sec_512_md_8_prchk_0_single_iov);
CU_add_test(suite, "dix_sec_512_md_8_prchk_0_1_2_4_multi_iovs",
dix_sec_512_md_8_prchk_0_1_2_4_multi_iovs);
CU_add_test(suite, "dix_sec_4096_md_128_prchk_7_multi_iovs",
dix_sec_4096_md_128_prchk_7_multi_iovs);
CU_add_test(suite, "dix_sec_512_md_8_prchk_7_multi_iovs_split_data",
dix_sec_512_md_8_prchk_7_multi_iovs_split_data);
CU_add_test(suite, "dix_sec_512_md_8_prchk_7_multi_iovs_complex_splits",
dix_sec_512_md_8_prchk_7_multi_iovs_complex_splits);
CU_add_test(suite, "dix_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test",
dix_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test);
CU_add_test(suite, "dix_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_test",
dix_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_test);
CU_add_test(suite, "set_md_interleave_iovs_test", set_md_interleave_iovs_test);
CU_add_test(suite, "set_md_interleave_iovs_split_test",
set_md_interleave_iovs_split_test);
CU_add_test(suite, "dif_generate_stream_test", dif_generate_stream_test);
CU_add_test(suite, "set_md_interleave_iovs_alignment_test",
set_md_interleave_iovs_alignment_test);
CU_add_test(suite, "_dif_generate_split_test", _dif_generate_split_test);
CU_add_test(suite, "set_md_interleave_iovs_multi_segments_test",
set_md_interleave_iovs_multi_segments_test);
CU_add_test(suite, "_dif_verify_split_test", _dif_verify_split_test);
CU_add_test(suite, "dif_verify_stream_multi_segments_test",
dif_verify_stream_multi_segments_test);
CU_add_test(suite, "update_crc32c_test", update_crc32c_test);
CU_add_test(suite, "_dif_update_crc32c_split_test",
_dif_update_crc32c_split_test);
CU_add_test(suite, "dif_update_crc32c_stream_multi_segments_test",
dif_update_crc32c_stream_multi_segments_test);
CU_add_test(suite, "get_range_with_md_test", get_range_with_md_test);
CU_add_test(suite, "dif_sec_4096_md_128_prchk_7_multi_iovs_remap_test",
dif_sec_4096_md_128_prchk_7_multi_iovs_remap_test);
CU_add_test(suite, "dif_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_remap_test",
dif_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_remap_test);
CU_add_test(suite, "dix_sec_4096_md_128_prchk_7_multi_iovs_remap",
dix_sec_4096_md_128_prchk_7_multi_iovs_remap);
CU_add_test(suite, "dix_sec_512_md_8_prchk_7_multi_iovs_complex_splits_remap",
dix_sec_512_md_8_prchk_7_multi_iovs_complex_splits_remap);
CU_ADD_TEST(suite, dif_generate_and_verify_test);
CU_ADD_TEST(suite, dif_disable_check_test);
CU_ADD_TEST(suite, dif_sec_512_md_0_error_test);
CU_ADD_TEST(suite, dif_guard_seed_test);
CU_ADD_TEST(suite, dif_disable_sec_512_md_8_single_iov_test);
CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_0_single_iov_test);
CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_0_1_2_4_multi_iovs_test);
CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_test);
CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_split_data_and_md_test);
CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_split_data_test);
CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_split_guard_test);
CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_split_apptag_test);
CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_split_reftag_test);
CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_complex_splits_test);
CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_test);
CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test);
CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_data_and_md_test);
CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_data_test);
CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_guard_test);
CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_apptag_test);
CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_reftag_test);
CU_ADD_TEST(suite, dif_copy_sec_512_md_8_prchk_0_single_iov);
CU_ADD_TEST(suite, dif_copy_sec_512_md_8_prchk_0_1_2_4_multi_iovs);
CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_prchk_7_multi_iovs);
CU_ADD_TEST(suite, dif_copy_sec_512_md_8_prchk_7_multi_iovs_split_data);
CU_ADD_TEST(suite, dif_copy_sec_512_md_8_prchk_7_multi_iovs_complex_splits);
CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test);
CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_test);
CU_ADD_TEST(suite, dix_sec_512_md_0_error);
CU_ADD_TEST(suite, dix_sec_512_md_8_prchk_0_single_iov);
CU_ADD_TEST(suite, dix_sec_512_md_8_prchk_0_1_2_4_multi_iovs);
CU_ADD_TEST(suite, dix_sec_4096_md_128_prchk_7_multi_iovs);
CU_ADD_TEST(suite, dix_sec_512_md_8_prchk_7_multi_iovs_split_data);
CU_ADD_TEST(suite, dix_sec_512_md_8_prchk_7_multi_iovs_complex_splits);
CU_ADD_TEST(suite, dix_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test);
CU_ADD_TEST(suite, dix_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_test);
CU_ADD_TEST(suite, set_md_interleave_iovs_test);
CU_ADD_TEST(suite, set_md_interleave_iovs_split_test);
CU_ADD_TEST(suite, dif_generate_stream_test);
CU_ADD_TEST(suite, set_md_interleave_iovs_alignment_test);
CU_ADD_TEST(suite, _dif_generate_split_test);
CU_ADD_TEST(suite, set_md_interleave_iovs_multi_segments_test);
CU_ADD_TEST(suite, _dif_verify_split_test);
CU_ADD_TEST(suite, dif_verify_stream_multi_segments_test);
CU_ADD_TEST(suite, update_crc32c_test);
CU_ADD_TEST(suite, _dif_update_crc32c_split_test);
CU_ADD_TEST(suite, dif_update_crc32c_stream_multi_segments_test);
CU_ADD_TEST(suite, get_range_with_md_test);
CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_remap_test);
CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_remap_test);
CU_ADD_TEST(suite, dix_sec_4096_md_128_prchk_7_multi_iovs_remap);
CU_ADD_TEST(suite, dix_sec_512_md_8_prchk_7_multi_iovs_complex_splits_remap);
CU_basic_set_mode(CU_BRM_VERBOSE);

6
test/unit/lib/util/iov.c/iov_ut.c
View File

@ -234,9 +234,9 @@ main(int argc, char **argv)
suite = CU_add_suite("iov", NULL, NULL);
CU_add_test(suite, "test_single_iov", test_single_iov);
CU_add_test(suite, "test_simple_iov", test_simple_iov);
CU_add_test(suite, "test_complex_iov", test_complex_iov);
CU_ADD_TEST(suite, test_single_iov);
CU_ADD_TEST(suite, test_simple_iov);
CU_ADD_TEST(suite, test_complex_iov);
CU_basic_set_mode(CU_BRM_VERBOSE);

3
test/unit/lib/util/math.c/math_ut.c
View File

@ -68,8 +68,7 @@ main(int argc, char **argv)
suite = CU_add_suite("math", NULL, NULL);
CU_add_test(suite, "test_serial_number_arithmetic",
test_serial_number_arithmetic);
CU_ADD_TEST(suite, test_serial_number_arithmetic);
CU_basic_set_mode(CU_BRM_VERBOSE);

12
test/unit/lib/util/pipe.c/pipe_ut.c
View File

@ -635,12 +635,12 @@ main(int argc, char **argv)
suite = CU_add_suite("pipe", NULL, NULL);
CU_add_test(suite, "test_create_destroy", test_create_destroy);
CU_add_test(suite, "test_write_get_buffer", test_write_get_buffer);
CU_add_test(suite, "test_write_advance", test_write_advance);
CU_add_test(suite, "test_read_get_buffer", test_read_get_buffer);
CU_add_test(suite, "test_read_advance", test_read_advance);
CU_add_test(suite, "test_data", test_data);
CU_ADD_TEST(suite, test_create_destroy);
CU_ADD_TEST(suite, test_write_get_buffer);
CU_ADD_TEST(suite, test_write_advance);
CU_ADD_TEST(suite, test_read_get_buffer);
CU_ADD_TEST(suite, test_read_advance);
CU_ADD_TEST(suite, test_data);
CU_basic_set_mode(CU_BRM_VERBOSE);

12
test/unit/lib/util/string.c/string_ut.c
View File

@ -389,12 +389,12 @@ main(int argc, char **argv)
suite = CU_add_suite("string", NULL, NULL);
CU_add_test(suite, "test_parse_ip_addr", test_parse_ip_addr);
CU_add_test(suite, "test_str_chomp", test_str_chomp);
CU_add_test(suite, "test_parse_capacity", test_parse_capacity);
CU_add_test(suite, "test_sprintf_append_realloc", test_sprintf_append_realloc);
CU_add_test(suite, "test_strtol", test_strtol);
CU_add_test(suite, "test_strtoll", test_strtoll);
CU_ADD_TEST(suite, test_parse_ip_addr);
CU_ADD_TEST(suite, test_str_chomp);
CU_ADD_TEST(suite, test_parse_capacity);
CU_ADD_TEST(suite, test_sprintf_append_realloc);
CU_ADD_TEST(suite, test_strtol);
CU_ADD_TEST(suite, test_strtoll);
CU_basic_set_mode(CU_BRM_VERBOSE);

10
test/unit/lib/vhost/vhost.c/vhost_ut.c
View File

@ -413,11 +413,11 @@ main(int argc, char **argv)
suite = CU_add_suite("vhost_suite", test_setup, NULL);
CU_add_test(suite, "desc_to_iov", desc_to_iov_test);
CU_add_test(suite, "create_controller", create_controller_test);
CU_add_test(suite, "session_find_by_vid", session_find_by_vid_test);
CU_add_test(suite, "remove_controller", remove_controller_test);
CU_add_test(suite, "vq_avail_ring_get", vq_avail_ring_get_test);
CU_ADD_TEST(suite, desc_to_iov_test);
CU_ADD_TEST(suite, create_controller_test);
CU_ADD_TEST(suite, session_find_by_vid_test);
CU_ADD_TEST(suite, remove_controller_test);
CU_ADD_TEST(suite, vq_avail_ring_get_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();