From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: Benjamin Marzinski Date: Fri, 7 Oct 2022 12:35:39 -0500 Subject: [PATCH] multipath tests: tests for adding and removing features Signed-off-by: Benjamin Marzinski Reviewed-by: Martin Wilck --- tests/Makefile | 2 +- tests/features.c | 318 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 319 insertions(+), 1 deletion(-) create mode 100644 tests/features.c diff --git a/tests/Makefile b/tests/Makefile index 77ff3249..914413b8 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -13,7 +13,7 @@ CFLAGS += $(BIN_CFLAGS) -I$(multipathdir) -I$(mpathcmddir) \ LIBDEPS += -L$(multipathdir) -lmultipath -lcmocka TESTS := uevent parser util dmevents hwtable blacklist unaligned vpd pgpolicy \ - alias directio + alias directio features .SILENT: $(TESTS:%=%.o) .PRECIOUS: $(TESTS:%=%-test) diff --git a/tests/features.c b/tests/features.c new file mode 100644 index 00000000..1e2e6bff --- /dev/null +++ b/tests/features.c @@ -0,0 +1,318 @@ +#include +#include +#include +#include + +#include "structs.h" +#include "globals.c" + +static void test_af_null_features_ptr(void **state) +{ + assert_int_equal(add_feature(NULL, "test"), 1); +} + +static void af_helper(const char *features_start, const char *addition, + const char *features_end, int result) +{ + char *f = NULL, *orig = NULL; + + if (features_start) { + f = strdup(features_start); + assert_non_null(f); + orig = f; + } + assert_int_equal(add_feature(&f, addition), result); + if (result != 0 || features_end == NULL) + assert_ptr_equal(orig, f); + else + assert_string_equal(f, features_end); + free(f); +} + +static void test_af_null_addition1(void **state) +{ + af_helper("0", NULL, NULL, 0); +} + +static void test_af_null_addition2(void **state) +{ + af_helper("1 queue_if_no_path", NULL, NULL, 0); +} + +static void test_af_empty_addition(void **state) +{ + af_helper("2 pg_init_retries 5", "", NULL, 0); +} + +static void test_af_invalid_addition1(void **state) +{ + af_helper("2 pg_init_retries 5", " ", NULL, 1); +} + +static void test_af_invalid_addition2(void **state) +{ + af_helper("2 pg_init_retries 5", "\tbad", NULL, 1); +} + +static void test_af_invalid_addition3(void **state) +{ + af_helper("2 pg_init_retries 5", "bad ", NULL, 1); +} + +static void test_af_invalid_addition4(void **state) +{ + af_helper("2 pg_init_retries 5", " bad ", NULL, 1); +} + +static void test_af_null_features1(void **state) +{ + af_helper(NULL, "test", "1 test", 0); +} + +static void test_af_null_features2(void **state) +{ + af_helper(NULL, "test\t more", "2 test\t more", 0); +} + +static void test_af_null_features3(void **state) +{ + af_helper(NULL, "test\neven\tmore", "3 test\neven\tmore", 0); +} + +static void test_af_already_exists1(void **state) +{ + af_helper("4 this is a test", "test", NULL, 0); +} + +static void test_af_already_exists2(void **state) +{ + af_helper("5 contest testy intestine test retest", "test", NULL, 0); +} + +static void test_af_almost_exists(void **state) +{ + af_helper("3 contest testy intestine", "test", + "4 contest testy intestine test", 0); +} + +static void test_af_bad_features1(void **state) +{ + af_helper("bad", "test", NULL, 1); +} + +static void test_af_bad_features2(void **state) +{ + af_helper("1bad", "test", NULL, 1); +} + +static void test_af_add1(void **state) +{ + af_helper("0", "test", "1 test", 0); +} + +static void test_af_add2(void **state) +{ + af_helper("0", "this is a test", "4 this is a test", 0); +} + +static void test_af_add3(void **state) +{ + af_helper("1 features", "more values", "3 features more values", 0); +} + +static void test_af_add4(void **state) +{ + af_helper("2 one\ttwo", "three\t four", "4 one\ttwo three\t four", 0); +} + +static int test_add_features(void) +{ + const struct CMUnitTest tests[] = { + cmocka_unit_test(test_af_null_features_ptr), + cmocka_unit_test(test_af_null_addition1), + cmocka_unit_test(test_af_null_addition2), + cmocka_unit_test(test_af_empty_addition), + cmocka_unit_test(test_af_invalid_addition1), + cmocka_unit_test(test_af_invalid_addition2), + cmocka_unit_test(test_af_invalid_addition3), + cmocka_unit_test(test_af_invalid_addition4), + cmocka_unit_test(test_af_null_features1), + cmocka_unit_test(test_af_null_features2), + cmocka_unit_test(test_af_null_features3), + cmocka_unit_test(test_af_already_exists1), + cmocka_unit_test(test_af_already_exists2), + cmocka_unit_test(test_af_almost_exists), + cmocka_unit_test(test_af_bad_features1), + cmocka_unit_test(test_af_bad_features2), + cmocka_unit_test(test_af_add1), + cmocka_unit_test(test_af_add2), + cmocka_unit_test(test_af_add3), + cmocka_unit_test(test_af_add4), + }; + return cmocka_run_group_tests(tests, NULL, NULL); +} + +static void test_rf_null_features_ptr(void **state) +{ + assert_int_equal(remove_feature(NULL, "test"), 1); +} + +static void test_rf_null_features(void **state) +{ + char *f = NULL; + assert_int_equal(remove_feature(&f, "test"), 1); +} + +static void rf_helper(const char *features_start, const char *removal, + const char *features_end, int result) +{ + char *f = strdup(features_start); + char *orig = f; + + assert_non_null(f); + assert_int_equal(remove_feature(&f, removal), result); + if (result != 0 || features_end == NULL) + assert_ptr_equal(orig, f); + else + assert_string_equal(f, features_end); + free(f); +} + +static void test_rf_null_removal(void **state) +{ + rf_helper("1 feature", NULL, NULL, 0); +} + +static void test_rf_empty_removal(void **state) +{ + rf_helper("1 feature", "", NULL, 0); +} + +static void test_rf_invalid_removal1(void **state) +{ + rf_helper("1 feature", " ", NULL, 1); +} + +static void test_rf_invalid_removal2(void **state) +{ + rf_helper("1 feature", " bad", NULL, 1); +} + +static void test_rf_invalid_removal3(void **state) +{ + rf_helper("1 feature", "bad\n", NULL, 1); +} + +static void test_rf_invalid_removal4(void **state) +{ + rf_helper("1 feature", "\tbad \n", NULL, 1); +} + +static void test_rf_bad_features1(void **state) +{ + rf_helper("invalid feature test string", "test", NULL, 1); +} + +static void test_rf_bad_features2(void **state) +{ + rf_helper("2no space test", "test", NULL, 1); +} + +static void test_rf_missing_removal1(void **state) +{ + rf_helper("0", "test", NULL, 0); +} + +static void test_rf_missing_removal2(void **state) +{ + rf_helper("1 detest", "test", NULL, 0); +} + +static void test_rf_missing_removal3(void **state) +{ + rf_helper("4 testing one two three", "test", NULL, 0); +} + +static void test_rf_missing_removal4(void **state) +{ + rf_helper("1 contestant", "test", NULL, 0); +} + +static void test_rf_missing_removal5(void **state) +{ + rf_helper("3 testament protest detestable", "test", NULL, 0); +} + +static void test_rf_remove_all_features1(void **state) +{ + rf_helper("1 test", "test", "0", 0); +} + +static void test_rf_remove_all_features2(void **state) +{ + rf_helper("2 another\t test", "another\t test", "0", 0); +} + +static void test_rf_remove1(void **state) +{ + rf_helper("2 feature1 feature2", "feature2", "1 feature1", 0); +} + +static void test_rf_remove2(void **state) +{ + rf_helper("2 feature1 feature2", "feature1", "1 feature2", 0); +} + +static void test_rf_remove3(void **state) +{ + rf_helper("3 test1 test\ttest2", "test", "2 test1 test2", 0); +} + +static void test_rf_remove4(void **state) +{ + rf_helper("4 this\t is a test", "is a", "2 this\t test", 0); +} + +static void test_rf_remove5(void **state) +{ + rf_helper("3 one more test", "more test", "1 one", 0); +} + +static int test_remove_features(void) +{ + const struct CMUnitTest tests[] = { + cmocka_unit_test(test_rf_null_features_ptr), + cmocka_unit_test(test_rf_null_features), + cmocka_unit_test(test_rf_null_removal), + cmocka_unit_test(test_rf_empty_removal), + cmocka_unit_test(test_rf_invalid_removal1), + cmocka_unit_test(test_rf_invalid_removal2), + cmocka_unit_test(test_rf_invalid_removal3), + cmocka_unit_test(test_rf_invalid_removal4), + cmocka_unit_test(test_rf_bad_features1), + cmocka_unit_test(test_rf_bad_features2), + cmocka_unit_test(test_rf_missing_removal1), + cmocka_unit_test(test_rf_missing_removal2), + cmocka_unit_test(test_rf_missing_removal3), + cmocka_unit_test(test_rf_missing_removal4), + cmocka_unit_test(test_rf_missing_removal5), + cmocka_unit_test(test_rf_remove_all_features1), + cmocka_unit_test(test_rf_remove_all_features2), + cmocka_unit_test(test_rf_remove1), + cmocka_unit_test(test_rf_remove2), + cmocka_unit_test(test_rf_remove3), + cmocka_unit_test(test_rf_remove4), + cmocka_unit_test(test_rf_remove5), + }; + return cmocka_run_group_tests(tests, NULL, NULL); +} + +int main(void) +{ + int ret = 0; + + ret += test_add_features(); + ret += test_remove_features(); + + return ret; +}