src/test/test-hashmap.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include "hashmap.h"
   4 #include "string-util.h"
   5 #include "util.h"
   6
   7 unsigned custom_counter = 0;
   8 static void custom_destruct(void* p) {
   9         custom_counter--;
  10         free(p);
  11 }
  12
  13 DEFINE_HASH_OPS_FULL(boring_hash_ops, char, string_hash_func, string_compare_func, free, char, free);
  14 DEFINE_HASH_OPS_FULL(custom_hash_ops, char, string_hash_func, string_compare_func, custom_destruct, char, custom_destruct);
  15
  16 void test_hashmap_funcs(void);
  17 void test_ordered_hashmap_funcs(void);
  18
  19 static void test_ordered_hashmap_next(void) {
  20         _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
  21         int i;
  22
  23         log_info("/* %s */", __func__);
  24
  25         assert_se(m = ordered_hashmap_new(NULL));
  26         for (i = -2; i <= 2; i++)
  27                 assert_se(ordered_hashmap_put(m, INT_TO_PTR(i), INT_TO_PTR(i+10)) == 1);
  28         for (i = -2; i <= 1; i++)
  29                 assert_se(ordered_hashmap_next(m, INT_TO_PTR(i)) == INT_TO_PTR(i+11));
  30         assert_se(!ordered_hashmap_next(m, INT_TO_PTR(2)));
  31         assert_se(!ordered_hashmap_next(NULL, INT_TO_PTR(1)));
  32         assert_se(!ordered_hashmap_next(m, INT_TO_PTR(3)));
  33 }
  34
  35 static void test_uint64_compare_func(void) {
  36         const uint64_t a = 0x100, b = 0x101;
  37
  38         assert_se(uint64_compare_func(&a, &a) == 0);
  39         assert_se(uint64_compare_func(&a, &b) == -1);
  40         assert_se(uint64_compare_func(&b, &a) == 1);
  41 }
  42
  43 static void test_trivial_compare_func(void) {
  44         assert_se(trivial_compare_func(INT_TO_PTR('a'), INT_TO_PTR('a')) == 0);
  45         assert_se(trivial_compare_func(INT_TO_PTR('a'), INT_TO_PTR('b')) == -1);
  46         assert_se(trivial_compare_func(INT_TO_PTR('b'), INT_TO_PTR('a')) == 1);
  47 }
  48
  49 static void test_string_compare_func(void) {
  50         assert_se(string_compare_func("fred", "wilma") != 0);
  51         assert_se(string_compare_func("fred", "fred") == 0);
  52 }
  53
  54 static void compare_cache(Hashmap *map, IteratedCache *cache) {
  55         const void **keys = NULL, **values = NULL;
  56         unsigned num, idx;
  57         void *k, *v;
  58
  59         assert_se(iterated_cache_get(cache, &keys, &values, &num) == 0);
  60         assert_se(num == 0 || keys);
  61         assert_se(num == 0 || values);
  62
  63         idx = 0;
  64         HASHMAP_FOREACH_KEY(v, k, map) {
  65                 assert_se(v == values[idx]);
  66                 assert_se(k == keys[idx]);
  67
  68                 idx++;
  69         }
  70
  71         assert_se(idx == num);
  72 }
  73
  74 static void test_iterated_cache(void) {
  75         Hashmap *m;
  76         IteratedCache *c;
  77
  78         log_info("/* %s */", __func__);
  79
  80         assert_se(m = hashmap_new(NULL));
  81         assert_se(c = hashmap_iterated_cache_new(m));
  82         compare_cache(m, c);
  83
  84         for (int stage = 0; stage < 100; stage++) {
  85
  86                 for (int i = 0; i < 100; i++) {
  87                         int foo = stage * 1000 + i;
  88
  89                         assert_se(hashmap_put(m, INT_TO_PTR(foo), INT_TO_PTR(foo + 777)) == 1);
  90                 }
  91
  92                 compare_cache(m, c);
  93
  94                 if (!(stage % 10)) {
  95                         for (int i = 0; i < 100; i++) {
  96                                 int foo = stage * 1000 + i;
  97
  98                                 assert_se(hashmap_remove(m, INT_TO_PTR(foo)) == INT_TO_PTR(foo + 777));
  99                         }
 100
 101                         compare_cache(m, c);
 102                 }
 103         }
 104
 105         hashmap_clear(m);
 106         compare_cache(m, c);
 107
 108         assert_se(hashmap_free(m) == NULL);
 109         assert_se(iterated_cache_free(c) == NULL);
 110 }
 111
 112 static void test_hashmap_put_strdup(void) {
 113         _cleanup_hashmap_free_ Hashmap *m = NULL;
 114         char *s;
 115
 116         /* We don't have ordered_hashmap_put_strdup() yet. If it is added,
 117          * these tests should be moved to test-hashmap-plain.c. */
 118
 119         log_info("/* %s */", __func__);
 120
 121         assert_se(hashmap_put_strdup(&m, "foo", "bar") == 1);
 122         assert_se(hashmap_put_strdup(&m, "foo", "bar") == 0);
 123         assert_se(hashmap_put_strdup(&m, "foo", "BAR") == -EEXIST);
 124         assert_se(hashmap_put_strdup(&m, "foo", "bar") == 0);
 125         assert_se(hashmap_contains(m, "foo"));
 126
 127         s = hashmap_get(m, "foo");
 128         assert_se(streq(s, "bar"));
 129
 130         assert_se(hashmap_put_strdup(&m, "xxx", "bar") == 1);
 131         assert_se(hashmap_put_strdup(&m, "xxx", "bar") == 0);
 132         assert_se(hashmap_put_strdup(&m, "xxx", "BAR") == -EEXIST);
 133         assert_se(hashmap_put_strdup(&m, "xxx", "bar") == 0);
 134         assert_se(hashmap_contains(m, "xxx"));
 135
 136         s = hashmap_get(m, "xxx");
 137         assert_se(streq(s, "bar"));
 138 }
 139
 140 static void test_hashmap_put_strdup_null(void) {
 141         _cleanup_hashmap_free_ Hashmap *m = NULL;
 142         char *s;
 143
 144         log_info("/* %s */", __func__);
 145
 146         assert_se(hashmap_put_strdup(&m, "foo", "bar") == 1);
 147         assert_se(hashmap_put_strdup(&m, "foo", "bar") == 0);
 148         assert_se(hashmap_put_strdup(&m, "foo", NULL) == -EEXIST);
 149         assert_se(hashmap_put_strdup(&m, "foo", "bar") == 0);
 150         assert_se(hashmap_contains(m, "foo"));
 151
 152         s = hashmap_get(m, "foo");
 153         assert_se(streq(s, "bar"));
 154
 155         assert_se(hashmap_put_strdup(&m, "xxx", NULL) == 1);
 156         assert_se(hashmap_put_strdup(&m, "xxx", "bar") == -EEXIST);
 157         assert_se(hashmap_put_strdup(&m, "xxx", NULL) == 0);
 158         assert_se(hashmap_contains(m, "xxx"));
 159
 160         s = hashmap_get(m, "xxx");
 161         assert_se(s == NULL);
 162 }
 163
 164 int main(int argc, const char *argv[]) {
 165         /* This file tests in test-hashmap-plain.c, and tests in test-hashmap-ordered.c, which is generated
 166          * from test-hashmap-plain.c. Hashmap tests should be added to test-hashmap-plain.c, and here only if
 167          * they don't apply to ordered hashmaps. */
 168
 169         log_parse_environment();
 170         log_open();
 171
 172         test_hashmap_funcs();
 173         test_ordered_hashmap_funcs();
 174
 175         log_info("/************ non-shared tests ************/");
 176
 177         test_ordered_hashmap_next();
 178         test_uint64_compare_func();
 179         test_trivial_compare_func();
 180         test_string_compare_func();
 181         test_iterated_cache();
 182         test_hashmap_put_strdup();
 183         test_hashmap_put_strdup_null();
 184
 185         return 0;
 186 }