ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ut: simplify error handling at initialization

Browse Source 
This patch changes the way that unittests initialize.
The new way is shorter and simpler.
It assumes that error during initialization is a fatal error,
but in our cases it always is.

This patch is a followp up to
https://review.spdk.io/gerrit/c/spdk/spdk/+/930

lvol_ut.c is the only test that skipped because
it runs same tests multiple times which is not allowed
by new method.

Change-Id: I0baf7ad09a35d5fca2dc4a03b4453c12c14f38a7
Signed-off-by: Vitaliy Mysak <vitaliy.mysak@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/1238
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 18:59:24 +01:00 committed by Tomasz Zawadzki
parent 576602acc4
commit 78b696bca5
83 changed files with 1133 additions and 1985 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -3123,47 +3123,37 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("bdev", null_init, null_clean);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "bytes_to_blocks_test", bytes_to_blocks_test) == NULL ||
CU_add_test(suite, "num_blocks_test", num_blocks_test) == NULL ||
CU_add_test(suite, "io_valid", io_valid_test) == NULL ||
CU_add_test(suite, "open_write", open_write_test) == NULL ||
CU_add_test(suite, "alias_add_del", alias_add_del_test) == NULL ||
CU_add_test(suite, "get_device_stat", get_device_stat_test) == NULL ||
CU_add_test(suite, "bdev_io_types", bdev_io_types_test) == NULL ||
CU_add_test(suite, "bdev_io_wait", bdev_io_wait_test) == NULL ||
CU_add_test(suite, "bdev_io_spans_boundary", bdev_io_spans_boundary_test) == NULL ||
CU_add_test(suite, "bdev_io_split", bdev_io_split_test) == NULL ||
CU_add_test(suite, "bdev_io_split_with_io_wait", bdev_io_split_with_io_wait) == NULL ||
CU_add_test(suite, "bdev_io_alignment_with_boundary", bdev_io_alignment_with_boundary) == NULL ||
CU_add_test(suite, "bdev_io_alignment", bdev_io_alignment) == NULL ||
CU_add_test(suite, "bdev_histograms", bdev_histograms) == NULL ||
CU_add_test(suite, "bdev_write_zeroes", bdev_write_zeroes) == NULL ||
CU_add_test(suite, "bdev_compare_and_write", bdev_compare_and_write) == NULL ||
CU_add_test(suite, "bdev_compare", bdev_compare) == NULL ||
CU_add_test(suite, "bdev_open_while_hotremove", bdev_open_while_hotremove) == NULL ||
CU_add_test(suite, "bdev_close_while_hotremove", bdev_close_while_hotremove) == NULL ||
CU_add_test(suite, "bdev_open_ext", bdev_open_ext) == NULL ||
CU_add_test(suite, "bdev_set_io_timeout", bdev_set_io_timeout) == NULL ||
CU_add_test(suite, "lba_range_overlap", lba_range_overlap) == NULL ||
CU_add_test(suite, "lock_lba_range_check_ranges", lock_lba_range_check_ranges) == NULL ||
CU_add_test(suite, "lock_lba_range_with_io_outstanding",
lock_lba_range_with_io_outstanding) == NULL ||
CU_add_test(suite, "lock_lba_range_overlapped", lock_lba_range_overlapped) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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);
allocate_threads(1);
set_thread(0);

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

@ -1162,26 +1162,16 @@ main(int argc, const char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("ocssd", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_create_controller", test_create_controller) == NULL ||
CU_add_test(suite, "test_device_geometry", test_device_geometry) == NULL ||
CU_add_test(suite, "test_lba_translation", test_lba_translation) == NULL ||
CU_add_test(suite, "test_parallel_unit_range", test_parallel_unit_range) == NULL ||
CU_add_test(suite, "test_get_zone_info", test_get_zone_info) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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);
g_thread = spdk_thread_create("test", NULL);
spdk_set_thread(g_thread);

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

@ -410,26 +410,16 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("zone", test_setup, test_cleanup);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "test_zone_get_operation", test_zone_get_operation) == NULL
|| CU_add_test(suite, "test_bdev_zone_get_info", test_bdev_zone_get_info) == NULL
|| CU_add_test(suite, "test_bdev_zone_management", test_bdev_zone_management) == NULL
|| CU_add_test(suite, "test_bdev_zone_append", test_bdev_zone_append) == NULL
|| CU_add_test(suite, "test_bdev_zone_append_with_md", test_bdev_zone_append_with_md) == NULL
|| CU_add_test(suite, "test_bdev_io_get_append_location", test_bdev_io_get_append_location) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1101,36 +1101,26 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("compress", test_setup, test_cleanup);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "test_compress_operation",
test_compress_operation) == NULL ||
CU_add_test(suite, "test_compress_operation_cross_boundary",
test_compress_operation_cross_boundary) == NULL ||
CU_add_test(suite, "vbdev_compress_submit_request",
test_vbdev_compress_submit_request) == NULL ||
CU_add_test(suite, "test_passthru",
test_passthru) == NULL ||
CU_add_test(suite, "test_initdrivers",
test_initdrivers) == NULL ||
CU_add_test(suite, "test_supported_io",
test_supported_io) == NULL ||
CU_add_test(suite, "test_poller",
test_poller) == NULL ||
CU_add_test(suite, "test_reset",
test_reset) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1058,46 +1058,36 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("crypto", test_setup, test_cleanup);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "test_error_paths",
test_error_paths) == NULL ||
CU_add_test(suite, "test_simple_write",
test_simple_write) == NULL ||
CU_add_test(suite, "test_simple_read",
test_simple_read) == NULL ||
CU_add_test(suite, "test_large_rw",
test_large_rw) == NULL ||
CU_add_test(suite, "test_dev_full",
test_dev_full) == NULL ||
CU_add_test(suite, "test_crazy_rw",
test_crazy_rw) == NULL ||
CU_add_test(suite, "test_passthru",
test_passthru) == NULL ||
CU_add_test(suite, "test_initdrivers",
test_initdrivers) == NULL ||
CU_add_test(suite, "test_crypto_op_complete",
test_crypto_op_complete) == NULL ||
CU_add_test(suite, "test_supported_io",
test_supported_io) == NULL ||
CU_add_test(suite, "test_reset",
test_reset) == NULL ||
CU_add_test(suite, "test_poller",
test_poller) == NULL ||
CU_add_test(suite, "test_assign_device_qp",
test_assign_device_qp) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -344,31 +344,21 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("gpt_parse", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "parse",
test_parse_mbr_and_primary) == NULL ||
CU_add_test(suite, "parse secondary",
test_parse_secondary) == NULL ||
CU_add_test(suite, "check mbr",
test_check_mbr) == NULL ||
CU_add_test(suite, "read header",
test_read_header) == NULL ||
CU_add_test(suite, "read partitions",
test_read_partitions) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1899,36 +1899,26 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("bdev", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "basic", basic) == NULL ||
CU_add_test(suite, "unregister_and_close", unregister_and_close) == NULL ||
CU_add_test(suite, "basic_qos", basic_qos) == NULL ||
CU_add_test(suite, "put_channel_during_reset", put_channel_during_reset) == NULL ||
CU_add_test(suite, "aborted_reset", aborted_reset) == NULL ||
CU_add_test(suite, "io_during_reset", io_during_reset) == NULL ||
CU_add_test(suite, "io_during_qos_queue", io_during_qos_queue) == NULL ||
CU_add_test(suite, "io_during_qos_reset", io_during_qos_reset) == NULL ||
CU_add_test(suite, "enomem", enomem) == NULL ||
CU_add_test(suite, "enomem_multi_bdev", enomem_multi_bdev) == NULL ||
CU_add_test(suite, "enomem_multi_io_target", enomem_multi_io_target) == NULL ||
CU_add_test(suite, "qos_dynamic_enable", qos_dynamic_enable) == NULL ||
CU_add_test(suite, "bdev_histograms_mt", bdev_histograms_mt) == NULL ||
CU_add_test(suite, "bdev_set_io_timeout_mt", bdev_set_io_timeout_mt) == NULL ||
CU_add_test(suite, "lock_lba_range_then_submit_io", lock_lba_range_then_submit_io) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -152,22 +152,12 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("bdev_part", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "part", part_test) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "part", part_test);
allocate_threads(1);
set_thread(0);

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

@ -751,27 +751,17 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("bdev_pmem", ut_pmem_blk_init, ut_pmem_blk_clean);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "ut_pmem_init", ut_pmem_init) == NULL ||
CU_add_test(suite, "ut_pmem_open_close", ut_pmem_open_close) == NULL ||
CU_add_test(suite, "ut_pmem_write_read", ut_pmem_write_read) == NULL ||
CU_add_test(suite, "ut_pmem_reset", ut_pmem_reset) == NULL ||
CU_add_test(suite, "ut_pmem_write_zero", ut_pmem_write_zero) == NULL ||
CU_add_test(suite, "ut_pmem_unmap", ut_pmem_unmap) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -2219,42 +2219,32 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("raid", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_create_raid", test_create_raid) == NULL ||
CU_add_test(suite, "test_delete_raid", test_delete_raid) == NULL ||
CU_add_test(suite, "test_create_raid_invalid_args",
test_create_raid_invalid_args) == NULL ||
CU_add_test(suite, "test_delete_raid_invalid_args",
test_delete_raid_invalid_args) == NULL ||
CU_add_test(suite, "test_io_channel", test_io_channel) == NULL ||
CU_add_test(suite, "test_reset_io", test_reset_io) == NULL ||
CU_add_test(suite, "test_write_io", test_write_io) == NULL ||
CU_add_test(suite, "test_read_io", test_read_io) == NULL ||
CU_add_test(suite, "test_unmap_io", test_unmap_io) == NULL ||
CU_add_test(suite, "test_io_failure", test_io_failure) == NULL ||
CU_add_test(suite, "test_multi_raid_no_io", test_multi_raid_no_io) == NULL ||
CU_add_test(suite, "test_multi_raid_with_io", test_multi_raid_with_io) == NULL ||
CU_add_test(suite, "test_io_type_supported", test_io_type_supported) == NULL ||
CU_add_test(suite, "test_create_raid_from_config", test_create_raid_from_config) == NULL ||
CU_add_test(suite, "test_create_raid_from_config_invalid_params",
test_create_raid_from_config_invalid_params) == NULL ||
CU_add_test(suite, "test_raid_json_dump_info", test_raid_json_dump_info) == NULL ||
CU_add_test(suite, "test_context_size", test_context_size) == NULL ||
CU_add_test(suite, "test_raid_level_conversions", test_raid_level_conversions) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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);
allocate_threads(1);
set_thread(0);

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

@ -200,20 +200,11 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("raid5", test_setup, test_cleanup);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "test_raid5_start", test_raid5_start) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "test_raid5_start", test_raid5_start);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -116,23 +116,13 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("scsi_nvme_suite", null_init, null_clean);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "scsi_nvme - translate nvme error to scsi error",
scsi_nvme_translate_test) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "scsi_nvme - translate nvme error to scsi error",
scsi_nvme_translate_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1397,38 +1397,28 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("lvol", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "ut_lvs_init", ut_lvs_init) == NULL ||
CU_add_test(suite, "ut_lvol_init", ut_lvol_init) == NULL ||
CU_add_test(suite, "ut_lvol_snapshot", ut_lvol_snapshot) == NULL ||
CU_add_test(suite, "ut_lvol_clone", ut_lvol_clone) == NULL ||
CU_add_test(suite, "ut_lvs_destroy", ut_lvs_destroy) == NULL ||
CU_add_test(suite, "ut_lvs_unload", ut_lvs_unload) == NULL ||
CU_add_test(suite, "ut_lvol_resize", ut_lvol_resize) == NULL ||
CU_add_test(suite, "ut_lvol_set_read_only", ut_lvol_set_read_only) == NULL ||
CU_add_test(suite, "lvol_hotremove", ut_lvol_hotremove) == NULL ||
CU_add_test(suite, "ut_vbdev_lvol_get_io_channel", ut_vbdev_lvol_get_io_channel) == NULL ||
CU_add_test(suite, "ut_vbdev_lvol_io_type_supported", ut_vbdev_lvol_io_type_supported) == NULL ||
CU_add_test(suite, "ut_lvol_read_write", ut_lvol_read_write) == NULL ||
CU_add_test(suite, "ut_vbdev_lvol_submit_request", ut_vbdev_lvol_submit_request) == NULL ||
CU_add_test(suite, "lvol_examine", ut_lvol_examine) == NULL ||
CU_add_test(suite, "ut_lvol_rename", ut_lvol_rename) == NULL ||
CU_add_test(suite, "ut_lvol_destroy", ut_lvol_destroy) == NULL ||
CU_add_test(suite, "ut_lvs_rename", ut_lvs_rename) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1465,32 +1465,22 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("zone_block", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_zone_block_create", test_zone_block_create) == NULL ||
CU_add_test(suite, "test_zone_block_create_invalid", test_zone_block_create_invalid) == NULL ||
CU_add_test(suite, "test_get_zone_info", test_get_zone_info) == NULL ||
CU_add_test(suite, "test_supported_io_types", test_supported_io_types) == NULL ||
CU_add_test(suite, "test_reset_zone", test_reset_zone) == NULL ||
CU_add_test(suite, "test_open_zone", test_open_zone) == NULL ||
CU_add_test(suite, "test_zone_write", test_zone_write) == NULL ||
CU_add_test(suite, "test_zone_read", test_zone_read) == NULL ||
CU_add_test(suite, "test_close_zone", test_close_zone) == NULL ||
CU_add_test(suite, "test_finish_zone", test_finish_zone) == NULL ||
CU_add_test(suite, "test_append_zone", test_append_zone) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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);
g_thread = spdk_thread_create("test", NULL);
spdk_set_thread(g_thread);

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

@ -672,31 +672,21 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("blobfs_async_ut", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "fs_init", fs_init) == NULL ||
CU_add_test(suite, "fs_open", fs_open) == NULL ||
CU_add_test(suite, "fs_create", fs_create) == NULL ||
CU_add_test(suite, "fs_truncate", fs_truncate) == NULL ||
CU_add_test(suite, "fs_rename", fs_rename) == NULL ||
CU_add_test(suite, "fs_rw_async", fs_rw_async) == NULL ||
CU_add_test(suite, "fs_writev_readv_async", fs_writev_readv_async) == NULL ||
CU_add_test(suite, "tree_find_buffer", tree_find_buffer_ut) == NULL ||
CU_add_test(suite, "channel_ops", channel_ops) == NULL ||
CU_add_test(suite, "channel_ops_sync", channel_ops_sync) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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);
allocate_threads(1);
set_thread(0);

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

@ -330,24 +330,14 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("blobfs_bdev_ut", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "spdk_blobfs_bdev_detect_test", spdk_blobfs_bdev_detect_test) == NULL ||
CU_add_test(suite, "spdk_blobfs_bdev_create_test", spdk_blobfs_bdev_create_test) == NULL ||
CU_add_test(suite, "spdk_blobfs_bdev_mount_test", spdk_blobfs_bdev_mount_test) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -629,30 +629,20 @@ int main(int argc, char **argv)
pthread_t spdk_tid;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("blobfs_sync_ut", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "cache read after write", cache_read_after_write) == NULL ||
CU_add_test(suite, "file length", file_length) == NULL ||
CU_add_test(suite, "append write to extend blob", append_write_to_extend_blob) == NULL ||
CU_add_test(suite, "partial buffer", partial_buffer) == NULL ||
CU_add_test(suite, "write_null_buffer", cache_write_null_buffer) == NULL ||
CU_add_test(suite, "create_sync", fs_create_sync) == NULL ||
CU_add_test(suite, "rename_sync", fs_rename_sync) == NULL ||
CU_add_test(suite, "append_no_cache", cache_append_no_cache) == NULL ||
CU_add_test(suite, "delete_file_without_close", fs_delete_file_without_close) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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);
spdk_thread_lib_init(NULL, 0);

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

@ -135,20 +135,11 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("tree", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "blobfs_tree_op_test", blobfs_tree_op_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "blobfs_tree_op_test", blobfs_tree_op_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -177,23 +177,13 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("app_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_spdk_app_parse_args",
test_spdk_app_parse_args) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "test_spdk_app_parse_args",
test_spdk_app_parse_args);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -305,27 +305,17 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("app_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_create_reactor", test_create_reactor) == NULL ||
CU_add_test(suite, "test_init_reactors", test_init_reactors) == NULL ||
CU_add_test(suite, "test_event_call", test_event_call) == NULL ||
CU_add_test(suite, "test_schedule_thread", test_schedule_thread) == NULL ||
CU_add_test(suite, "test_reschedule_thread", test_reschedule_thread) == NULL ||
CU_add_test(suite, "test_for_each_reactor", test_for_each_reactor) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -237,27 +237,17 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("subsystem_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "subsystem_sort_test_depends_on_single",
subsystem_sort_test_depends_on_single) == NULL
|| CU_add_test(suite, "subsystem_sort_test_depends_on_multiple",
subsystem_sort_test_depends_on_multiple) == NULL
|| CU_add_test(suite, "subsystem_sort_test_missing_dependency",
subsystem_sort_test_missing_dependency) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -285,33 +285,24 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("ftl_band_suite", NULL, NULL);
if (!suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_band_block_offset_from_addr_base",
test_band_block_offset_from_addr_base) == NULL
|| CU_add_test(suite, "test_band_block_offset_from_addr_offset",
test_band_block_offset_from_addr_offset) == NULL
|| CU_add_test(suite, "test_band_addr_from_block_offset",
test_band_addr_from_block_offset) == NULL
|| CU_add_test(suite, "test_band_set_addr",
test_band_set_addr) == NULL
|| CU_add_test(suite, "test_invalidate_addr",
test_invalidate_addr) == NULL
|| CU_add_test(suite, "test_next_xfer_addr",
test_next_xfer_addr) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1041,39 +1041,30 @@ main(int argc, char **argv)
CU_pSuite suite;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("ftl_io_suite", NULL, NULL);
if (!suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_completion",
test_completion) == NULL
|| CU_add_test(suite, "test_alloc_free",
test_alloc_free) == NULL
|| CU_add_test(suite, "test_child_requests",
test_child_requests) == NULL
|| CU_add_test(suite, "test_child_status",
test_child_status) == NULL
|| CU_add_test(suite, "test_multi_generation",
test_multi_generation) == NULL
|| CU_add_test(suite, "test_io_channel_create",
test_io_channel_create) == NULL
|| CU_add_test(suite, "test_acquire_entry",
test_acquire_entry) == NULL
|| CU_add_test(suite, "test_submit_batch",
test_submit_batch) == NULL
|| CU_add_test(suite, "test_entry_address",
test_entry_address) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -132,25 +132,16 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("ftl_meta_suite", NULL, NULL);
if (!suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_md_unpack",
test_md_unpack) == NULL
|| CU_add_test(suite, "test_md_unpack_fail",
test_md_unpack_fail) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "test_md_unpack",
test_md_unpack);
CU_add_test(suite, "test_md_unpack_fail",
test_md_unpack_fail);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -202,37 +202,25 @@ main(int argc, char **argv)
CU_pSuite suite32 = NULL, suite64 = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite32 = CU_add_suite("ftl_addr32_suite", setup_l2p_32bit, cleanup);
if (!suite32) {
CU_cleanup_registry();
return CU_get_error();
}
suite64 = CU_add_suite("ftl_addr64_suite", setup_l2p_64bit, cleanup);
if (!suite64) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite32, "test_addr_pack",
test_addr_pack32) == NULL
|| CU_add_test(suite32, "test_addr32_invalid",
test_addr_invalid) == NULL
|| CU_add_test(suite32, "test_addr32_cached",
test_addr_cached) == NULL
|| CU_add_test(suite64, "test_addr64_invalid",
test_addr_invalid) == NULL
|| CU_add_test(suite64, "test_addr64_cached",
test_addr_cached) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -484,33 +484,24 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("ftl_band_suite", NULL, NULL);
if (!suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_reloc_iter_full",
test_reloc_iter_full) == NULL
|| CU_add_test(suite, "test_reloc_empty_band",
test_reloc_empty_band) == NULL
|| CU_add_test(suite, "test_reloc_full_band",
test_reloc_full_band) == NULL
|| CU_add_test(suite, "test_reloc_scatter_band",
test_reloc_scatter_band) == NULL
|| CU_add_test(suite, "test_reloc_zone",
test_reloc_zone) == NULL
|| CU_add_test(suite, "test_reloc_single_block",
test_reloc_single_block) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -205,23 +205,14 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("ftl_wptr_suite", NULL, NULL);
if (!suite) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_wptr",
test_wptr) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "test_wptr",
test_wptr);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -129,21 +129,12 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("ioat", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "ioat_state_check", ioat_state_check) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "ioat_state_check", ioat_state_check);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -890,32 +890,22 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("conn_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "read task split in order", read_task_split_in_order_case) == NULL ||
CU_add_test(suite, "read task split reverse order",
read_task_split_reverse_order_case) == NULL ||
CU_add_test(suite, "propagate_scsi_error_status_for_split_read_tasks",
propagate_scsi_error_status_for_split_read_tasks) == NULL ||
CU_add_test(suite, "process_non_read_task_completion_test",
process_non_read_task_completion_test) == NULL ||
CU_add_test(suite, "free_tasks_on_connection", free_tasks_on_connection) == NULL ||
CU_add_test(suite, "free_tasks_with_queued_datain", free_tasks_with_queued_datain) == NULL ||
CU_add_test(suite, "abort_queued_datain_task_test", abort_queued_datain_task_test) == NULL ||
CU_add_test(suite, "abort_queued_datain_tasks_test", abort_queued_datain_tasks_test) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -640,59 +640,49 @@ main(int argc, char **argv)
exit(1);
}
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
config_file = argv[1];
suite = CU_add_suite("init_grp_suite", test_setup, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "create from config file cases",
create_from_config_file_cases) == NULL
|| CU_add_test(suite, "create initiator group success case",
create_initiator_group_success_case) == NULL
|| CU_add_test(suite, "find initiator group success case",
find_initiator_group_success_case) == NULL
|| CU_add_test(suite, "register initiator group twice case",
register_initiator_group_twice_case) == NULL
|| CU_add_test(suite, "add initiator name success case",
add_initiator_name_success_case) == NULL
|| CU_add_test(suite, "add initiator name fail case",
add_initiator_name_fail_case) == NULL
|| CU_add_test(suite, "delete all initiator names success case",
delete_all_initiator_names_success_case) == NULL
|| CU_add_test(suite, "add initiator netmask success case",
add_netmask_success_case) == NULL
|| CU_add_test(suite, "add initiator netmask fail case",
add_netmask_fail_case) == NULL
|| CU_add_test(suite, "delete all initiator netmasks success case",
delete_all_netmasks_success_case) == NULL
|| CU_add_test(suite, "overwrite all to any for name case",
initiator_name_overwrite_all_to_any_case) == NULL
|| CU_add_test(suite, "overwrite all to any for netmask case",
netmask_overwrite_all_to_any_case) == NULL
|| CU_add_test(suite, "add/delete initiator names case",
add_delete_initiator_names_case) == NULL
|| CU_add_test(suite, "add duplicated initiator names case",
add_duplicated_initiator_names_case) == NULL
|| CU_add_test(suite, "delete nonexisting initiator names case",
delete_nonexisting_initiator_names_case) == NULL
|| CU_add_test(suite, "add/delete netmasks case",
add_delete_netmasks_case) == NULL
|| CU_add_test(suite, "add duplicated netmasks case",
add_duplicated_netmasks_case) == NULL
|| CU_add_test(suite, "delete nonexisting netmasks case",
delete_nonexisting_netmasks_case) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1969,46 +1969,36 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("iscsi_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "login check target test", op_login_check_target_test) == NULL
|| CU_add_test(suite, "login_session_normal_test", op_login_session_normal_test) == NULL
|| CU_add_test(suite, "maxburstlength test", maxburstlength_test) == NULL
|| CU_add_test(suite, "underflow for read transfer test",
underflow_for_read_transfer_test) == NULL
|| CU_add_test(suite, "underflow for zero read transfer test",
underflow_for_zero_read_transfer_test) == NULL
|| CU_add_test(suite, "underflow for request sense test",
underflow_for_request_sense_test) == NULL
|| CU_add_test(suite, "underflow for check condition test",
underflow_for_check_condition_test) == NULL
|| CU_add_test(suite, "add transfer task test", add_transfer_task_test) == NULL
|| CU_add_test(suite, "get transfer task test", get_transfer_task_test) == NULL
|| CU_add_test(suite, "del transfer task test", del_transfer_task_test) == NULL
|| CU_add_test(suite, "clear all transfer tasks test",
clear_all_transfer_tasks_test) == NULL
|| CU_add_test(suite, "build_iovs_test", build_iovs_test) == NULL
|| CU_add_test(suite, "build_iovs_with_md_test", build_iovs_with_md_test) == NULL
|| CU_add_test(suite, "pdu_hdr_op_login_test", pdu_hdr_op_login_test) == NULL
|| CU_add_test(suite, "pdu_hdr_op_text_test", pdu_hdr_op_text_test) == NULL
|| CU_add_test(suite, "pdu_hdr_op_logout_test", pdu_hdr_op_logout_test) == NULL
|| CU_add_test(suite, "pdu_hdr_op_scsi_test", pdu_hdr_op_scsi_test) == NULL
|| CU_add_test(suite, "pdu_hdr_op_task_mgmt_test", pdu_hdr_op_task_mgmt_test) == NULL
|| CU_add_test(suite, "pdu_hdr_op_nopout_test", pdu_hdr_op_nopout_test) == NULL
|| CU_add_test(suite, "pdu_hdr_op_data_test", pdu_hdr_op_data_test) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -382,29 +382,19 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("iscsi_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "param negotiation test",
param_negotiation_test) == NULL ||
CU_add_test(suite, "list negotiation test",
list_negotiation_test) == NULL ||
CU_add_test(suite, "parse valid test",
parse_valid_test) == NULL ||
CU_add_test(suite, "parse invalid test",
parse_invalid_test) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -393,47 +393,37 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("portal_grp_suite", test_setup, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "portal create ipv4 normal case",
portal_create_ipv4_normal_case) == NULL
|| CU_add_test(suite, "portal create ipv6 normal case",
portal_create_ipv6_normal_case) == NULL
|| CU_add_test(suite, "portal create ipv4 wildcard case",
portal_create_ipv4_wildcard_case) == NULL
|| CU_add_test(suite, "portal create ipv6 wildcard case",
portal_create_ipv6_wildcard_case) == NULL
|| CU_add_test(suite, "portal create twice case",
portal_create_twice_case) == NULL
|| CU_add_test(suite, "parse portal ipv4 normal case",
parse_portal_ipv4_normal_case) == NULL
|| CU_add_test(suite, "parse portal ipv6 normal case",
parse_portal_ipv6_normal_case) == NULL
|| CU_add_test(suite, "parse portal ipv4 skip port case",
parse_portal_ipv4_skip_port_case) == NULL
|| CU_add_test(suite, "parse portal ipv6 skip port case",
parse_portal_ipv6_skip_port_case) == NULL
|| CU_add_test(suite, "portal group register/unregister case",
portal_grp_register_unregister_case) == NULL
|| CU_add_test(suite, "portal group register twice case",
portal_grp_register_twice_case) == NULL
|| CU_add_test(suite, "portal group add/delete case",
portal_grp_add_delete_case) == NULL
|| CU_add_test(suite, "portal group add/delete twice case",
portal_grp_add_delete_twice_case) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -802,40 +802,30 @@ main(int argc, char **argv)
exit(1);
}
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
config_file = argv[1];
suite = CU_add_suite("iscsi_target_node_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "add lun test cases", add_lun_test_cases) == NULL
|| CU_add_test(suite, "config file fail cases", config_file_fail_cases) == NULL
|| CU_add_test(suite, "allow any allowed case", allow_any_allowed) == NULL
|| CU_add_test(suite, "allow ipv6 allowed case", allow_ipv6_allowed) == NULL
|| CU_add_test(suite, "allow ipv6 denied case", allow_ipv6_denied) == NULL
|| CU_add_test(suite, "allow ipv6 invalid case", allow_ipv6_invalid) == NULL
|| CU_add_test(suite, "allow ipv4 allowed case", allow_ipv4_allowed) == NULL
|| CU_add_test(suite, "allow ipv4 denied case", allow_ipv4_denied) == NULL
|| CU_add_test(suite, "allow ipv4 invalid case", allow_ipv4_invalid) == NULL
|| CU_add_test(suite, "node access allowed case", node_access_allowed) == NULL
|| CU_add_test(suite, "node access denied case (empty netmask)",
node_access_denied_by_empty_netmask) == NULL
|| CU_add_test(suite, "node access multiple initiator groups cases",
node_access_multi_initiator_groups_cases) == NULL
|| CU_add_test(suite, "allow iscsi name case",
allow_iscsi_name_multi_maps_case) == NULL
|| CU_add_test(suite, "chap param test cases", chap_param_test_cases) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -903,31 +903,22 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("json", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "parse_literal", test_parse_literal) == NULL ||
CU_add_test(suite, "parse_string_simple", test_parse_string_simple) == NULL ||
CU_add_test(suite, "parse_string_control_chars", test_parse_string_control_chars) == NULL ||
CU_add_test(suite, "parse_string_utf8", test_parse_string_utf8) == NULL ||
CU_add_test(suite, "parse_string_escapes_twochar", test_parse_string_escapes_twochar) == NULL ||
CU_add_test(suite, "parse_string_escapes_unicode", test_parse_string_escapes_unicode) == NULL ||
CU_add_test(suite, "parse_number", test_parse_number) == NULL ||
CU_add_test(suite, "parse_array", test_parse_array) == NULL ||
CU_add_test(suite, "parse_object", test_parse_object) == NULL ||
CU_add_test(suite, "parse_nesting", test_parse_nesting) == NULL ||
CU_add_test(suite, "parse_comment", test_parse_comment) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);

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

@ -923,34 +923,25 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("json", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "strequal", test_strequal) == NULL ||
CU_add_test(suite, "num_to_uint16", test_num_to_uint16) == NULL ||
CU_add_test(suite, "num_to_int32", test_num_to_int32) == NULL ||
CU_add_test(suite, "num_to_uint64", test_num_to_uint64) == NULL ||
CU_add_test(suite, "decode_object", test_decode_object) == NULL ||
CU_add_test(suite, "decode_array", test_decode_array) == NULL ||
CU_add_test(suite, "decode_bool", test_decode_bool) == NULL ||
CU_add_test(suite, "decode_uint16", test_decode_uint16) == NULL ||
CU_add_test(suite, "decode_int32", test_decode_int32) == NULL ||
CU_add_test(suite, "decode_uint32", test_decode_uint32) == NULL ||
CU_add_test(suite, "decode_uint64", test_decode_uint64) == NULL ||
CU_add_test(suite, "decode_string", test_decode_string) == NULL ||
CU_add_test(suite, "find_object", test_find) == NULL ||
CU_add_test(suite, "iterating", test_iterating) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);

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

@ -707,32 +707,23 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("json", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "write_literal", test_write_literal) == NULL ||
CU_add_test(suite, "write_string_simple", test_write_string_simple) == NULL ||
CU_add_test(suite, "write_string_escapes", test_write_string_escapes) == NULL ||
CU_add_test(suite, "write_string_utf16le", test_write_string_utf16le) == NULL ||
CU_add_test(suite, "write_number_int32", test_write_number_int32) == NULL ||
CU_add_test(suite, "write_number_uint32", test_write_number_uint32) == NULL ||
CU_add_test(suite, "write_number_int64", test_write_number_int64) == NULL ||
CU_add_test(suite, "write_number_uint64", test_write_number_uint64) == NULL ||
CU_add_test(suite, "write_array", test_write_array) == NULL ||
CU_add_test(suite, "write_object", test_write_object) == NULL ||
CU_add_test(suite, "write_nesting", test_write_nesting) == NULL ||
CU_add_test(suite, "write_val", test_write_val) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);

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

@ -389,22 +389,13 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("jsonrpc", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "parse_request", test_parse_request) == NULL ||
CU_add_test(suite, "parse_request_streaming", test_parse_request_streaming) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "parse_request", test_parse_request);
CU_add_test(suite, "parse_request_streaming", test_parse_request_streaming);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -89,21 +89,12 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("log", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "log_ut", log_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "log_ut", log_test);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -96,20 +96,11 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("app_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "notify", notify) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "notify", notify);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1314,65 +1314,55 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_opc_data_transfer",
test_opc_data_transfer) == NULL ||
CU_add_test(suite, "test_spdk_nvme_transport_id_parse_trtype",
test_spdk_nvme_transport_id_parse_trtype) == NULL ||
CU_add_test(suite, "test_spdk_nvme_transport_id_parse_adrfam",
test_spdk_nvme_transport_id_parse_adrfam) == NULL ||
CU_add_test(suite, "test_trid_parse_and_compare",
test_trid_parse_and_compare) == NULL ||
CU_add_test(suite, "test_trid_trtype_str",
test_trid_trtype_str) == NULL ||
CU_add_test(suite, "test_trid_adrfam_str",
test_trid_adrfam_str) == NULL ||
CU_add_test(suite, "test_nvme_ctrlr_probe",
test_nvme_ctrlr_probe) == NULL ||
CU_add_test(suite, "test_spdk_nvme_probe",
test_spdk_nvme_probe) == NULL ||
CU_add_test(suite, "test_spdk_nvme_connect",
test_spdk_nvme_connect) == NULL ||
CU_add_test(suite, "test_nvme_pci_probe_internal",
test_nvme_ctrlr_probe_internal) == NULL ||
CU_add_test(suite, "test_nvme_init_controllers",
test_nvme_init_controllers) == NULL ||
CU_add_test(suite, "test_nvme_driver_init",
test_nvme_driver_init) == NULL ||
CU_add_test(suite, "test_spdk_nvme_detach",
test_spdk_nvme_detach) == NULL ||
CU_add_test(suite, "test_nvme_completion_poll_cb",
test_nvme_completion_poll_cb) == NULL ||
CU_add_test(suite, "test_nvme_user_copy_cmd_complete",
test_nvme_user_copy_cmd_complete) == NULL ||
CU_add_test(suite, "test_nvme_allocate_request_null",
test_nvme_allocate_request_null) == NULL ||
CU_add_test(suite, "test_nvme_allocate_request",
test_nvme_allocate_request) == NULL ||
CU_add_test(suite, "test_nvme_free_request",
test_nvme_free_request) == NULL ||
CU_add_test(suite, "test_nvme_allocate_request_user_copy",
test_nvme_allocate_request_user_copy) == NULL ||
CU_add_test(suite, "test_nvme_robust_mutex_init_shared",
test_nvme_robust_mutex_init_shared) == NULL ||
CU_add_test(suite, "test_nvme_request_check_timeout",
test_nvme_request_check_timeout) == NULL ||
CU_add_test(suite, "test_nvme_wait_for_completion",
test_nvme_wait_for_completion) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -2077,66 +2077,56 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme_ctrlr", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test nvme_ctrlr init CC.EN = 1 CSTS.RDY = 0",
test_nvme_ctrlr_init_en_1_rdy_0) == NULL
|| CU_add_test(suite, "test nvme_ctrlr init CC.EN = 1 CSTS.RDY = 1",
test_nvme_ctrlr_init_en_1_rdy_1) == NULL
|| CU_add_test(suite, "test nvme_ctrlr init CC.EN = 0 CSTS.RDY = 0",
test_nvme_ctrlr_init_en_0_rdy_0) == NULL
|| CU_add_test(suite, "test nvme_ctrlr init CC.EN = 0 CSTS.RDY = 1",
test_nvme_ctrlr_init_en_0_rdy_1) == NULL
|| 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) == NULL
|| 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) == NULL
|| 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) == NULL
|| CU_add_test(suite, "test_nvme_ctrlr_init_delay",
test_nvme_ctrlr_init_delay) == NULL
|| CU_add_test(suite, "alloc_io_qpair_rr 1", test_alloc_io_qpair_rr_1) == NULL
|| CU_add_test(suite, "get_default_ctrlr_opts", test_ctrlr_get_default_ctrlr_opts) == NULL
|| CU_add_test(suite, "get_default_io_qpair_opts", test_ctrlr_get_default_io_qpair_opts) == NULL
|| CU_add_test(suite, "alloc_io_qpair_wrr 1", test_alloc_io_qpair_wrr_1) == NULL
|| CU_add_test(suite, "alloc_io_qpair_wrr 2", test_alloc_io_qpair_wrr_2) == NULL
|| CU_add_test(suite, "test nvme ctrlr function update_firmware",
test_spdk_nvme_ctrlr_update_firmware) == NULL
|| CU_add_test(suite, "test nvme_ctrlr function nvme_ctrlr_fail", test_nvme_ctrlr_fail) == NULL
|| 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) == NULL
|| CU_add_test(suite, "test nvme ctrlr function nvme_ctrlr_set_supported_features",
test_nvme_ctrlr_set_supported_features) == NULL
|| CU_add_test(suite, "test nvme ctrlr function nvme_ctrlr_set_doorbell_buffer_config",
test_spdk_nvme_ctrlr_doorbell_buffer_config) == 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);
#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) == NULL
CU_add_test(suite, "test nvme ctrlr function nvme_ctrlr_alloc_cmb",
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) == NULL
|| CU_add_test(suite, "test nvme ctrlr function test_nvme_ctrlr_test_active_ns_error_case",
test_nvme_ctrlr_test_active_ns_error_case) == NULL
|| CU_add_test(suite, "test_spdk_nvme_ctrlr_reconnect_io_qpair",
test_spdk_nvme_ctrlr_reconnect_io_qpair) == NULL
|| CU_add_test(suite, "test_spdk_nvme_ctrlr_set_trid", test_spdk_nvme_ctrlr_set_trid) == NULL
|| CU_add_test(suite, "test_nvme_ctrlr_init_set_nvmf_ioccsz",
test_nvme_ctrlr_init_set_nvmf_ioccsz) == NULL
|| CU_add_test(suite, "test nvme ctrlr init set num queues",
test_nvme_ctrlr_init_set_num_queues) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -718,41 +718,31 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme_ctrlr_cmd", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test ctrlr cmd get_log_pages", test_get_log_pages) == NULL
|| CU_add_test(suite, "test ctrlr cmd set_feature", test_set_feature_cmd) == NULL
|| CU_add_test(suite, "test ctrlr cmd set_feature_ns", test_set_feature_ns_cmd) == NULL
|| CU_add_test(suite, "test ctrlr cmd get_feature", test_get_feature_cmd) == NULL
|| CU_add_test(suite, "test ctrlr cmd get_feature_ns", test_get_feature_ns_cmd) == NULL
|| CU_add_test(suite, "test ctrlr cmd abort_cmd", test_abort_cmd) == NULL
|| CU_add_test(suite, "test ctrlr cmd set_host_id", test_set_host_id_cmds) == NULL
|| CU_add_test(suite, "test ctrlr cmd io_raw_no_payload_build",
test_io_cmd_raw_no_payload_build) == NULL
|| CU_add_test(suite, "test ctrlr cmd io_raw_cmd", test_io_raw_cmd) == NULL
|| CU_add_test(suite, "test ctrlr cmd io_raw_cmd_with_md", test_io_raw_cmd_with_md) == NULL
|| CU_add_test(suite, "test ctrlr cmd namespace_attach", test_namespace_attach) == NULL
|| CU_add_test(suite, "test ctrlr cmd namespace_detach", test_namespace_detach) == NULL
|| CU_add_test(suite, "test ctrlr cmd namespace_create", test_namespace_create) == NULL
|| CU_add_test(suite, "test ctrlr cmd namespace_delete", test_namespace_delete) == NULL
|| CU_add_test(suite, "test ctrlr cmd doorbell_buffer_config", test_doorbell_buffer_config) == NULL
|| CU_add_test(suite, "test ctrlr cmd format_nvme", test_format_nvme) == NULL
|| CU_add_test(suite, "test ctrlr cmd fw_commit", test_fw_commit) == NULL
|| CU_add_test(suite, "test ctrlr cmd fw_image_download", test_fw_image_download) == NULL
|| CU_add_test(suite, "test ctrlr cmd sanitize", test_sanitize) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -91,22 +91,12 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme_ctrlr_cmd", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test ocssd ctrlr geometry cmd ", test_geometry_cmd) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "test ocssd ctrlr geometry cmd ", test_geometry_cmd);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -137,23 +137,13 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_nvme_ns", test_nvme_ns_construct) == NULL ||
CU_add_test(suite, "test_nvme_ns_uuid", test_nvme_ns_uuid) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "test_nvme_ns", test_nvme_ns_construct);
CU_add_test(suite, "test_nvme_ns_uuid", test_nvme_ns_uuid);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1701,48 +1701,38 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme_ns_cmd", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "split_test", split_test) == NULL
|| CU_add_test(suite, "split_test2", split_test2) == NULL
|| CU_add_test(suite, "split_test3", split_test3) == NULL
|| CU_add_test(suite, "split_test4", split_test4) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_flush", test_nvme_ns_cmd_flush) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_dataset_management",
test_nvme_ns_cmd_dataset_management) == NULL
|| CU_add_test(suite, "io_flags", test_io_flags) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_write_zeroes", test_nvme_ns_cmd_write_zeroes) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_write_uncorrectable",
test_nvme_ns_cmd_write_uncorrectable) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_reservation_register",
test_nvme_ns_cmd_reservation_register) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_reservation_release",
test_nvme_ns_cmd_reservation_release) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_reservation_acquire",
test_nvme_ns_cmd_reservation_acquire) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_reservation_report", test_nvme_ns_cmd_reservation_report) == NULL
|| CU_add_test(suite, "test_cmd_child_request", test_cmd_child_request) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_readv", test_nvme_ns_cmd_readv) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_read_with_md", test_nvme_ns_cmd_read_with_md) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_writev", test_nvme_ns_cmd_writev) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_write_with_md", test_nvme_ns_cmd_write_with_md) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_comparev", test_nvme_ns_cmd_comparev) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_compare_and_write", test_nvme_ns_cmd_compare_and_write) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_compare_with_md", test_nvme_ns_cmd_compare_with_md) == NULL
|| CU_add_test(suite, "nvme_ns_cmd_comparev_with_md", test_nvme_ns_cmd_comparev_with_md) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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);
g_spdk_nvme_driver = &_g_nvme_driver;

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

@ -622,41 +622,31 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme_ns_cmd", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "nvme_ns_ocssd_cmd_vector_reset", test_nvme_ocssd_ns_cmd_vector_reset) == NULL
|| CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_reset_single_entry",
test_nvme_ocssd_ns_cmd_vector_reset_single_entry) == NULL
|| CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_read_with_md",
test_nvme_ocssd_ns_cmd_vector_read_with_md) == NULL
|| 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) == NULL
|| CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_read", test_nvme_ocssd_ns_cmd_vector_read) == NULL
|| CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_read_single_entry",
test_nvme_ocssd_ns_cmd_vector_read_single_entry) == NULL
|| CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_write_with_md",
test_nvme_ocssd_ns_cmd_vector_write_with_md) == NULL
|| 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) == NULL
|| CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_write", test_nvme_ocssd_ns_cmd_vector_write) == NULL
|| CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_write_single_entry",
test_nvme_ocssd_ns_cmd_vector_write_single_entry) == NULL
|| CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_copy", test_nvme_ocssd_ns_cmd_vector_copy) == NULL
|| CU_add_test(suite, "nvme_ocssd_ns_cmd_vector_copy_single_entry",
test_nvme_ocssd_ns_cmd_vector_copy_single_entry) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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);
g_spdk_nvme_driver = &_g_nvme_driver;

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

@ -480,23 +480,14 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme_pcie", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "prp_list_append", test_prp_list_append) == NULL ||
CU_add_test(suite, "nvme_pcie_hotplug_monitor", test_nvme_pcie_hotplug_monitor) == NULL ||
CU_add_test(suite, "shadow_doorbell_update", test_shadow_doorbell_update) == NULL ||
CU_add_test(suite, "build_contig_hw_sgl_request", test_build_contig_hw_sgl_request) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -597,35 +597,26 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme_qpair", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "test3", test3) == NULL
|| CU_add_test(suite, "ctrlr_failed", test_ctrlr_failed) == NULL
|| CU_add_test(suite, "struct_packing", struct_packing) == NULL
|| CU_add_test(suite, "spdk_nvme_qpair_process_completions",
test_nvme_qpair_process_completions) == NULL
|| CU_add_test(suite, "nvme_completion_is_retry", test_nvme_completion_is_retry) == 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);
#ifdef DEBUG
|| CU_add_test(suite, "get_status_string", test_get_status_string) == NULL
CU_add_test(suite, "get_status_string", test_get_status_string);
#endif
|| CU_add_test(suite, "spdk_nvme_qpair_add_cmd_error_injection",
test_nvme_qpair_add_cmd_error_injection) == NULL
|| CU_add_test(suite, "spdk_nvme_qpair_submit_request",
test_nvme_qpair_submit_request) == NULL
|| CU_add_test(suite, "nvme_qpair_resubmit_request_with_transport_failed",
test_nvme_qpair_resubmit_request_with_transport_failed) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -76,23 +76,13 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme_quirks", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test nvme_quirks striping",
test_nvme_quirks_striping) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "test nvme_quirks striping",
test_nvme_quirks_striping);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -204,20 +204,11 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme_rdma", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "build_sgl_request", test_nvme_rdma_build_sgl_request) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "build_sgl_request", test_nvme_rdma_build_sgl_request);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -435,30 +435,20 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme_tcp", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "nvme_tcp_pdu_set_data_buf",
test_nvme_tcp_pdu_set_data_buf) == NULL ||
CU_add_test(suite, "nvme_tcp_build_iovs",
test_nvme_tcp_build_iovs) == NULL ||
CU_add_test(suite, "build_sgl_request",
test_nvme_tcp_build_sgl_request) == NULL ||
CU_add_test(suite, "nvme_tcp_pdu_set_data_buf_with_md",
test_nvme_tcp_pdu_set_data_buf_with_md) == NULL ||
CU_add_test(suite, "nvme_tcp_build_iovs_with_md",
test_nvme_tcp_build_iovs_with_md) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -150,23 +150,13 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvme_uevent", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_nvme_uevent_parse_event",
test_nvme_uevent_parse_event) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "test_nvme_uevent_parse_event",
test_nvme_uevent_parse_event);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1599,37 +1599,28 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvmf", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "get_log_page", test_get_log_page) == NULL ||
CU_add_test(suite, "process_fabrics_cmd", test_process_fabrics_cmd) == NULL ||
CU_add_test(suite, "connect", test_connect) == NULL ||
CU_add_test(suite, "get_ns_id_desc_list", test_get_ns_id_desc_list) == NULL ||
CU_add_test(suite, "identify_ns", test_identify_ns) == NULL ||
CU_add_test(suite, "reservation_write_exclusive", test_reservation_write_exclusive) == NULL ||
CU_add_test(suite, "reservation_exclusive_access", test_reservation_exclusive_access) == NULL ||
CU_add_test(suite, "reservation_write_exclusive_regs_only_and_all_regs",
test_reservation_write_exclusive_regs_only_and_all_regs) == NULL ||
CU_add_test(suite, "reservation_exclusive_access_regs_only_and_all_regs",
test_reservation_exclusive_access_regs_only_and_all_regs) == NULL ||
CU_add_test(suite, "reservation_notification_log_page",
test_reservation_notification_log_page) == NULL ||
CU_add_test(suite, "get_dif_ctx", test_get_dif_ctx) == NULL ||
CU_add_test(suite, "set_get_features", test_set_get_features) == NULL ||
CU_add_test(suite, "identify_ctrlr", test_identify_ctrlr) == NULL ||
CU_add_test(suite, "custom_admin_cmd", test_custom_admin_cmd) == NULL ||
CU_add_test(suite, "fused_compare_and_write", test_fused_compare_and_write) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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);
allocate_threads(1);
set_thread(0);

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

@ -396,27 +396,17 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvmf", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "get_rw_params", test_get_rw_params) == NULL ||
CU_add_test(suite, "lba_in_range", test_lba_in_range) == NULL ||
CU_add_test(suite, "get_dif_ctx", test_get_dif_ctx) == 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, "spdk_nvmf_bdev_ctrlr_compare_and_write_cmd",
test_spdk_nvmf_bdev_ctrlr_compare_and_write_cmd) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "spdk_nvmf_bdev_ctrlr_compare_and_write_cmd",
test_spdk_nvmf_bdev_ctrlr_compare_and_write_cmd);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -288,21 +288,12 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvmf", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "discovery_log", test_discovery_log) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "discovery_log", test_discovery_log);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -480,57 +480,28 @@ int main(int argc, char **argv)
unsigned int num_failures = 0;
CU_pSuite suite = NULL;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("NVMf-FC", nvmf_fc_tests_init, nvmf_fc_tests_fini);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "Create Target & FC Transport",
create_transport_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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);
if (CU_add_test(suite, "Create Poll Groups",
create_poll_groups_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "Online FC Port",
online_fc_port_test);
CU_add_test(suite, "PG poll", poll_group_poll_test);
if (CU_add_test(suite, "Create FC Port",
create_fc_port_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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);
if (CU_add_test(suite, "Online FC Port",
online_fc_port_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "PG poll", poll_group_poll_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "Remove HWQP's from PG's",
remove_hwqps_from_poll_groups_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "Destroy Transport & Target",
destroy_transport_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1026,87 +1026,43 @@ int main(int argc, char **argv)
}
}
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("FC-NVMe LS", ls_tests_init, ls_tests_fini);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (test == 0) {
if (CU_add_test(suite, "CASS/DISC", create_single_assoc_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "CASS/DISC", create_single_assoc_test);
if (CU_add_test(suite, "Max. Connections", create_max_conns_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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);
if (CU_add_test(suite, "CIOC to bad assoc_id", invalid_connection_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "DISC bad assoc_id", disconnect_bad_assoc_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "Create/delete max. assocs/conns", create_max_aq_conns_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "Xmt LS RSP ERR Cleanup", xmt_ls_rsp_failure_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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);
} else {
switch (test) {
case 1:
if (CU_add_test(suite, "CASS/DISC", create_single_assoc_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "CASS/DISC", create_single_assoc_test);
break;
case 2:
if (CU_add_test(suite, "Max. Connections", create_max_conns_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "Max. Connections", create_max_conns_test);
break;
case 3:
if (CU_add_test(suite, "CIOC to bad assoc_id", invalid_connection_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "CIOC to bad assoc_id", invalid_connection_test);
break;
case 4:
if (CU_add_test(suite, "Create/delete max. assocs/conns",
create_max_aq_conns_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "Create/delete max. assocs/conns",
create_max_aq_conns_test);
break;
case 5:
if (CU_add_test(suite, "Xmt LS RSP ERR Cleanup", xmt_ls_rsp_failure_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "Xmt LS RSP ERR Cleanup", xmt_ls_rsp_failure_test);
break;
case 6:
if (CU_add_test(suite, "DISC bad assoc_id", disconnect_bad_assoc_test) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "DISC bad assoc_id", disconnect_bad_assoc_test);
break;
default:

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

@ -1280,23 +1280,15 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvmf", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (!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_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1308,40 +1308,30 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvmf", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "create_subsystem", nvmf_test_create_subsystem) == NULL ||
CU_add_test(suite, "nvmf_subsystem_add_ns", test_spdk_nvmf_subsystem_add_ns) == NULL ||
CU_add_test(suite, "nvmf_subsystem_set_sn", test_spdk_nvmf_subsystem_set_sn) == NULL ||
CU_add_test(suite, "reservation_register", test_reservation_register) == NULL ||
CU_add_test(suite, "reservation_register_with_ptpl", test_reservation_register_with_ptpl) == NULL ||
CU_add_test(suite, "reservation_acquire_preempt_1", test_reservation_acquire_preempt_1) == NULL ||
CU_add_test(suite, "reservation_acquire_release_with_ptpl",
test_reservation_acquire_release_with_ptpl) == NULL ||
CU_add_test(suite, "reservation_release", test_reservation_release) == NULL ||
CU_add_test(suite, "reservation_unregister_notification",
test_reservation_unregister_notification) == NULL ||
CU_add_test(suite, "reservation_release_notification",
test_reservation_release_notification) == NULL ||
CU_add_test(suite, "reservation_release_notification_write_exclusive",
test_reservation_release_notification_write_exclusive) == NULL ||
CU_add_test(suite, "reservation_clear_notification", test_reservation_clear_notification) == NULL ||
CU_add_test(suite, "reservation_preempt_notification",
test_reservation_preempt_notification) == NULL ||
CU_add_test(suite, "spdk_nvmf_ns_event", test_spdk_nvmf_ns_event) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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);
allocate_threads(1);
set_thread(0);

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

@ -676,27 +676,17 @@ int main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("nvmf", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "nvmf_tcp_create", test_nvmf_tcp_create) == NULL ||
CU_add_test(suite, "nvmf_tcp_destroy", test_nvmf_tcp_destroy) == NULL ||
CU_add_test(suite, "nvmf_tcp_poll_group_create", test_nvmf_tcp_poll_group_create) == NULL ||
CU_add_test(suite, "nvmf_tcp_send_c2h_data", test_nvmf_tcp_send_c2h_data) == NULL ||
CU_add_test(suite, "nvmf_tcp_h2c_data_hdr_handle", test_nvmf_tcp_h2c_data_hdr_handle) == NULL ||
CU_add_test(suite, "nvmf_tcp_incapsule_test", test_nvmf_tcp_incapsule_data_handle) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1277,34 +1277,24 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("reduce", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "get_pm_file_size", get_pm_file_size) == NULL ||
CU_add_test(suite, "get_vol_size", get_vol_size) == NULL ||
CU_add_test(suite, "init_failure", init_failure) == NULL ||
CU_add_test(suite, "init_md", init_md) == NULL ||
CU_add_test(suite, "init_backing_dev", init_backing_dev) == NULL ||
CU_add_test(suite, "load", load) == NULL ||
CU_add_test(suite, "write_maps", write_maps) == NULL ||
CU_add_test(suite, "read_write", read_write) == NULL ||
CU_add_test(suite, "readv_writev", readv_writev) == NULL ||
CU_add_test(suite, "destroy", destroy) == NULL ||
CU_add_test(suite, "defer_bdev_io", defer_bdev_io) == NULL ||
CU_add_test(suite, "overlapped", overlapped) == NULL ||
CU_add_test(suite, "compress_algorithm", compress_algorithm) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -644,69 +644,59 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("dev_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "destruct - null dev",
dev_destruct_null_dev) == NULL
|| CU_add_test(suite, "destruct - zero luns", dev_destruct_zero_luns) == NULL
|| CU_add_test(suite, "destruct - null lun", dev_destruct_null_lun) == NULL
|| CU_add_test(suite, "destruct - success", dev_destruct_success) == NULL
|| CU_add_test(suite, "construct - queue depth gt max depth",
dev_construct_num_luns_zero) == NULL
|| CU_add_test(suite, "construct - no lun0",
dev_construct_no_lun_zero) == NULL
|| CU_add_test(suite, "construct - null lun",
dev_construct_null_lun) == NULL
|| CU_add_test(suite, "construct - name too long", dev_construct_name_too_long) == NULL
|| CU_add_test(suite, "construct - success", dev_construct_success) == NULL
|| CU_add_test(suite, "construct - success - LUN zero not first",
dev_construct_success_lun_zero_not_first) == NULL
|| CU_add_test(suite, "dev queue task mgmt - success",
dev_queue_mgmt_task_success) == NULL
|| CU_add_test(suite, "dev queue task - success",
dev_queue_task_success) == NULL
|| CU_add_test(suite, "dev stop - success", dev_stop_success) == NULL
|| CU_add_test(suite, "dev add port - max ports",
dev_add_port_max_ports) == NULL
|| CU_add_test(suite, "dev add port - construct port failure 1",
dev_add_port_construct_failure1) == NULL
|| CU_add_test(suite, "dev add port - construct port failure 2",
dev_add_port_construct_failure2) == NULL
|| CU_add_test(suite, "dev add port - success 1",
dev_add_port_success1) == NULL
|| CU_add_test(suite, "dev add port - success 2",
dev_add_port_success2) == NULL
|| CU_add_test(suite, "dev add port - success 3",
dev_add_port_success3) == NULL
|| CU_add_test(suite, "dev find port by id - num ports zero",
dev_find_port_by_id_num_ports_zero) == NULL
|| CU_add_test(suite, "dev find port by id - different port id failure",
dev_find_port_by_id_id_not_found_failure) == NULL
|| CU_add_test(suite, "dev find port by id - success",
dev_find_port_by_id_success) == NULL
|| CU_add_test(suite, "dev add lun - bdev not found",
dev_add_lun_bdev_not_found) == NULL
|| CU_add_test(suite, "dev add lun - no free lun id",
dev_add_lun_no_free_lun_id) == NULL
|| CU_add_test(suite, "dev add lun - success 1",
dev_add_lun_success1) == NULL
|| CU_add_test(suite, "dev add lun - success 2",
dev_add_lun_success2) == NULL
|| CU_add_test(suite, "dev check pending tasks",
dev_check_pending_tasks) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -738,50 +738,40 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("lun_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "task management abort task - not supported",
lun_task_mgmt_execute_abort_task_not_supported) == NULL
|| CU_add_test(suite, "task management abort task set - success",
lun_task_mgmt_execute_abort_task_all_not_supported) == NULL
|| CU_add_test(suite, "task management - lun reset success",
lun_task_mgmt_execute_lun_reset) == NULL
|| CU_add_test(suite, "task management - invalid option",
lun_task_mgmt_execute_invalid_case) == NULL
|| CU_add_test(suite, "append task - null lun SPDK_SPC_INQUIRY",
lun_append_task_null_lun_task_cdb_spc_inquiry) == NULL
|| CU_add_test(suite, "append task - allocated length less than 4096",
lun_append_task_null_lun_alloc_len_lt_4096) == NULL
|| CU_add_test(suite, "append task - unsupported lun",
lun_append_task_null_lun_not_supported) == NULL
|| CU_add_test(suite, "execute task - scsi task pending",
lun_execute_scsi_task_pending) == NULL
|| CU_add_test(suite, "execute task - scsi task complete",
lun_execute_scsi_task_complete) == NULL
|| CU_add_test(suite, "destruct task - success", lun_destruct_success) == NULL
|| CU_add_test(suite, "construct - null ctx", lun_construct_null_ctx) == NULL
|| CU_add_test(suite, "construct - success", lun_construct_success) == NULL
|| CU_add_test(suite, "reset task wait for prior task completion",
lun_reset_task_wait_scsi_task_complete) == NULL
|| CU_add_test(suite, "reset task suspend subsequent scsi task",
lun_reset_task_suspend_scsi_task) == NULL
|| CU_add_test(suite, "check pending tasks only for specific initiator",
lun_check_pending_tasks_only_for_specific_initiator) == NULL
|| CU_add_test(suite, "abort_pending_mgmt_tasks_when_lun_is_removed",
abort_pending_mgmt_tasks_when_lun_is_removed) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
allocate_threads(1);

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

@ -54,23 +54,12 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("scsi_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "scsi init", \
scsi_init) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "scsi init", scsi_init);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -1007,34 +1007,24 @@ main(int argc, char **argv)
TAILQ_INIT(&g_bdev_io_queue);
TAILQ_INIT(&g_io_wait_queue);
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("translation_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "mode select 6 test", mode_select_6_test) == NULL
|| CU_add_test(suite, "mode select 6 test2", mode_select_6_test2) == NULL
|| CU_add_test(suite, "mode sense 6 test", mode_sense_6_test) == NULL
|| CU_add_test(suite, "mode sense 10 test", mode_sense_10_test) == NULL
|| CU_add_test(suite, "inquiry evpd test", inquiry_evpd_test) == NULL
|| CU_add_test(suite, "inquiry standard test", inquiry_standard_test) == NULL
|| CU_add_test(suite, "inquiry overflow test", inquiry_overflow_test) == NULL
|| CU_add_test(suite, "task complete test", task_complete_test) == NULL
|| CU_add_test(suite, "LBA range test", lba_range_test) == NULL
|| CU_add_test(suite, "transfer length test", xfer_len_test) == NULL
|| CU_add_test(suite, "transfer test", xfer_test) == NULL
|| CU_add_test(suite, "scsi name padding test", scsi_name_padding_test) == NULL
|| CU_add_test(suite, "get dif context test", get_dif_ctx_test) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -541,24 +541,15 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("reservation_suite", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (CU_add_test(suite, "register", test_reservation_register) == NULL ||
CU_add_test(suite, "reserve", test_reservation_reserve) == NULL ||
CU_add_test(suite, "preempt", test_reservation_preempt_non_all_regs) == NULL ||
CU_add_test(suite, "preempt all regs", test_reservation_preempt_all_regs) == NULL ||
CU_add_test(suite, "conflict", test_reservation_cmds_conflict) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -156,21 +156,12 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("posix", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "flush", flush) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "flush", flush);
CU_basic_set_mode(CU_BRM_VERBOSE);

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

@ -822,26 +822,17 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("sock", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "posix_sock", posix_sock) == NULL ||
CU_add_test(suite, "ut_sock", ut_sock) == NULL ||
CU_add_test(suite, "posix_sock_group", posix_sock_group) == NULL ||
CU_add_test(suite, "ut_sock_group", ut_sock_group) == NULL ||
CU_add_test(suite, "posix_sock_group_fairness", posix_sock_group_fairness) == NULL ||
CU_add_test(suite, "posix_sock_close", posix_sock_close) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);

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

@ -252,23 +252,14 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("uring", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "flush_client", flush_client) == NULL ||
CU_add_test(suite, "flush_server", flush_server) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "flush_client", flush_client);
CU_add_test(suite, "flush_server", flush_server);
CU_basic_set_mode(CU_BRM_VERBOSE);

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

@ -1006,33 +1006,23 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("io_channel", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "thread_alloc", thread_alloc) == NULL ||
CU_add_test(suite, "thread_send_msg", thread_send_msg) == NULL ||
CU_add_test(suite, "thread_poller", thread_poller) == NULL ||
CU_add_test(suite, "poller_pause", poller_pause) == NULL ||
CU_add_test(suite, "thread_for_each", thread_for_each) == NULL ||
CU_add_test(suite, "for_each_channel_remove", for_each_channel_remove) == NULL ||
CU_add_test(suite, "for_each_channel_unreg", for_each_channel_unreg) == NULL ||
CU_add_test(suite, "thread_name", thread_name) == NULL ||
CU_add_test(suite, "channel", channel) == NULL ||
CU_add_test(suite, "channel_destroy_races", channel_destroy_races) == NULL ||
CU_add_test(suite, "thread_exit", thread_exit) == NULL ||
CU_add_test(suite, "thread_update_stats", thread_update_stats) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();

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

@ -358,27 +358,18 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("base64", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_base64_get_encoded_strlen", test_base64_get_encoded_strlen) == NULL ||
CU_add_test(suite, "test_base64_get_decoded_len",
test_base64_get_decoded_len) == NULL ||
CU_add_test(suite, "test_base64_encode", test_base64_encode) == NULL ||
CU_add_test(suite, "test_base64_decode", test_base64_decode) == NULL ||
CU_add_test(suite, "test_base64_urlsafe_encode", test_base64_urlsafe_encode) == NULL ||
CU_add_test(suite, "test_base64_urlsafe_decode", test_base64_urlsafe_decode) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);

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

@ -351,28 +351,19 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("bit_array", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_1bit", test_1bit) == NULL ||
CU_add_test(suite, "test_64bit", test_64bit) == NULL ||
CU_add_test(suite, "test_find", test_find) == NULL ||
CU_add_test(suite, "test_resize", test_resize) == NULL ||
CU_add_test(suite, "test_errors", test_errors) == NULL ||
CU_add_test(suite, "test_count", test_count) == NULL ||
CU_add_test(suite, "test_mask_store_load", test_mask_store_load) == NULL ||
CU_add_test(suite, "test_mask_clear", test_mask_clear) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);

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

@ -242,23 +242,14 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("cpuset", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_cpuset", test_cpuset) == NULL ||
CU_add_test(suite, "test_cpuset_parse", test_cpuset_parse) == NULL ||
CU_add_test(suite, "test_cpuset_fmt", test_cpuset_fmt) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);

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

@ -84,23 +84,14 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("crc16", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_crc16_t10dif", test_crc16_t10dif) == NULL ||
CU_add_test(suite, "test_crc16_t10dif_seed", test_crc16_t10dif_seed) == NULL ||
CU_add_test(suite, "test_crc16_t10dif_copy", test_crc16_t10dif_copy) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);

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

@ -56,21 +56,12 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("crc32_ieee", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_crc32_ieee", test_crc32_ieee) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "test_crc32_ieee", test_crc32_ieee);
CU_basic_set_mode(CU_BRM_VERBOSE);

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

@ -127,21 +127,12 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("crc32c", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_crc32c", test_crc32c) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "test_crc32c", test_crc32c);
CU_basic_set_mode(CU_BRM_VERBOSE);

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

@ -2600,114 +2600,104 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("dif", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "dif_generate_and_verify_test", dif_generate_and_verify_test) == NULL ||
CU_add_test(suite, "dif_disable_check_test", dif_disable_check_test) == NULL ||
CU_add_test(suite, "dif_sec_512_md_0_error_test", dif_sec_512_md_0_error_test) == NULL ||
CU_add_test(suite, "dif_guard_seed_test", dif_guard_seed_test) == NULL ||
CU_add_test(suite, "dif_disable_sec_512_md_8_single_iov_test",
dif_disable_sec_512_md_8_single_iov_test) == NULL ||
CU_add_test(suite, "dif_sec_512_md_8_prchk_0_single_iov_test",
dif_sec_512_md_8_prchk_0_single_iov_test) == NULL ||
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) == NULL ||
CU_add_test(suite, "dif_sec_4096_md_128_prchk_7_multi_iovs_test",
dif_sec_4096_md_128_prchk_7_multi_iovs_test) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
CU_add_test(suite, "dif_copy_sec_512_md_8_prchk_0_single_iov",
dif_copy_sec_512_md_8_prchk_0_single_iov) == NULL ||
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) == NULL ||
CU_add_test(suite, "dif_copy_sec_4096_md_128_prchk_7_multi_iovs",
dif_copy_sec_4096_md_128_prchk_7_multi_iovs) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
CU_add_test(suite, "dix_sec_512_md_0_error", dix_sec_512_md_0_error) == NULL ||
CU_add_test(suite, "dix_sec_512_md_8_prchk_0_single_iov",
dix_sec_512_md_8_prchk_0_single_iov) == NULL ||
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) == NULL ||
CU_add_test(suite, "dix_sec_4096_md_128_prchk_7_multi_iovs",
dix_sec_4096_md_128_prchk_7_multi_iovs) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
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) == NULL ||
CU_add_test(suite, "set_md_interleave_iovs_test", set_md_interleave_iovs_test) == NULL ||
CU_add_test(suite, "set_md_interleave_iovs_split_test",
set_md_interleave_iovs_split_test) == NULL ||
CU_add_test(suite, "dif_generate_stream_test", dif_generate_stream_test) == NULL ||
CU_add_test(suite, "set_md_interleave_iovs_alignment_test",
set_md_interleave_iovs_alignment_test) == NULL ||
CU_add_test(suite, "_dif_generate_split_test", _dif_generate_split_test) == NULL ||
CU_add_test(suite, "set_md_interleave_iovs_multi_segments_test",
set_md_interleave_iovs_multi_segments_test) == NULL ||
CU_add_test(suite, "_dif_verify_split_test", _dif_verify_split_test) == NULL ||
CU_add_test(suite, "dif_verify_stream_multi_segments_test",
dif_verify_stream_multi_segments_test) == NULL ||
CU_add_test(suite, "update_crc32c_test", update_crc32c_test) == NULL ||
CU_add_test(suite, "_dif_update_crc32c_split_test",
_dif_update_crc32c_split_test) == NULL ||
CU_add_test(suite, "dif_update_crc32c_stream_multi_segments_test",
dif_update_crc32c_stream_multi_segments_test) == NULL ||
CU_add_test(suite, "get_range_with_md_test", get_range_with_md_test) == NULL ||
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) == NULL ||
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) == NULL ||
CU_add_test(suite, "dix_sec_4096_md_128_prchk_7_multi_iovs_remap",
dix_sec_4096_md_128_prchk_7_multi_iovs_remap) == NULL ||
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) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);

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

@ -229,23 +229,14 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("iov", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_single_iov", test_single_iov) == NULL ||
CU_add_test(suite, "test_simple_iov", test_simple_iov) == NULL ||
CU_add_test(suite, "test_complex_iov", test_complex_iov) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);

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

@ -63,23 +63,13 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("math", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_serial_number_arithmetic",
test_serial_number_arithmetic) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
CU_add_test(suite, "test_serial_number_arithmetic",
test_serial_number_arithmetic);
CU_basic_set_mode(CU_BRM_VERBOSE);

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

@ -630,26 +630,17 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("pipe", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_create_destroy", test_create_destroy) == NULL ||
CU_add_test(suite, "test_write_get_buffer", test_write_get_buffer) == NULL ||
CU_add_test(suite, "test_write_advance", test_write_advance) == NULL ||
CU_add_test(suite, "test_read_get_buffer", test_read_get_buffer) == NULL ||
CU_add_test(suite, "test_read_advance", test_read_advance) == NULL ||
CU_add_test(suite, "test_data", test_data) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);

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

@ -384,26 +384,17 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("string", NULL, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "test_parse_ip_addr", test_parse_ip_addr) == NULL ||
CU_add_test(suite, "test_str_chomp", test_str_chomp) == NULL ||
CU_add_test(suite, "test_parse_capacity", test_parse_capacity) == NULL ||
CU_add_test(suite, "test_sprintf_append_realloc", test_sprintf_append_realloc) == NULL ||
CU_add_test(suite, "test_strtol", test_strtol) == NULL ||
CU_add_test(suite, "test_strtoll", test_strtoll) == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);

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

@ -408,26 +408,16 @@ main(int argc, char **argv)
CU_pSuite suite = NULL;
unsigned int num_failures;
if (CU_initialize_registry() != CUE_SUCCESS) {
return CU_get_error();
}
CU_set_error_action(CUEA_ABORT);
CU_initialize_registry();
suite = CU_add_suite("vhost_suite", test_setup, NULL);
if (suite == NULL) {
CU_cleanup_registry();
return CU_get_error();
}
if (
CU_add_test(suite, "desc_to_iov", desc_to_iov_test) == NULL ||
CU_add_test(suite, "create_controller", create_controller_test) == NULL ||
CU_add_test(suite, "session_find_by_vid", session_find_by_vid_test) == NULL ||
CU_add_test(suite, "remove_controller", remove_controller_test) == NULL ||
CU_add_test(suite, "vq_avail_ring_get", vq_avail_ring_get_test) == NULL
) {
CU_cleanup_registry();
return CU_get_error();
}
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_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();