testsuite: Add basic tests for hash implementation

Far from complete, but already covers all internal APIs.

3 files changed, 242 insertions, 1 deletions

diff --git a/Makefile.am b/Makefile.am
index 305d48e..14ddcab 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -247,7 +247,8 @@ testsuite_libtestsuite_la_DEPENDENCIES = $(ROOTFS) \
 testsuite_libtestsuite_la_CPPFLAGS = $(TESTSUITE_CPPFLAGS)
 testsuite_libtestsuite_la_LIBADD = -lrt
 
-TESTSUITE = testsuite/test-init testsuite/test-testsuite testsuite/test-loaded \
+TESTSUITE = testsuite/test-hash \
+            testsuite/test-init testsuite/test-testsuite testsuite/test-loaded \
 	    testsuite/test-modinfo testsuite/test-util testsuite/test-new-module \
 	    testsuite/test-modprobe testsuite/test-blacklist \
 	    testsuite/test-dependencies testsuite/test-depmod
@@ -257,6 +258,10 @@ TESTS = $(TESTSUITE)
 
 testsuite_test_testsuite_LDADD = testsuite/libtestsuite.la libkmod/libkmod-util.la
 testsuite_test_testsuite_CPPFLAGS = $(TESTSUITE_CPPFLAGS)
+
+testsuite_test_hash_LDADD = $(TESTSUITE_LDADD)
+testsuite_test_hash_CPPFLAGS = $(TESTSUITE_CPPFLAGS)
+
 testsuite_test_init_LDADD = $(TESTSUITE_LDADD)
 testsuite_test_init_CPPFLAGS = $(TESTSUITE_CPPFLAGS)
 testsuite_test_loaded_LDADD = $(TESTSUITE_LDADD)
diff --git a/testsuite/.gitignore b/testsuite/.gitignore
index bd26a40..377c89c 100644
--- a/testsuite/.gitignore
+++ b/testsuite/.gitignore
@@ -12,6 +12,7 @@
 /test-new-module
 /test-testsuite
 /test-modprobe
+/test-hash
 /rootfs
 /stamp-rootfs
 /test-util.log
@@ -30,6 +31,8 @@
 /test-modinfo.trs
 /test-modprobe.log
 /test-modprobe.trs
+/test-hash.log
+/test-hash.trs
 /test-new-module.log
 /test-new-module.trs
 /test-testsuite.log
diff --git a/testsuite/test-hash.c b/testsuite/test-hash.c
new file mode 100644
index 0000000..110c4d1
--- /dev/null
+++ b/testsuite/test-hash.c
@@ -0,0 +1,233 @@
+/*
+ * Copyright (C)  2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include <libkmod-hash.h>
+#include "testsuite.h"
+
+static int freecount;
+
+static void countfreecalls(void *v)
+{
+	freecount++;
+}
+
+static int test_hash_new(const struct test *t)
+{
+	struct hash *h = hash_new(8, NULL);
+	assert_return(h != NULL, EXIT_FAILURE);
+	hash_free(h);
+	return 0;
+}
+static DEFINE_TEST(test_hash_new,
+		.description = "test hash_new");
+
+
+static int test_hash_get_count(const struct test *t)
+{
+	struct hash *h = hash_new(8, NULL);
+	const char *k1 = "k1", *k2 = "k2", *k3 = "k3";
+	const char *v1 = "v1", *v2 = "v2", *v3 = "v3";
+
+	hash_add(h, k1, v1);
+	hash_add(h, k2, v2);
+	hash_add(h, k3, v3);
+
+	assert_return(hash_get_count(h) == 3, EXIT_FAILURE);
+
+	hash_free(h);
+	return 0;
+}
+static DEFINE_TEST(test_hash_get_count,
+		.description = "test hash_add / hash_get_count");
+
+
+static int test_hash_replace(const struct test *t)
+{
+	struct hash *h = hash_new(8, countfreecalls);
+	const char *k1 = "k1", *k2 = "k2", *k3 = "k3";
+	const char *v1 = "v1", *v2 = "v2", *v3 = "v3", *v4 = "v4";
+	const char *v;
+	int r = 0;
+
+	r |= hash_add(h, k1, v1);
+	r |= hash_add(h, k2, v2);
+	r |= hash_add(h, k3, v3);
+
+	/* replace v1 */
+	r |= hash_add(h, k1, v4);
+
+	assert_return(r == 0, EXIT_FAILURE);
+	assert_return(hash_get_count(h) == 3, EXIT_FAILURE);
+
+	v = hash_find(h, "k1");
+	assert_return(strcmp(v, v4) == 0, EXIT_FAILURE);
+
+	assert_return(freecount == 1, EXIT_FAILURE);
+
+	hash_free(h);
+	return 0;
+}
+static DEFINE_TEST(test_hash_replace,
+		.description = "test hash_add replacing existing value");
+
+
+static int test_hash_replace_failing(const struct test *t)
+{
+	struct hash *h = hash_new(8, countfreecalls);
+	const char *k1 = "k1", *k2 = "k2", *k3 = "k3";
+	const char *v1 = "v1", *v2 = "v2", *v3 = "v3", *v4 = "v4";
+	const char *v;
+	int r = 0;
+
+	r |= hash_add(h, k1, v1);
+	r |= hash_add(h, k2, v2);
+	r |= hash_add(h, k3, v3);
+
+	assert_return(r == 0, EXIT_FAILURE);
+
+	/* replace v1 */
+	r = hash_add_unique(h, k1, v4);
+	assert_return(r != 0, EXIT_FAILURE);
+	assert_return(hash_get_count(h) == 3, EXIT_FAILURE);
+
+	v = hash_find(h, "k1");
+	assert_return(strcmp(v, v1) == 0, EXIT_FAILURE);
+
+	assert_return(freecount == 0, EXIT_FAILURE);
+
+	hash_free(h);
+	return 0;
+}
+static DEFINE_TEST(test_hash_replace_failing,
+		.description = "test hash_add_unique failing to replace existing value");
+
+
+static int test_hash_iter(const struct test *t)
+{
+	struct hash *h = hash_new(8, NULL);
+	struct hash *h2 = hash_new(8, NULL);
+	const char *k1 = "k1", *k2 = "k2", *k3 = "k3";
+	const char *v1 = "v1", *v2 = "v2", *v3 = "v3";
+	struct hash_iter iter;
+	const char *k, *v;
+
+	hash_add(h, k1, v1);
+	hash_add(h2, k1, v1);
+	hash_add(h, k2, v2);
+	hash_add(h2, k2, v2);
+	hash_add(h, k3, v3);
+	hash_add(h2, k3, v3);
+
+	for (hash_iter_init(h, &iter);
+	     hash_iter_next(&iter, &k, (const void **) &v);) {
+		v2 = hash_find(h2, k);
+		assert_return(v2 != NULL, EXIT_FAILURE);
+		hash_del(h2, k);
+	}
+
+	assert_return(hash_get_count(h) == 3, EXIT_FAILURE);
+	assert_return(hash_get_count(h2) == 0, EXIT_FAILURE);
+
+	hash_free(h);
+	hash_free(h2);
+	return 0;
+}
+static DEFINE_TEST(test_hash_iter,
+		.description = "test hash_iter");
+
+
+static int test_hash_iter_after_del(const struct test *t)
+{
+	struct hash *h = hash_new(8, NULL);
+	struct hash *h2 = hash_new(8, NULL);
+	const char *k1 = "k1", *k2 = "k2", *k3 = "k3";
+	const char *v1 = "v1", *v2 = "v2", *v3 = "v3";
+	struct hash_iter iter;
+	const char *k, *v;
+
+	hash_add(h, k1, v1);
+	hash_add(h2, k1, v1);
+	hash_add(h, k2, v2);
+	hash_add(h2, k2, v2);
+	hash_add(h, k3, v3);
+	hash_add(h2, k3, v3);
+
+	hash_del(h, k1);
+
+	for (hash_iter_init(h, &iter);
+	     hash_iter_next(&iter, &k, (const void **) &v);) {
+		v2 = hash_find(h2, k);
+		assert_return(v2 != NULL, EXIT_FAILURE);
+		hash_del(h2, k);
+	}
+
+	assert_return(hash_get_count(h) == 2, EXIT_FAILURE);
+	assert_return(hash_get_count(h2) == 1, EXIT_FAILURE);
+
+	hash_free(h);
+	hash_free(h2);
+	return 0;
+}
+static DEFINE_TEST(test_hash_iter_after_del,
+		.description = "test hash_iter, after deleting element");
+
+
+static int test_hash_free(const struct test *t)
+{
+	struct hash *h = hash_new(8, countfreecalls);
+	const char *k1 = "k1", *k2 = "k2", *k3 = "k3";
+	const char *v1 = "v1", *v2 = "v2", *v3 = "v3";
+
+	hash_add(h, k1, v1);
+	hash_add(h, k2, v2);
+	hash_add(h, k3, v3);
+
+	hash_del(h, k1);
+
+	assert_return(freecount == 1, EXIT_FAILURE);
+
+	assert_return(hash_get_count(h) == 2, EXIT_FAILURE);
+
+	hash_free(h);
+
+	assert_return(freecount == 3, EXIT_FAILURE);
+
+	return 0;
+}
+static DEFINE_TEST(test_hash_free,
+		.description = "test hash_free calling free function for all values");
+static const struct test *tests[] = {
+	&stest_hash_new,
+	&stest_hash_get_count,
+	&stest_hash_replace,
+	&stest_hash_replace_failing,
+	&stest_hash_iter,
+	&stest_hash_iter_after_del,
+	&stest_hash_free,
+	NULL,
+};
+
+
+TESTSUITE_MAIN(tests);