Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include "hashmap.h"
4 : : #include "util.h"
5 : :
6 : : unsigned custom_counter = 0;
7 : 12582912 : static void custom_destruct(void* p) {
8 : 12582912 : custom_counter--;
9 : 12582912 : free(p);
10 : 12582912 : }
11 : :
12 : 12582912 : DEFINE_HASH_OPS_FULL(boring_hash_ops, char, string_hash_func, string_compare_func, free, char, free);
13 : 12582912 : DEFINE_HASH_OPS_FULL(custom_hash_ops, char, string_hash_func, string_compare_func, custom_destruct, char, custom_destruct);
14 : :
15 : : void test_hashmap_funcs(void);
16 : : void test_ordered_hashmap_funcs(void);
17 : :
18 : 3 : static void test_ordered_hashmap_next(void) {
19 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
20 : : int i;
21 : :
22 [ + - ]: 3 : log_info("/* %s */", __func__);
23 : :
24 [ - + ]: 3 : assert_se(m = ordered_hashmap_new(NULL));
25 [ + + ]: 18 : for (i = -2; i <= 2; i++)
26 [ - + ]: 15 : assert_se(ordered_hashmap_put(m, INT_TO_PTR(i), INT_TO_PTR(i+10)) == 1);
27 [ + + ]: 15 : for (i = -2; i <= 1; i++)
28 [ - + ]: 12 : assert_se(ordered_hashmap_next(m, INT_TO_PTR(i)) == INT_TO_PTR(i+11));
29 [ - + ]: 3 : assert_se(!ordered_hashmap_next(m, INT_TO_PTR(2)));
30 [ - + ]: 3 : assert_se(!ordered_hashmap_next(NULL, INT_TO_PTR(1)));
31 [ - + ]: 3 : assert_se(!ordered_hashmap_next(m, INT_TO_PTR(3)));
32 : 3 : }
33 : :
34 : 3 : static void test_uint64_compare_func(void) {
35 : 3 : const uint64_t a = 0x100, b = 0x101;
36 : :
37 [ - + ]: 3 : assert_se(uint64_compare_func(&a, &a) == 0);
38 [ - + ]: 3 : assert_se(uint64_compare_func(&a, &b) == -1);
39 [ - + ]: 3 : assert_se(uint64_compare_func(&b, &a) == 1);
40 : 3 : }
41 : :
42 : 3 : static void test_trivial_compare_func(void) {
43 [ - + ]: 3 : assert_se(trivial_compare_func(INT_TO_PTR('a'), INT_TO_PTR('a')) == 0);
44 [ - + ]: 3 : assert_se(trivial_compare_func(INT_TO_PTR('a'), INT_TO_PTR('b')) == -1);
45 [ - + ]: 3 : assert_se(trivial_compare_func(INT_TO_PTR('b'), INT_TO_PTR('a')) == 1);
46 : 3 : }
47 : :
48 : 3 : static void test_string_compare_func(void) {
49 : : assert_se(string_compare_func("fred", "wilma") != 0);
50 : : assert_se(string_compare_func("fred", "fred") == 0);
51 : 3 : }
52 : :
53 : 336 : static void compare_cache(Hashmap *map, IteratedCache *cache) {
54 : 336 : const void **keys = NULL, **values = NULL;
55 : : unsigned num, idx;
56 : : Iterator iter;
57 : : void *k, *v;
58 : :
59 [ - + ]: 336 : assert_se(iterated_cache_get(cache, &keys, &values, &num) == 0);
60 [ + + - + ]: 336 : assert_se(num == 0 || keys);
61 [ + + - + ]: 336 : assert_se(num == 0 || values);
62 : :
63 : 336 : idx = 0;
64 [ + + ]: 1474836 : HASHMAP_FOREACH_KEY(v, k, map, iter) {
65 [ - + ]: 1474500 : assert_se(v == values[idx]);
66 [ - + ]: 1474500 : assert_se(k == keys[idx]);
67 : :
68 : 1474500 : idx++;
69 : : }
70 : :
71 [ - + ]: 336 : assert_se(idx == num);
72 : 336 : }
73 : :
74 : 3 : static void test_iterated_cache(void) {
75 : : Hashmap *m;
76 : : IteratedCache *c;
77 : :
78 [ + - ]: 3 : log_info("/* %s */", __func__);
79 : :
80 [ - + ]: 3 : assert_se(m = hashmap_new(NULL));
81 [ - + ]: 3 : assert_se(c = hashmap_iterated_cache_new(m));
82 : 3 : compare_cache(m, c);
83 : :
84 [ + + ]: 303 : for (int stage = 0; stage < 100; stage++) {
85 : :
86 [ + + ]: 30300 : for (int i = 0; i < 100; i++) {
87 : 30000 : int foo = stage * 1000 + i;
88 : :
89 [ - + ]: 30000 : assert_se(hashmap_put(m, INT_TO_PTR(foo), INT_TO_PTR(foo + 777)) == 1);
90 : : }
91 : :
92 : 300 : compare_cache(m, c);
93 : :
94 [ + + ]: 300 : if (!(stage % 10)) {
95 [ + + ]: 3030 : for (int i = 0; i < 100; i++) {
96 : 3000 : int foo = stage * 1000 + i;
97 : :
98 [ - + ]: 3000 : assert_se(hashmap_remove(m, INT_TO_PTR(foo)) == INT_TO_PTR(foo + 777));
99 : : }
100 : :
101 : 30 : compare_cache(m, c);
102 : : }
103 : : }
104 : :
105 : 3 : hashmap_clear(m);
106 : 3 : compare_cache(m, c);
107 : :
108 [ - + ]: 3 : assert_se(hashmap_free(m) == NULL);
109 [ - + ]: 3 : assert_se(iterated_cache_free(c) == NULL);
110 : 3 : }
111 : :
112 : 3 : int main(int argc, const char *argv[]) {
113 : : /* This file tests in test-hashmap-plain.c, and tests in test-hashmap-ordered.c, which is generated
114 : : * from test-hashmap-plain.c. Hashmap tests should be added to test-hashmap-plain.c, and here only if
115 : : * they don't apply to ordered hashmaps. */
116 : :
117 : 3 : log_parse_environment();
118 : 3 : log_open();
119 : :
120 : 3 : test_hashmap_funcs();
121 : 3 : test_ordered_hashmap_funcs();
122 : :
123 [ + - ]: 3 : log_info("/************ non-shared tests ************/");
124 : :
125 : 3 : test_ordered_hashmap_next();
126 : 3 : test_uint64_compare_func();
127 : 3 : test_trivial_compare_func();
128 : 3 : test_string_compare_func();
129 : 3 : test_iterated_cache();
130 : :
131 : 3 : return 0;
132 : : }
|
