testsuite: Add basic tests for hash implementation

Far from complete, but already covers all internal APIs.

diff --git a/Makefile.am b/Makefile.am
index 305d48e913360b04fb988532c368ddbc2a4dca51..14ddcabd4e5ac61650235567a3cf589f8b7f9b6a 100644 (file)
--- 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 bd26a4025eb393c28970dcf75257716e37b6050e..377c89c07957725bb9c88803366b7d02673284fb 100644 (file)
--- 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 (file)
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);