device-mapper-multipath/0070-multipath-tests-tests-for-adding-and-removing-featur.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Benjamin Marzinski <bmarzins@redhat.com>
Date: Fri, 7 Oct 2022 12:35:39 -0500
Subject: [PATCH] multipath tests: tests for adding and removing features

Signed-off-by: Benjamin Marzinski <bmarzins@redhat.com>
Reviewed-by: Martin Wilck <mwilck@suse.com>
---
 tests/Makefile   |   2 +-
 tests/features.c | 319 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 320 insertions(+), 1 deletion(-)
 create mode 100644 tests/features.c

diff --git a/tests/Makefile b/tests/Makefile
index 8cbc4b73..972a5e04 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -13,7 +13,7 @@ CFLAGS += $(BIN_CFLAGS) -I$(multipathdir) -I$(mpathcmddir) \
 LIBDEPS += -L. -L$(mpathcmddir) -lmultipath -lmpathcmd -lcmocka
 
 TESTS := uevent parser util dmevents hwtable blacklist unaligned vpd pgpolicy \
-	 alias directio valid devt mpathvalid strbuf
+	 alias directio valid devt mpathvalid strbuf features
 HELPERS := test-lib.o test-log.o
 
 .SILENT: $(TESTS:%=%.o)
diff --git a/tests/features.c b/tests/features.c
new file mode 100644
index 00000000..4d8f0860
--- /dev/null
+++ b/tests/features.c
@@ -0,0 +1,319 @@
+#include <stddef.h>
+#include <stdarg.h>
+#include <setjmp.h>
+#include <cmocka.h>
+
+#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;
+
+	init_test_verbosity(-1);
+	ret += test_add_features();
+	ret += test_remove_features();
+
+	return ret;
+}