Commit 78b696bc authored by Vitaliy Mysak's avatar Vitaliy Mysak Committed by Tomasz Zawadzki
Browse files

ut: simplify error handling at initialization 

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: default avatarVitaliy Mysak <vitaliy.mysak@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/1238


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
Reviewed-by: default avatarTomasz Zawadzki <tomasz.zawadzki@intel.com>
parent 576602ac

test/unit/lib/bdev/bdev.c/bdev_ut.c

+28 −38
Original line number Diff line number Diff line
@@ -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, "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) == NULL ||

		CU_add_test(suite, "lock_lba_range_overlapped", lock_lba_range_overlapped) == NULL

	) {

		CU_cleanup_registry();

		return CU_get_error();

	}

		    lock_lba_range_with_io_outstanding);

	CU_add_test(suite, "lock_lba_range_overlapped", lock_lba_range_overlapped);



	allocate_threads(1);

	set_thread(0);

test/unit/lib/bdev/bdev_ocssd.c/bdev_ocssd_ut.c

+7 −17
Original line number Diff line number Diff line
@@ -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);

test/unit/lib/bdev/bdev_zone.c/bdev_zone_ut.c

+8 −18
Original line number Diff line number Diff line
@@ -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();

test/unit/lib/bdev/compress.c/compress_ut.c

+18 −28
Original line number Diff line number Diff line
@@ -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",

		    test_compress_operation);

	CU_add_test(suite, "test_compress_operation_cross_boundary",

			test_compress_operation_cross_boundary) == NULL ||

		    test_compress_operation_cross_boundary);

	CU_add_test(suite, "vbdev_compress_submit_request",

			test_vbdev_compress_submit_request) == NULL ||

		    test_vbdev_compress_submit_request);

	CU_add_test(suite, "test_passthru",

			test_passthru) == NULL ||

		    test_passthru);

	CU_add_test(suite, "test_initdrivers",

			test_initdrivers) == NULL ||

		    test_initdrivers);

	CU_add_test(suite, "test_supported_io",

			test_supported_io) == NULL ||

		    test_supported_io);

	CU_add_test(suite, "test_poller",

			test_poller) == NULL ||

		    test_poller);

	CU_add_test(suite, "test_reset",

			test_reset) == NULL

	   ) {

		CU_cleanup_registry();

		return CU_get_error();

	}

		    test_reset);



	CU_basic_set_mode(CU_BRM_VERBOSE);

	CU_basic_run_tests();

test/unit/lib/bdev/crypto.c/crypto_ut.c

+28 −38
Original line number Diff line number Diff line
@@ -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_error_paths",

		    test_error_paths);

	CU_add_test(suite, "test_simple_write",

			test_simple_write) == NULL ||

		    test_simple_write);

	CU_add_test(suite, "test_simple_read",

			test_simple_read) == NULL ||

		    test_simple_read);

	CU_add_test(suite, "test_large_rw",

			test_large_rw) == NULL ||

		    test_large_rw);

	CU_add_test(suite, "test_dev_full",

			test_dev_full) == NULL ||

		    test_dev_full);

	CU_add_test(suite, "test_crazy_rw",

			test_crazy_rw) == NULL ||

		    test_crazy_rw);

	CU_add_test(suite, "test_passthru",

			test_passthru) == NULL ||

		    test_passthru);

	CU_add_test(suite, "test_initdrivers",

			test_initdrivers) == NULL ||

		    test_initdrivers);

	CU_add_test(suite, "test_crypto_op_complete",

			test_crypto_op_complete) == NULL ||

		    test_crypto_op_complete);

	CU_add_test(suite, "test_supported_io",

			test_supported_io) == NULL ||

		    test_supported_io);

	CU_add_test(suite, "test_reset",

			test_reset) == NULL ||

		    test_reset);

	CU_add_test(suite, "test_poller",

			test_poller) == NULL ||

		    test_poller);

	CU_add_test(suite, "test_assign_device_qp",

			test_assign_device_qp) == NULL

	   ) {

		CU_cleanup_registry();

		return CU_get_error();

	}

		    test_assign_device_qp);



	CU_basic_set_mode(CU_BRM_VERBOSE);

	CU_basic_run_tests();