tree-wide: beautify remaining copyright statements

[elogind.git] / src / test / test-hashmap-plain.c

diff --git a/src/test/test-hashmap-plain.c b/src/test/test-hashmap-plain.c
index 84b508f874e754efd7d8f72b1cd41a8828e8d141..47e689749b536837553bdd370a8110fefbacab52 100644 (file)
--- a/src/test/test-hashmap-plain.c
+++ b/src/test/test-hashmap-plain.c
@@ -1,25 +1,17 @@
+/* SPDX-License-Identifier: LGPL-2.1+ */
 /***
-  This file is part of systemd
-
-  Copyright 2013 Daniel Buch
-
-  systemd 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.
-
-  systemd 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 systemd; If not, see <http://www.gnu.org/licenses/>.
+  Copyright © 2013 Daniel Buch
 ***/
 
+#include "alloc-util.h"
+#include "env-util.h"
+#include "hashmap.h"
+#include "log.h"
+#include "string-util.h"
 #include "strv.h"
 #include "util.h"
-#include "hashmap.h"
+
+static bool arg_slow = false;
 
 void test_hashmap_funcs(void);
 
@@ -27,6 +19,8 @@ static void test_hashmap_replace(void) {
         Hashmap *m;
         char *val1, *val2, *val3, *val4, *val5, *r;
 
+        log_info("%s", __func__);
+
         m = hashmap_new(&string_hash_ops);
 
         val1 = strdup("val1");
@@ -65,6 +59,8 @@ static void test_hashmap_copy(void) {
         Hashmap *m, *copy;
         char *val1, *val2, *val3, *val4, *r;
 
+        log_info("%s", __func__);
+
         val1 = strdup("val1");
         assert_se(val1);
         val2 = strdup("val2");
@@ -101,6 +97,8 @@ static void test_hashmap_get_strv(void) {
         char **strv;
         char *val1, *val2, *val3, *val4;
 
+        log_info("%s", __func__);
+
         val1 = strdup("val1");
         assert_se(val1);
         val2 = strdup("val2");
@@ -137,6 +135,8 @@ static void test_hashmap_move_one(void) {
         Hashmap *m, *n;
         char *val1, *val2, *val3, *val4, *r;
 
+        log_info("%s", __func__);
+
         val1 = strdup("val1");
         assert_se(val1);
         val2 = strdup("val2");
@@ -176,6 +176,8 @@ static void test_hashmap_move(void) {
         Hashmap *m, *n;
         char *val1, *val2, *val3, *val4, *r;
 
+        log_info("%s", __func__);
+
         val1 = strdup("val1");
         assert_se(val1);
         val2 = strdup("val2");
@@ -218,6 +220,8 @@ static void test_hashmap_update(void) {
         Hashmap *m;
         char *val1, *val2, *r;
 
+        log_info("%s", __func__);
+
         m = hashmap_new(&string_hash_ops);
         val1 = strdup("old_value");
         assert_se(val1);
@@ -248,6 +252,8 @@ static void test_hashmap_put(void) {
         void *val2 = (void*) "val 2";
         _cleanup_free_ char* key1 = NULL;
 
+        log_info("%s", __func__);
+
         assert_se(hashmap_ensure_allocated(&m, &string_hash_ops) >= 0);
         assert_se(m);
 
@@ -266,6 +272,8 @@ static void test_hashmap_remove(void) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
         char *r;
 
+        log_info("%s", __func__);
+
         r = hashmap_remove(NULL, "key 1");
         assert_se(r == NULL);
 
@@ -294,6 +302,8 @@ static void test_hashmap_remove2(void) {
         char val2[] = "val 2";
         void *r, *r2;
 
+        log_info("%s", __func__);
+
         r = hashmap_remove2(NULL, "key 1", &r2);
         assert_se(r == NULL);
 
@@ -321,26 +331,31 @@ static void test_hashmap_remove_value(void) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
         char *r;
 
-        r = hashmap_remove_value(NULL, "key 1", (void*) "val 1");
+        char val1[] = "val 1";
+        char val2[] = "val 2";
+
+        log_info("%s", __func__);
+
+        r = hashmap_remove_value(NULL, "key 1", val1);
         assert_se(r == NULL);
 
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
-        r = hashmap_remove_value(m, "key 1", (void*) "val 1");
+        r = hashmap_remove_value(m, "key 1", val1);
         assert_se(r == NULL);
 
-        hashmap_put(m, "key 1", (void*) "val 1");
-        hashmap_put(m, "key 2", (void*) "val 2");
+        hashmap_put(m, "key 1", val1);
+        hashmap_put(m, "key 2", val2);
 
-        r = hashmap_remove_value(m, "key 1", (void*) "val 1");
+        r = hashmap_remove_value(m, "key 1", val1);
         assert_se(streq(r, "val 1"));
 
         r = hashmap_get(m, "key 2");
         assert_se(streq(r, "val 2"));
         assert_se(!hashmap_get(m, "key 1"));
 
-        r = hashmap_remove_value(m, "key 2", (void*) "val 1");
+        r = hashmap_remove_value(m, "key 2", val1);
         assert_se(r == NULL);
 
         r = hashmap_get(m, "key 2");
@@ -353,6 +368,8 @@ static void test_hashmap_remove_and_put(void) {
         int valid;
         char *r;
 
+        log_info("%s", __func__);
+
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
@@ -387,6 +404,8 @@ static void test_hashmap_remove_and_replace(void) {
         void *r;
         int i, j;
 
+        log_info("%s", __func__);
+
         m = hashmap_new(&trivial_hash_ops);
         assert_se(m);
 
@@ -438,6 +457,8 @@ static void test_hashmap_ensure_allocated(void) {
         Hashmap *m;
         int valid_hashmap;
 
+        log_info("%s", __func__);
+
         m = hashmap_new(&string_hash_ops);
 
         valid_hashmap = hashmap_ensure_allocated(&m, &string_hash_ops);
@@ -459,12 +480,15 @@ static void test_hashmap_foreach_key(void) {
                 "key 3\0"
                 "key 4\0";
 
+        log_info("%s", __func__);
+
         m = hashmap_new(&string_hash_ops);
 
         NULSTR_FOREACH(key, key_table)
                 hashmap_put(m, key, (void*) (const char*) "my dummy val");
 
         HASHMAP_FOREACH_KEY(s, key, m, i) {
+                assert(s);
                 if (!key_found[0] && streq(key, "key 1"))
                         key_found[0] = true;
                 else if (!key_found[1] && streq(key, "key 2"))
@@ -488,6 +512,8 @@ static void test_hashmap_foreach(void) {
         char *val1, *val2, *val3, *val4, *s;
         unsigned count;
 
+        log_info("%s", __func__);
+
         val1 = strdup("my val1");
         assert_se(val1);
         val2 = strdup("my val2");
@@ -538,6 +564,8 @@ static void test_hashmap_merge(void) {
         Hashmap *n;
         char *val1, *val2, *val3, *val4, *r;
 
+        log_info("%s", __func__);
+
         val1 = strdup("my val1");
         assert_se(val1);
         val2 = strdup("my val2");
@@ -571,6 +599,8 @@ static void test_hashmap_contains(void) {
         Hashmap *m;
         char *val1;
 
+        log_info("%s", __func__);
+
         val1 = strdup("my val");
         assert_se(val1);
 
@@ -591,6 +621,8 @@ static void test_hashmap_isempty(void) {
         Hashmap *m;
         char *val1;
 
+        log_info("%s", __func__);
+
         val1 = strdup("my val");
         assert_se(val1);
 
@@ -608,6 +640,8 @@ static void test_hashmap_size(void) {
         Hashmap *m;
         char *val1, *val2, *val3, *val4;
 
+        log_info("%s", __func__);
+
         val1 = strdup("my val");
         assert_se(val1);
         val2 = strdup("my val");
@@ -638,6 +672,8 @@ static void test_hashmap_get(void) {
         char *r;
         char *val;
 
+        log_info("%s", __func__);
+
         val = strdup("my val");
         assert_se(val);
 
@@ -665,6 +701,8 @@ static void test_hashmap_get2(void) {
         char key_orig[] = "Key 1";
         void *key_copy;
 
+        log_info("%s", __func__);
+
         val = strdup("my val");
         assert_se(val);
 
@@ -682,7 +720,7 @@ static void test_hashmap_get2(void) {
         r = hashmap_get2(m, key_orig, &key_copy);
         assert_se(streq(r, val));
         assert_se(key_orig != key_copy);
-        assert_se(streq(key_orig, key_orig));
+        assert_se(streq(key_orig, key_copy));
 
         r = hashmap_get2(m, "no such key", NULL);
         assert_se(r == NULL);
@@ -691,8 +729,8 @@ static void test_hashmap_get2(void) {
         hashmap_free_free_free(m);
 }
 
-static unsigned long crippled_hashmap_func(const void *p, const uint8_t hash_key[HASH_KEY_SIZE]) {
-        return trivial_hash_func(p, hash_key) & 0xff;
+static void crippled_hashmap_func(const void *p, struct siphash *state) {
+        return trivial_hash_func(INT_TO_PTR(PTR_TO_INT(p) & 0xff), state);
 }
 
 static const struct hash_ops crippled_hashmap_ops = {
@@ -704,14 +742,15 @@ static void test_hashmap_many(void) {
         Hashmap *h;
         unsigned i, j;
         void *v, *k;
-        static const struct {
+        const struct {
                 const struct hash_ops *ops;
                 unsigned n_entries;
         } tests[] = {
-                { .ops = NULL,                  .n_entries = 1 << 20 },
-                { .ops = &crippled_hashmap_ops, .n_entries = 1 << 11 },
+                { .ops = NULL,                  .n_entries = arg_slow ? 1 << 20 : 240 },
+                { .ops = &crippled_hashmap_ops, .n_entries = arg_slow ? 1 << 14 : 140 },
         };
 
+        log_info("%s (%s)", __func__, arg_slow ? "slow" : "fast");
 
         for (j = 0; j < ELEMENTSOF(tests); j++) {
                 assert_se(h = hashmap_new(tests[j].ops));
@@ -742,6 +781,8 @@ static void test_hashmap_many(void) {
 static void test_hashmap_first(void) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
 
+        log_info("%s", __func__);
+
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
@@ -759,6 +800,8 @@ static void test_hashmap_first(void) {
 static void test_hashmap_first_key(void) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
 
+        log_info("%s", __func__);
+
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
@@ -776,6 +819,8 @@ static void test_hashmap_first_key(void) {
 static void test_hashmap_steal_first_key(void) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
 
+        log_info("%s", __func__);
+
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
@@ -791,6 +836,8 @@ static void test_hashmap_steal_first(void) {
         int seen[3] = {};
         char *val;
 
+        log_info("%s", __func__);
+
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
@@ -809,6 +856,8 @@ static void test_hashmap_steal_first(void) {
 static void test_hashmap_clear_free_free(void) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
 
+        log_info("%s", __func__);
+
         m = hashmap_new(&string_hash_ops);
         assert_se(m);
 
@@ -823,6 +872,8 @@ static void test_hashmap_clear_free_free(void) {
 static void test_hashmap_reserve(void) {
         _cleanup_hashmap_free_ Hashmap *m = NULL;
 
+        log_info("%s", __func__);
+
         m = hashmap_new(&string_hash_ops);
 
         assert_se(hashmap_reserve(m, 1) == 0);
@@ -838,6 +889,18 @@ static void test_hashmap_reserve(void) {
 }
 
 void test_hashmap_funcs(void) {
+#if 0 /// UNNEEDED by elogind
+        int r;
+#endif // 0
+
+        log_parse_environment();
+        log_open();
+
+#if 0 /// UNNEEDED by elogind
+        r = getenv_bool("SYSTEMD_SLOW_TESTS");
+        arg_slow = r >= 0 ? r : SYSTEMD_SLOW_TESTS_DEFAULT;
+#endif // 0
+
         test_hashmap_copy();
         test_hashmap_get_strv();
         test_hashmap_move_one();