Merge pull request #11827 from keszybz/pkgconfig-variables

[thirdparty/systemd.git] / src / test / test-hashmap-plain.c

diff --git a/src/test/test-hashmap-plain.c b/src/test/test-hashmap-plain.c
index 1bd5c02f8789a9547d16727d7e7996728e6c7ad4..5376aa84c40a5c69353e9b78cf1bcd8e9dc02c8f 100644 (file)
--- a/src/test/test-hashmap-plain.c
+++ b/src/test/test-hashmap-plain.c
@@ -1,26 +1,12 @@
-/***
-  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/>.
-***/
+/* SPDX-License-Identifier: LGPL-2.1+ */
 
 #include "alloc-util.h"
 #include "hashmap.h"
+#include "log.h"
+#include "stdio-util.h"
 #include "string-util.h"
 #include "strv.h"
+#include "tests.h"
 #include "util.h"
 
 void test_hashmap_funcs(void);
@@ -29,6 +15,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");
@@ -67,6 +55,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");
@@ -103,6 +93,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");
@@ -139,6 +131,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");
@@ -178,6 +172,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");
@@ -220,6 +216,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);
@@ -250,6 +248,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);
 
@@ -268,6 +268,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);
 
@@ -296,6 +298,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);
 
@@ -326,6 +330,8 @@ static void test_hashmap_remove_value(void) {
         char val1[] = "val 1";
         char val2[] = "val 2";
 
+        log_info("/* %s */", __func__);
+
         r = hashmap_remove_value(NULL, "key 1", val1);
         assert_se(r == NULL);
 
@@ -358,6 +364,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);
 
@@ -392,6 +400,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);
 
@@ -443,6 +453,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);
@@ -464,6 +476,8 @@ 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)
@@ -494,6 +508,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");
@@ -544,6 +560,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");
@@ -577,6 +595,8 @@ static void test_hashmap_contains(void) {
         Hashmap *m;
         char *val1;
 
+        log_info("/* %s */", __func__);
+
         val1 = strdup("my val");
         assert_se(val1);
 
@@ -597,6 +617,8 @@ static void test_hashmap_isempty(void) {
         Hashmap *m;
         char *val1;
 
+        log_info("/* %s */", __func__);
+
         val1 = strdup("my val");
         assert_se(val1);
 
@@ -614,6 +636,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");
@@ -644,6 +668,8 @@ static void test_hashmap_get(void) {
         char *r;
         char *val;
 
+        log_info("/* %s */", __func__);
+
         val = strdup("my val");
         assert_se(val);
 
@@ -671,6 +697,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);
 
@@ -710,16 +738,22 @@ static void test_hashmap_many(void) {
         Hashmap *h;
         unsigned i, j;
         void *v, *k;
-        static const struct {
+        bool slow = slow_tests_enabled();
+        const struct {
+                const char *title;
                 const struct hash_ops *ops;
                 unsigned n_entries;
         } tests[] = {
-                { .ops = NULL,                  .n_entries = 1 << 20 },
-                { .ops = &crippled_hashmap_ops, .n_entries = 1 << 14 },
+                { "trivial_hashmap_ops",  NULL,                  slow ? 1 << 20 : 240 },
+                { "crippled_hashmap_ops", &crippled_hashmap_ops, slow ? 1 << 14 : 140 },
         };
 
+        log_info("/* %s (%s) */", __func__, slow ? "slow" : "fast");
 
         for (j = 0; j < ELEMENTSOF(tests); j++) {
+                usec_t ts = now(CLOCK_MONOTONIC), n;
+                char b[FORMAT_TIMESPAN_MAX];
+
                 assert_se(h = hashmap_new(tests[j].ops));
 
                 for (i = 1; i < tests[j].n_entries*3; i+=3) {
@@ -730,7 +764,8 @@ static void test_hashmap_many(void) {
                 for (i = 1; i < tests[j].n_entries*3; i++)
                         assert_se(hashmap_contains(h, UINT_TO_PTR(i)) == (i % 3 == 1));
 
-                log_info("%u <= %u * 0.8 = %g", hashmap_size(h), hashmap_buckets(h), hashmap_buckets(h) * 0.8);
+                log_info("%s %u <= %u * 0.8 = %g",
+                         tests[j].title, hashmap_size(h), hashmap_buckets(h), hashmap_buckets(h) * 0.8);
 
                 assert_se(hashmap_size(h) <= hashmap_buckets(h) * 0.8);
                 assert_se(hashmap_size(h) == tests[j].n_entries);
@@ -742,12 +777,64 @@ static void test_hashmap_many(void) {
                 }
 
                 hashmap_free(h);
+
+                n = now(CLOCK_MONOTONIC);
+                log_info("test took %s", format_timespan(b, sizeof b, n - ts, 0));
+        }
+}
+
+extern unsigned custom_counter;
+extern const struct hash_ops boring_hash_ops, custom_hash_ops;
+
+static void test_hashmap_free(void) {
+        Hashmap *h;
+        bool slow = slow_tests_enabled();
+        usec_t ts, n;
+        char b[FORMAT_TIMESPAN_MAX];
+        unsigned n_entries = slow ? 1 << 20 : 240;
+
+        const struct {
+                const char *title;
+                const struct hash_ops *ops;
+                unsigned expect_counter;
+        } tests[] = {
+                { "string_hash_ops",      &boring_hash_ops, 2 * n_entries},
+                { "custom_free_hash_ops", &custom_hash_ops, 0 },
+        };
+
+        log_info("/* %s (%s, %u entries) */", __func__, slow ? "slow" : "fast", n_entries);
+
+        for (unsigned j = 0; j < ELEMENTSOF(tests); j++) {
+                ts = now(CLOCK_MONOTONIC);
+                assert_se(h = hashmap_new(tests[j].ops));
+
+                custom_counter = 0;
+                for (unsigned i = 0; i < n_entries; i++) {
+                        char s[DECIMAL_STR_MAX(unsigned)];
+                        char *k, *v;
+
+                        xsprintf(s, "%u", i);
+                        assert_se(k = strdup(s));
+                        assert_se(v = strdup(s));
+                        custom_counter += 2;
+
+                        assert_se(hashmap_put(h, k, v) >= 0);
+                }
+
+                hashmap_free(h);
+
+                n = now(CLOCK_MONOTONIC);
+                log_info("%s test took %s", tests[j].title, format_timespan(b, sizeof b, n - ts, 0));
+
+                assert_se(custom_counter == tests[j].expect_counter);
         }
 }
 
 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);
 
@@ -765,6 +852,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);
 
@@ -782,6 +871,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);
 
@@ -797,6 +888,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);
 
@@ -815,6 +908,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);
 
@@ -824,11 +919,50 @@ static void test_hashmap_clear_free_free(void) {
 
         hashmap_clear_free_free(m);
         assert_se(hashmap_isempty(m));
+
+        assert_se(hashmap_put(m, strdup("key 1"), strdup("value 1")) == 1);
+        assert_se(hashmap_put(m, strdup("key 2"), strdup("value 2")) == 1);
+        assert_se(hashmap_put(m, strdup("key 3"), strdup("value 3")) == 1);
+
+        hashmap_clear_free_free(m);
+        assert_se(hashmap_isempty(m));
+}
+
+DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(test_hash_ops_key, char, string_hash_func, string_compare_func, free);
+DEFINE_PRIVATE_HASH_OPS_FULL(test_hash_ops_full, char, string_hash_func, string_compare_func, free, char, free);
+
+static void test_hashmap_clear_free_with_destructor(void) {
+        _cleanup_hashmap_free_ Hashmap *m = NULL;
+
+        log_info("/* %s */", __func__);
+
+        m = hashmap_new(&test_hash_ops_key);
+        assert_se(m);
+
+        assert_se(hashmap_put(m, strdup("key 1"), NULL) == 1);
+        assert_se(hashmap_put(m, strdup("key 2"), NULL) == 1);
+        assert_se(hashmap_put(m, strdup("key 3"), NULL) == 1);
+
+        hashmap_clear_free(m);
+        assert_se(hashmap_isempty(m));
+        m = hashmap_free(m);
+
+        m = hashmap_new(&test_hash_ops_full);
+        assert_se(m);
+
+        assert_se(hashmap_put(m, strdup("key 1"), strdup("value 1")) == 1);
+        assert_se(hashmap_put(m, strdup("key 2"), strdup("value 2")) == 1);
+        assert_se(hashmap_put(m, strdup("key 3"), strdup("value 3")) == 1);
+
+        hashmap_clear_free(m);
+        assert_se(hashmap_isempty(m));
 }
 
 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);
@@ -844,6 +978,9 @@ static void test_hashmap_reserve(void) {
 }
 
 void test_hashmap_funcs(void) {
+        log_parse_environment();
+        log_open();
+
         test_hashmap_copy();
         test_hashmap_get_strv();
         test_hashmap_move_one();
@@ -866,10 +1003,12 @@ void test_hashmap_funcs(void) {
         test_hashmap_get2();
         test_hashmap_size();
         test_hashmap_many();
+        test_hashmap_free();
         test_hashmap_first();
         test_hashmap_first_key();
         test_hashmap_steal_first_key();
         test_hashmap_steal_first();
         test_hashmap_clear_free_free();
+        test_hashmap_clear_free_with_destructor();
         test_hashmap_reserve();
 }