Branch data Line data Source code
1 : : /* GENERATED FILE */
2 : : #define ORDERED
3 : : /* SPDX-License-Identifier: LGPL-2.1+ */
4 : :
5 : : #include "alloc-util.h"
6 : : #include "hashmap.h"
7 : : #include "log.h"
8 : : #include "nulstr-util.h"
9 : : #include "stdio-util.h"
10 : : #include "string-util.h"
11 : : #include "strv.h"
12 : : #include "time-util.h"
13 : : #include "tests.h"
14 : :
15 : : void test_ordered_hashmap_funcs(void);
16 : :
17 : 3 : static void test_ordered_hashmap_replace(void) {
18 : : OrderedHashmap *m;
19 : : char *val1, *val2, *val3, *val4, *val5, *r;
20 : :
21 [ + - ]: 3 : log_info("/* %s */", __func__);
22 : :
23 : 3 : m = ordered_hashmap_new(&string_hash_ops);
24 : :
25 : 3 : val1 = strdup("val1");
26 [ - + ]: 3 : assert_se(val1);
27 : 3 : val2 = strdup("val2");
28 [ - + ]: 3 : assert_se(val2);
29 : 3 : val3 = strdup("val3");
30 [ - + ]: 3 : assert_se(val3);
31 : 3 : val4 = strdup("val4");
32 [ - + ]: 3 : assert_se(val4);
33 : 3 : val5 = strdup("val5");
34 [ - + ]: 3 : assert_se(val5);
35 : :
36 : 3 : ordered_hashmap_put(m, "key 1", val1);
37 : 3 : ordered_hashmap_put(m, "key 2", val2);
38 : 3 : ordered_hashmap_put(m, "key 3", val3);
39 : 3 : ordered_hashmap_put(m, "key 4", val4);
40 : :
41 : 3 : ordered_hashmap_replace(m, "key 3", val1);
42 : 3 : r = ordered_hashmap_get(m, "key 3");
43 [ - + ]: 3 : assert_se(streq(r, "val1"));
44 : :
45 : 3 : ordered_hashmap_replace(m, "key 5", val5);
46 : 3 : r = ordered_hashmap_get(m, "key 5");
47 [ - + ]: 3 : assert_se(streq(r, "val5"));
48 : :
49 : 3 : free(val1);
50 : 3 : free(val2);
51 : 3 : free(val3);
52 : 3 : free(val4);
53 : 3 : free(val5);
54 : 3 : ordered_hashmap_free(m);
55 : 3 : }
56 : :
57 : 3 : static void test_ordered_hashmap_copy(void) {
58 : : OrderedHashmap *m, *copy;
59 : : char *val1, *val2, *val3, *val4, *r;
60 : :
61 [ + - ]: 3 : log_info("/* %s */", __func__);
62 : :
63 : 3 : val1 = strdup("val1");
64 [ - + ]: 3 : assert_se(val1);
65 : 3 : val2 = strdup("val2");
66 [ - + ]: 3 : assert_se(val2);
67 : 3 : val3 = strdup("val3");
68 [ - + ]: 3 : assert_se(val3);
69 : 3 : val4 = strdup("val4");
70 [ - + ]: 3 : assert_se(val4);
71 : :
72 : 3 : m = ordered_hashmap_new(&string_hash_ops);
73 : :
74 : 3 : ordered_hashmap_put(m, "key 1", val1);
75 : 3 : ordered_hashmap_put(m, "key 2", val2);
76 : 3 : ordered_hashmap_put(m, "key 3", val3);
77 : 3 : ordered_hashmap_put(m, "key 4", val4);
78 : :
79 : 3 : copy = ordered_hashmap_copy(m);
80 : :
81 : 3 : r = ordered_hashmap_get(copy, "key 1");
82 [ - + ]: 3 : assert_se(streq(r, "val1"));
83 : 3 : r = ordered_hashmap_get(copy, "key 2");
84 [ - + ]: 3 : assert_se(streq(r, "val2"));
85 : 3 : r = ordered_hashmap_get(copy, "key 3");
86 [ - + ]: 3 : assert_se(streq(r, "val3"));
87 : 3 : r = ordered_hashmap_get(copy, "key 4");
88 [ - + ]: 3 : assert_se(streq(r, "val4"));
89 : :
90 : 3 : ordered_hashmap_free_free(copy);
91 : 3 : ordered_hashmap_free(m);
92 : 3 : }
93 : :
94 : 3 : static void test_ordered_hashmap_get_strv(void) {
95 : : OrderedHashmap *m;
96 : : char **strv;
97 : : char *val1, *val2, *val3, *val4;
98 : :
99 [ + - ]: 3 : log_info("/* %s */", __func__);
100 : :
101 : 3 : val1 = strdup("val1");
102 [ - + ]: 3 : assert_se(val1);
103 : 3 : val2 = strdup("val2");
104 [ - + ]: 3 : assert_se(val2);
105 : 3 : val3 = strdup("val3");
106 [ - + ]: 3 : assert_se(val3);
107 : 3 : val4 = strdup("val4");
108 [ - + ]: 3 : assert_se(val4);
109 : :
110 : 3 : m = ordered_hashmap_new(&string_hash_ops);
111 : :
112 : 3 : ordered_hashmap_put(m, "key 1", val1);
113 : 3 : ordered_hashmap_put(m, "key 2", val2);
114 : 3 : ordered_hashmap_put(m, "key 3", val3);
115 : 3 : ordered_hashmap_put(m, "key 4", val4);
116 : :
117 : 3 : strv = ordered_hashmap_get_strv(m);
118 : :
119 : : #ifndef ORDERED
120 : : strv = strv_sort(strv);
121 : : #endif
122 : :
123 [ - + ]: 3 : assert_se(streq(strv[0], "val1"));
124 [ - + ]: 3 : assert_se(streq(strv[1], "val2"));
125 [ - + ]: 3 : assert_se(streq(strv[2], "val3"));
126 [ - + ]: 3 : assert_se(streq(strv[3], "val4"));
127 : :
128 : 3 : strv_free(strv);
129 : :
130 : 3 : ordered_hashmap_free(m);
131 : 3 : }
132 : :
133 : 3 : static void test_ordered_hashmap_move_one(void) {
134 : : OrderedHashmap *m, *n;
135 : : char *val1, *val2, *val3, *val4, *r;
136 : :
137 [ + - ]: 3 : log_info("/* %s */", __func__);
138 : :
139 : 3 : val1 = strdup("val1");
140 [ - + ]: 3 : assert_se(val1);
141 : 3 : val2 = strdup("val2");
142 [ - + ]: 3 : assert_se(val2);
143 : 3 : val3 = strdup("val3");
144 [ - + ]: 3 : assert_se(val3);
145 : 3 : val4 = strdup("val4");
146 [ - + ]: 3 : assert_se(val4);
147 : :
148 : 3 : m = ordered_hashmap_new(&string_hash_ops);
149 : 3 : n = ordered_hashmap_new(&string_hash_ops);
150 : :
151 : 3 : ordered_hashmap_put(m, "key 1", val1);
152 : 3 : ordered_hashmap_put(m, "key 2", val2);
153 : 3 : ordered_hashmap_put(m, "key 3", val3);
154 : 3 : ordered_hashmap_put(m, "key 4", val4);
155 : :
156 [ - + ]: 3 : assert_se(ordered_hashmap_move_one(n, NULL, "key 3") == -ENOENT);
157 [ - + ]: 3 : assert_se(ordered_hashmap_move_one(n, m, "key 5") == -ENOENT);
158 [ - + ]: 3 : assert_se(ordered_hashmap_move_one(n, m, "key 3") == 0);
159 [ - + ]: 3 : assert_se(ordered_hashmap_move_one(n, m, "key 4") == 0);
160 : :
161 : 3 : r = ordered_hashmap_get(n, "key 3");
162 [ + - - + ]: 3 : assert_se(r && streq(r, "val3"));
163 : 3 : r = ordered_hashmap_get(n, "key 4");
164 [ + - - + ]: 3 : assert_se(r && streq(r, "val4"));
165 : 3 : r = ordered_hashmap_get(m, "key 3");
166 [ - + ]: 3 : assert_se(!r);
167 : :
168 [ - + ]: 3 : assert_se(ordered_hashmap_move_one(n, m, "key 3") == -EEXIST);
169 : :
170 : 3 : ordered_hashmap_free_free(m);
171 : 3 : ordered_hashmap_free_free(n);
172 : 3 : }
173 : :
174 : 3 : static void test_ordered_hashmap_move(void) {
175 : : OrderedHashmap *m, *n;
176 : : char *val1, *val2, *val3, *val4, *r;
177 : :
178 [ + - ]: 3 : log_info("/* %s */", __func__);
179 : :
180 : 3 : val1 = strdup("val1");
181 [ - + ]: 3 : assert_se(val1);
182 : 3 : val2 = strdup("val2");
183 [ - + ]: 3 : assert_se(val2);
184 : 3 : val3 = strdup("val3");
185 [ - + ]: 3 : assert_se(val3);
186 : 3 : val4 = strdup("val4");
187 [ - + ]: 3 : assert_se(val4);
188 : :
189 : 3 : m = ordered_hashmap_new(&string_hash_ops);
190 : 3 : n = ordered_hashmap_new(&string_hash_ops);
191 : :
192 : 3 : ordered_hashmap_put(n, "key 1", strdup(val1));
193 : 3 : ordered_hashmap_put(m, "key 1", val1);
194 : 3 : ordered_hashmap_put(m, "key 2", val2);
195 : 3 : ordered_hashmap_put(m, "key 3", val3);
196 : 3 : ordered_hashmap_put(m, "key 4", val4);
197 : :
198 [ - + ]: 3 : assert_se(ordered_hashmap_move(n, NULL) == 0);
199 [ - + ]: 3 : assert_se(ordered_hashmap_move(n, m) == 0);
200 : :
201 [ - + ]: 3 : assert_se(ordered_hashmap_size(m) == 1);
202 : 3 : r = ordered_hashmap_get(m, "key 1");
203 [ + - - + ]: 3 : assert_se(r && streq(r, "val1"));
204 : :
205 : 3 : r = ordered_hashmap_get(n, "key 1");
206 [ + - - + ]: 3 : assert_se(r && streq(r, "val1"));
207 : 3 : r = ordered_hashmap_get(n, "key 2");
208 [ + - - + ]: 3 : assert_se(r && streq(r, "val2"));
209 : 3 : r = ordered_hashmap_get(n, "key 3");
210 [ + - - + ]: 3 : assert_se(r && streq(r, "val3"));
211 : 3 : r = ordered_hashmap_get(n, "key 4");
212 [ + - - + ]: 3 : assert_se(r && streq(r, "val4"));
213 : :
214 : 3 : ordered_hashmap_free_free(m);
215 : 3 : ordered_hashmap_free_free(n);
216 : 3 : }
217 : :
218 : 3 : static void test_ordered_hashmap_update(void) {
219 : : OrderedHashmap *m;
220 : : char *val1, *val2, *r;
221 : :
222 [ + - ]: 3 : log_info("/* %s */", __func__);
223 : :
224 : 3 : m = ordered_hashmap_new(&string_hash_ops);
225 : 3 : val1 = strdup("old_value");
226 [ - + ]: 3 : assert_se(val1);
227 : 3 : val2 = strdup("new_value");
228 [ - + ]: 3 : assert_se(val2);
229 : :
230 : 3 : ordered_hashmap_put(m, "key 1", val1);
231 : 3 : r = ordered_hashmap_get(m, "key 1");
232 [ - + ]: 3 : assert_se(streq(r, "old_value"));
233 : :
234 [ - + ]: 3 : assert_se(ordered_hashmap_update(m, "key 2", val2) == -ENOENT);
235 : 3 : r = ordered_hashmap_get(m, "key 1");
236 [ - + ]: 3 : assert_se(streq(r, "old_value"));
237 : :
238 [ - + ]: 3 : assert_se(ordered_hashmap_update(m, "key 1", val2) == 0);
239 : 3 : r = ordered_hashmap_get(m, "key 1");
240 [ - + ]: 3 : assert_se(streq(r, "new_value"));
241 : :
242 : 3 : free(val1);
243 : 3 : free(val2);
244 : 3 : ordered_hashmap_free(m);
245 : 3 : }
246 : :
247 : 3 : static void test_ordered_hashmap_put(void) {
248 : 3 : OrderedHashmap *m = NULL;
249 : : int valid_ordered_hashmap_put;
250 : 3 : void *val1 = (void*) "val 1";
251 : 3 : void *val2 = (void*) "val 2";
252 : 3 : _cleanup_free_ char* key1 = NULL;
253 : :
254 [ + - ]: 3 : log_info("/* %s */", __func__);
255 : :
256 [ - + ]: 3 : assert_se(ordered_hashmap_ensure_allocated(&m, &string_hash_ops) >= 0);
257 [ - + ]: 3 : assert_se(m);
258 : :
259 : 3 : valid_ordered_hashmap_put = ordered_hashmap_put(m, "key 1", val1);
260 [ - + ]: 3 : assert_se(valid_ordered_hashmap_put == 1);
261 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, "key 1", val1) == 0);
262 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, "key 1", val2) == -EEXIST);
263 : 3 : key1 = strdup("key 1");
264 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, key1, val1) == 0);
265 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, key1, val2) == -EEXIST);
266 : :
267 : 3 : ordered_hashmap_free(m);
268 : 3 : }
269 : :
270 : 3 : static void test_ordered_hashmap_remove(void) {
271 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
272 : : char *r;
273 : :
274 [ + - ]: 3 : log_info("/* %s */", __func__);
275 : :
276 : 3 : r = ordered_hashmap_remove(NULL, "key 1");
277 [ - + ]: 3 : assert_se(r == NULL);
278 : :
279 : 3 : m = ordered_hashmap_new(&string_hash_ops);
280 [ - + ]: 3 : assert_se(m);
281 : :
282 : 3 : r = ordered_hashmap_remove(m, "no such key");
283 [ - + ]: 3 : assert_se(r == NULL);
284 : :
285 : 3 : ordered_hashmap_put(m, "key 1", (void*) "val 1");
286 : 3 : ordered_hashmap_put(m, "key 2", (void*) "val 2");
287 : :
288 : 3 : r = ordered_hashmap_remove(m, "key 1");
289 [ - + ]: 3 : assert_se(streq(r, "val 1"));
290 : :
291 : 3 : r = ordered_hashmap_get(m, "key 2");
292 [ - + ]: 3 : assert_se(streq(r, "val 2"));
293 [ - + ]: 3 : assert_se(!ordered_hashmap_get(m, "key 1"));
294 : 3 : }
295 : :
296 : 3 : static void test_ordered_hashmap_remove2(void) {
297 : 3 : _cleanup_ordered_hashmap_free_free_free_ OrderedHashmap *m = NULL;
298 : 3 : char key1[] = "key 1";
299 : 3 : char key2[] = "key 2";
300 : 3 : char val1[] = "val 1";
301 : 3 : char val2[] = "val 2";
302 : : void *r, *r2;
303 : :
304 [ + - ]: 3 : log_info("/* %s */", __func__);
305 : :
306 : 3 : r = ordered_hashmap_remove2(NULL, "key 1", &r2);
307 [ - + ]: 3 : assert_se(r == NULL);
308 : :
309 : 3 : m = ordered_hashmap_new(&string_hash_ops);
310 [ - + ]: 3 : assert_se(m);
311 : :
312 : 3 : r = ordered_hashmap_remove2(m, "no such key", &r2);
313 [ - + ]: 3 : assert_se(r == NULL);
314 : :
315 : 3 : ordered_hashmap_put(m, strdup(key1), strdup(val1));
316 : 3 : ordered_hashmap_put(m, strdup(key2), strdup(val2));
317 : :
318 : 3 : r = ordered_hashmap_remove2(m, key1, &r2);
319 [ - + ]: 3 : assert_se(streq(r, val1));
320 [ - + ]: 3 : assert_se(streq(r2, key1));
321 : 3 : free(r);
322 : 3 : free(r2);
323 : :
324 : 3 : r = ordered_hashmap_get(m, key2);
325 [ - + ]: 3 : assert_se(streq(r, val2));
326 [ - + ]: 3 : assert_se(!ordered_hashmap_get(m, key1));
327 : 3 : }
328 : :
329 : 3 : static void test_ordered_hashmap_remove_value(void) {
330 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
331 : : char *r;
332 : :
333 : 3 : char val1[] = "val 1";
334 : 3 : char val2[] = "val 2";
335 : :
336 [ + - ]: 3 : log_info("/* %s */", __func__);
337 : :
338 : 3 : r = ordered_hashmap_remove_value(NULL, "key 1", val1);
339 [ - + ]: 3 : assert_se(r == NULL);
340 : :
341 : 3 : m = ordered_hashmap_new(&string_hash_ops);
342 [ - + ]: 3 : assert_se(m);
343 : :
344 : 3 : r = ordered_hashmap_remove_value(m, "key 1", val1);
345 [ - + ]: 3 : assert_se(r == NULL);
346 : :
347 : 3 : ordered_hashmap_put(m, "key 1", val1);
348 : 3 : ordered_hashmap_put(m, "key 2", val2);
349 : :
350 : 3 : r = ordered_hashmap_remove_value(m, "key 1", val1);
351 [ - + ]: 3 : assert_se(streq(r, "val 1"));
352 : :
353 : 3 : r = ordered_hashmap_get(m, "key 2");
354 [ - + ]: 3 : assert_se(streq(r, "val 2"));
355 [ - + ]: 3 : assert_se(!ordered_hashmap_get(m, "key 1"));
356 : :
357 : 3 : r = ordered_hashmap_remove_value(m, "key 2", val1);
358 [ - + ]: 3 : assert_se(r == NULL);
359 : :
360 : 3 : r = ordered_hashmap_get(m, "key 2");
361 [ - + ]: 3 : assert_se(streq(r, "val 2"));
362 [ - + ]: 3 : assert_se(!ordered_hashmap_get(m, "key 1"));
363 : 3 : }
364 : :
365 : 3 : static void test_ordered_hashmap_remove_and_put(void) {
366 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
367 : : int valid;
368 : : char *r;
369 : :
370 [ + - ]: 3 : log_info("/* %s */", __func__);
371 : :
372 : 3 : m = ordered_hashmap_new(&string_hash_ops);
373 [ - + ]: 3 : assert_se(m);
374 : :
375 : 3 : valid = ordered_hashmap_remove_and_put(m, "invalid key", "new key", NULL);
376 [ - + ]: 3 : assert_se(valid == -ENOENT);
377 : :
378 : 3 : valid = ordered_hashmap_put(m, "key 1", (void*) (const char *) "val 1");
379 [ - + ]: 3 : assert_se(valid == 1);
380 : :
381 : 3 : valid = ordered_hashmap_remove_and_put(NULL, "key 1", "key 2", (void*) (const char *) "val 2");
382 [ - + ]: 3 : assert_se(valid == -ENOENT);
383 : :
384 : 3 : valid = ordered_hashmap_remove_and_put(m, "key 1", "key 2", (void*) (const char *) "val 2");
385 [ - + ]: 3 : assert_se(valid == 0);
386 : :
387 : 3 : r = ordered_hashmap_get(m, "key 2");
388 [ - + ]: 3 : assert_se(streq(r, "val 2"));
389 [ - + ]: 3 : assert_se(!ordered_hashmap_get(m, "key 1"));
390 : :
391 : 3 : valid = ordered_hashmap_put(m, "key 3", (void*) (const char *) "val 3");
392 [ - + ]: 3 : assert_se(valid == 1);
393 : 3 : valid = ordered_hashmap_remove_and_put(m, "key 3", "key 2", (void*) (const char *) "val 2");
394 [ - + ]: 3 : assert_se(valid == -EEXIST);
395 : 3 : }
396 : :
397 : 3 : static void test_ordered_hashmap_remove_and_replace(void) {
398 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
399 : : int valid;
400 : 3 : void *key1 = UINT_TO_PTR(1);
401 : 3 : void *key2 = UINT_TO_PTR(2);
402 : 3 : void *key3 = UINT_TO_PTR(3);
403 : : void *r;
404 : : int i, j;
405 : :
406 [ + - ]: 3 : log_info("/* %s */", __func__);
407 : :
408 : 3 : m = ordered_hashmap_new(&trivial_hash_ops);
409 [ - + ]: 3 : assert_se(m);
410 : :
411 : 3 : valid = ordered_hashmap_remove_and_replace(m, key1, key2, NULL);
412 [ - + ]: 3 : assert_se(valid == -ENOENT);
413 : :
414 : 3 : valid = ordered_hashmap_put(m, key1, key1);
415 [ - + ]: 3 : assert_se(valid == 1);
416 : :
417 : 3 : valid = ordered_hashmap_remove_and_replace(NULL, key1, key2, key2);
418 [ - + ]: 3 : assert_se(valid == -ENOENT);
419 : :
420 : 3 : valid = ordered_hashmap_remove_and_replace(m, key1, key2, key2);
421 [ - + ]: 3 : assert_se(valid == 0);
422 : :
423 : 3 : r = ordered_hashmap_get(m, key2);
424 [ - + ]: 3 : assert_se(r == key2);
425 [ - + ]: 3 : assert_se(!ordered_hashmap_get(m, key1));
426 : :
427 : 3 : valid = ordered_hashmap_put(m, key3, key3);
428 [ - + ]: 3 : assert_se(valid == 1);
429 : 3 : valid = ordered_hashmap_remove_and_replace(m, key3, key2, key2);
430 [ - + ]: 3 : assert_se(valid == 0);
431 : 3 : r = ordered_hashmap_get(m, key2);
432 [ - + ]: 3 : assert_se(r == key2);
433 [ - + ]: 3 : assert_se(!ordered_hashmap_get(m, key3));
434 : :
435 : : /* Repeat this test several times to increase the chance of hitting
436 : : * the less likely case in ordered_hashmap_remove_and_replace where it
437 : : * compensates for the backward shift. */
438 [ + + ]: 63 : for (i = 0; i < 20; i++) {
439 : 60 : ordered_hashmap_clear(m);
440 : :
441 [ + + ]: 420 : for (j = 1; j < 7; j++)
442 : 360 : ordered_hashmap_put(m, UINT_TO_PTR(10*i + j), UINT_TO_PTR(10*i + j));
443 : 120 : valid = ordered_hashmap_remove_and_replace(m, UINT_TO_PTR(10*i + 1),
444 : 60 : UINT_TO_PTR(10*i + 2),
445 : 60 : UINT_TO_PTR(10*i + 2));
446 [ - + ]: 60 : assert_se(valid == 0);
447 [ - + ]: 60 : assert_se(!ordered_hashmap_get(m, UINT_TO_PTR(10*i + 1)));
448 [ + + ]: 360 : for (j = 2; j < 7; j++) {
449 : 300 : r = ordered_hashmap_get(m, UINT_TO_PTR(10*i + j));
450 [ - + ]: 300 : assert_se(r == UINT_TO_PTR(10*i + j));
451 : : }
452 : : }
453 : 3 : }
454 : :
455 : 3 : static void test_ordered_hashmap_ensure_allocated(void) {
456 : : OrderedHashmap *m;
457 : : int valid_ordered_hashmap;
458 : :
459 [ + - ]: 3 : log_info("/* %s */", __func__);
460 : :
461 : 3 : m = ordered_hashmap_new(&string_hash_ops);
462 : :
463 : 3 : valid_ordered_hashmap = ordered_hashmap_ensure_allocated(&m, &string_hash_ops);
464 [ - + ]: 3 : assert_se(valid_ordered_hashmap == 0);
465 : :
466 [ - + ]: 3 : assert_se(m);
467 : 3 : ordered_hashmap_free(m);
468 : 3 : }
469 : :
470 : 3 : static void test_ordered_hashmap_foreach_key(void) {
471 : : OrderedHashmap *m;
472 : : Iterator i;
473 : 3 : bool key_found[] = { false, false, false, false };
474 : : const char *s;
475 : : const char *key;
476 : : static const char key_table[] =
477 : : "key 1\0"
478 : : "key 2\0"
479 : : "key 3\0"
480 : : "key 4\0";
481 : :
482 [ + - ]: 3 : log_info("/* %s */", __func__);
483 : :
484 : 3 : m = ordered_hashmap_new(&string_hash_ops);
485 : :
486 [ + - + + ]: 15 : NULSTR_FOREACH(key, key_table)
487 : 12 : ordered_hashmap_put(m, key, (void*) (const char*) "my dummy val");
488 : :
489 [ + + ]: 15 : ORDERED_HASHMAP_FOREACH_KEY(s, key, m, i) {
490 [ - + ]: 12 : assert(s);
491 [ + + + - ]: 12 : if (!key_found[0] && streq(key, "key 1"))
492 : 3 : key_found[0] = true;
493 [ + + + - ]: 9 : else if (!key_found[1] && streq(key, "key 2"))
494 : 3 : key_found[1] = true;
495 [ + + + - ]: 6 : else if (!key_found[2] && streq(key, "key 3"))
496 : 3 : key_found[2] = true;
497 [ + - - + ]: 3 : else if (!key_found[3] && streq(key, "fail"))
498 : 0 : key_found[3] = true;
499 : : }
500 : :
501 [ - + ]: 3 : assert_se(m);
502 [ + - - + : 3 : assert_se(key_found[0] && key_found[1] && key_found[2] && !key_found[3]);
+ - - + +
- - + ]
503 : :
504 : 3 : ordered_hashmap_free(m);
505 : 3 : }
506 : :
507 : 3 : static void test_ordered_hashmap_foreach(void) {
508 : : OrderedHashmap *m;
509 : : Iterator i;
510 : 3 : bool value_found[] = { false, false, false, false };
511 : : char *val1, *val2, *val3, *val4, *s;
512 : : unsigned count;
513 : :
514 [ + - ]: 3 : log_info("/* %s */", __func__);
515 : :
516 : 3 : val1 = strdup("my val1");
517 [ - + ]: 3 : assert_se(val1);
518 : 3 : val2 = strdup("my val2");
519 [ - + ]: 3 : assert_se(val2);
520 : 3 : val3 = strdup("my val3");
521 [ - + ]: 3 : assert_se(val3);
522 : 3 : val4 = strdup("my val4");
523 [ - + ]: 3 : assert_se(val4);
524 : :
525 : 3 : m = NULL;
526 : :
527 : 3 : count = 0;
528 [ - + ]: 3 : ORDERED_HASHMAP_FOREACH(s, m, i)
529 : 0 : count++;
530 [ - + ]: 3 : assert_se(count == 0);
531 : :
532 : 3 : m = ordered_hashmap_new(&string_hash_ops);
533 : :
534 : 3 : count = 0;
535 [ - + ]: 3 : ORDERED_HASHMAP_FOREACH(s, m, i)
536 : 0 : count++;
537 [ - + ]: 3 : assert_se(count == 0);
538 : :
539 : 3 : ordered_hashmap_put(m, "Key 1", val1);
540 : 3 : ordered_hashmap_put(m, "Key 2", val2);
541 : 3 : ordered_hashmap_put(m, "Key 3", val3);
542 : 3 : ordered_hashmap_put(m, "Key 4", val4);
543 : :
544 [ + + ]: 15 : ORDERED_HASHMAP_FOREACH(s, m, i) {
545 [ + + + - ]: 12 : if (!value_found[0] && streq(s, val1))
546 : 3 : value_found[0] = true;
547 [ + + + - ]: 9 : else if (!value_found[1] && streq(s, val2))
548 : 3 : value_found[1] = true;
549 [ + + + - ]: 6 : else if (!value_found[2] && streq(s, val3))
550 : 3 : value_found[2] = true;
551 [ + - + - ]: 3 : else if (!value_found[3] && streq(s, val4))
552 : 3 : value_found[3] = true;
553 : : }
554 : :
555 [ - + ]: 3 : assert_se(m);
556 [ + - - + : 3 : assert_se(value_found[0] && value_found[1] && value_found[2] && value_found[3]);
+ - - + +
- - + ]
557 : :
558 : 3 : ordered_hashmap_free_free(m);
559 : 3 : }
560 : :
561 : 3 : static void test_ordered_hashmap_merge(void) {
562 : : OrderedHashmap *m;
563 : : OrderedHashmap *n;
564 : : char *val1, *val2, *val3, *val4, *r;
565 : :
566 [ + - ]: 3 : log_info("/* %s */", __func__);
567 : :
568 : 3 : val1 = strdup("my val1");
569 [ - + ]: 3 : assert_se(val1);
570 : 3 : val2 = strdup("my val2");
571 [ - + ]: 3 : assert_se(val2);
572 : 3 : val3 = strdup("my val3");
573 [ - + ]: 3 : assert_se(val3);
574 : 3 : val4 = strdup("my val4");
575 [ - + ]: 3 : assert_se(val4);
576 : :
577 : 3 : n = ordered_hashmap_new(&string_hash_ops);
578 : 3 : m = ordered_hashmap_new(&string_hash_ops);
579 : :
580 : 3 : ordered_hashmap_put(m, "Key 1", val1);
581 : 3 : ordered_hashmap_put(m, "Key 2", val2);
582 : 3 : ordered_hashmap_put(n, "Key 3", val3);
583 : 3 : ordered_hashmap_put(n, "Key 4", val4);
584 : :
585 [ - + ]: 3 : assert_se(ordered_hashmap_merge(m, n) == 0);
586 : 3 : r = ordered_hashmap_get(m, "Key 3");
587 [ + - - + ]: 3 : assert_se(r && streq(r, "my val3"));
588 : 3 : r = ordered_hashmap_get(m, "Key 4");
589 [ + - - + ]: 3 : assert_se(r && streq(r, "my val4"));
590 : :
591 [ - + ]: 3 : assert_se(n);
592 [ - + ]: 3 : assert_se(m);
593 : 3 : ordered_hashmap_free(n);
594 : 3 : ordered_hashmap_free_free(m);
595 : 3 : }
596 : :
597 : 3 : static void test_ordered_hashmap_contains(void) {
598 : : OrderedHashmap *m;
599 : : char *val1;
600 : :
601 [ + - ]: 3 : log_info("/* %s */", __func__);
602 : :
603 : 3 : val1 = strdup("my val");
604 [ - + ]: 3 : assert_se(val1);
605 : :
606 : 3 : m = ordered_hashmap_new(&string_hash_ops);
607 : :
608 [ - + ]: 3 : assert_se(!ordered_hashmap_contains(m, "Key 1"));
609 : 3 : ordered_hashmap_put(m, "Key 1", val1);
610 [ - + ]: 3 : assert_se(ordered_hashmap_contains(m, "Key 1"));
611 [ - + ]: 3 : assert_se(!ordered_hashmap_contains(m, "Key 2"));
612 : :
613 [ - + ]: 3 : assert_se(!ordered_hashmap_contains(NULL, "Key 1"));
614 : :
615 [ - + ]: 3 : assert_se(m);
616 : 3 : ordered_hashmap_free_free(m);
617 : 3 : }
618 : :
619 : 3 : static void test_ordered_hashmap_isempty(void) {
620 : : OrderedHashmap *m;
621 : : char *val1;
622 : :
623 [ + - ]: 3 : log_info("/* %s */", __func__);
624 : :
625 : 3 : val1 = strdup("my val");
626 [ - + ]: 3 : assert_se(val1);
627 : :
628 : 3 : m = ordered_hashmap_new(&string_hash_ops);
629 : :
630 [ - + ]: 3 : assert_se(ordered_hashmap_isempty(m));
631 : 3 : ordered_hashmap_put(m, "Key 1", val1);
632 [ - + ]: 3 : assert_se(!ordered_hashmap_isempty(m));
633 : :
634 [ - + ]: 3 : assert_se(m);
635 : 3 : ordered_hashmap_free_free(m);
636 : 3 : }
637 : :
638 : 3 : static void test_ordered_hashmap_size(void) {
639 : : OrderedHashmap *m;
640 : : char *val1, *val2, *val3, *val4;
641 : :
642 [ + - ]: 3 : log_info("/* %s */", __func__);
643 : :
644 : 3 : val1 = strdup("my val");
645 [ - + ]: 3 : assert_se(val1);
646 : 3 : val2 = strdup("my val");
647 [ - + ]: 3 : assert_se(val2);
648 : 3 : val3 = strdup("my val");
649 [ - + ]: 3 : assert_se(val3);
650 : 3 : val4 = strdup("my val");
651 [ - + ]: 3 : assert_se(val4);
652 : :
653 [ - + ]: 3 : assert_se(ordered_hashmap_size(NULL) == 0);
654 [ - + ]: 3 : assert_se(ordered_hashmap_buckets(NULL) == 0);
655 : :
656 : 3 : m = ordered_hashmap_new(&string_hash_ops);
657 : :
658 : 3 : ordered_hashmap_put(m, "Key 1", val1);
659 : 3 : ordered_hashmap_put(m, "Key 2", val2);
660 : 3 : ordered_hashmap_put(m, "Key 3", val3);
661 : 3 : ordered_hashmap_put(m, "Key 4", val4);
662 : :
663 [ - + ]: 3 : assert_se(m);
664 [ - + ]: 3 : assert_se(ordered_hashmap_size(m) == 4);
665 [ - + ]: 3 : assert_se(ordered_hashmap_buckets(m) >= 4);
666 : 3 : ordered_hashmap_free_free(m);
667 : 3 : }
668 : :
669 : 3 : static void test_ordered_hashmap_get(void) {
670 : : OrderedHashmap *m;
671 : : char *r;
672 : : char *val;
673 : :
674 [ + - ]: 3 : log_info("/* %s */", __func__);
675 : :
676 : 3 : val = strdup("my val");
677 [ - + ]: 3 : assert_se(val);
678 : :
679 : 3 : r = ordered_hashmap_get(NULL, "Key 1");
680 [ - + ]: 3 : assert_se(r == NULL);
681 : :
682 : 3 : m = ordered_hashmap_new(&string_hash_ops);
683 : :
684 : 3 : ordered_hashmap_put(m, "Key 1", val);
685 : :
686 : 3 : r = ordered_hashmap_get(m, "Key 1");
687 [ - + ]: 3 : assert_se(streq(r, val));
688 : :
689 : 3 : r = ordered_hashmap_get(m, "no such key");
690 [ - + ]: 3 : assert_se(r == NULL);
691 : :
692 [ - + ]: 3 : assert_se(m);
693 : 3 : ordered_hashmap_free_free(m);
694 : 3 : }
695 : :
696 : 3 : static void test_ordered_hashmap_get2(void) {
697 : : OrderedHashmap *m;
698 : : char *r;
699 : : char *val;
700 : 3 : char key_orig[] = "Key 1";
701 : : void *key_copy;
702 : :
703 [ + - ]: 3 : log_info("/* %s */", __func__);
704 : :
705 : 3 : val = strdup("my val");
706 [ - + ]: 3 : assert_se(val);
707 : :
708 : 3 : key_copy = strdup(key_orig);
709 [ - + ]: 3 : assert_se(key_copy);
710 : :
711 : 3 : r = ordered_hashmap_get2(NULL, key_orig, &key_copy);
712 [ - + ]: 3 : assert_se(r == NULL);
713 : :
714 : 3 : m = ordered_hashmap_new(&string_hash_ops);
715 : :
716 : 3 : ordered_hashmap_put(m, key_copy, val);
717 : 3 : key_copy = NULL;
718 : :
719 : 3 : r = ordered_hashmap_get2(m, key_orig, &key_copy);
720 [ - + ]: 3 : assert_se(streq(r, val));
721 [ - + ]: 3 : assert_se(key_orig != key_copy);
722 [ - + ]: 3 : assert_se(streq(key_orig, key_copy));
723 : :
724 : 3 : r = ordered_hashmap_get2(m, "no such key", NULL);
725 [ - + ]: 3 : assert_se(r == NULL);
726 : :
727 [ - + ]: 3 : assert_se(m);
728 : 3 : ordered_hashmap_free_free_free(m);
729 : 3 : }
730 : :
731 : 17219690 : static void crippled_ordered_hashmap_func(const void *p, struct siphash *state) {
732 : 17219690 : return trivial_hash_func(INT_TO_PTR(PTR_TO_INT(p) & 0xff), state);
733 : : }
734 : :
735 : : static const struct hash_ops crippled_ordered_hashmap_ops = {
736 : : .hash = crippled_ordered_hashmap_func,
737 : : .compare = trivial_compare_func,
738 : : };
739 : :
740 : 3 : static void test_ordered_hashmap_many(void) {
741 : : OrderedHashmap *h;
742 : : unsigned i, j;
743 : : void *v, *k;
744 : 3 : bool slow = slow_tests_enabled();
745 : : const struct {
746 : : const char *title;
747 : : const struct hash_ops *ops;
748 : : unsigned n_entries;
749 : 9 : } tests[] = {
750 [ + - ]: 3 : { "trivial_ordered_hashmap_ops", NULL, slow ? 1 << 20 : 240 },
751 [ + - ]: 3 : { "crippled_ordered_hashmap_ops", &crippled_ordered_hashmap_ops, slow ? 1 << 14 : 140 },
752 : : };
753 : :
754 [ + - + - ]: 3 : log_info("/* %s (%s) */", __func__, slow ? "slow" : "fast");
755 : :
756 [ + + ]: 9 : for (j = 0; j < ELEMENTSOF(tests); j++) {
757 : 6 : usec_t ts = now(CLOCK_MONOTONIC), n;
758 : : char b[FORMAT_TIMESPAN_MAX];
759 : :
760 [ - + ]: 6 : assert_se(h = ordered_hashmap_new(tests[j].ops));
761 : :
762 [ + + ]: 3194886 : for (i = 1; i < tests[j].n_entries*3; i+=3) {
763 [ - + ]: 3194880 : assert_se(ordered_hashmap_put(h, UINT_TO_PTR(i), UINT_TO_PTR(i)) >= 0);
764 [ - + ]: 3194880 : assert_se(PTR_TO_UINT(ordered_hashmap_get(h, UINT_TO_PTR(i))) == i);
765 : : }
766 : :
767 [ + + ]: 9584640 : for (i = 1; i < tests[j].n_entries*3; i++)
768 [ - + ]: 9584634 : assert_se(ordered_hashmap_contains(h, UINT_TO_PTR(i)) == (i % 3 == 1));
769 : :
770 [ + - ]: 6 : log_info("%s %u <= %u * 0.8 = %g",
771 : : tests[j].title, ordered_hashmap_size(h), ordered_hashmap_buckets(h), ordered_hashmap_buckets(h) * 0.8);
772 : :
773 [ - + ]: 6 : assert_se(ordered_hashmap_size(h) <= ordered_hashmap_buckets(h) * 0.8);
774 [ - + ]: 6 : assert_se(ordered_hashmap_size(h) == tests[j].n_entries);
775 : :
776 [ + + ]: 3194886 : while (!ordered_hashmap_isempty(h)) {
777 : 3194880 : k = ordered_hashmap_first_key(h);
778 : 3194880 : v = ordered_hashmap_remove(h, k);
779 [ - + ]: 3194880 : assert_se(v == k);
780 : : }
781 : :
782 : 6 : ordered_hashmap_free(h);
783 : :
784 : 6 : n = now(CLOCK_MONOTONIC);
785 [ + - ]: 6 : log_info("test took %s", format_timespan(b, sizeof b, n - ts, 0));
786 : : }
787 : 3 : }
788 : :
789 : : extern unsigned custom_counter;
790 : : extern const struct hash_ops boring_hash_ops, custom_hash_ops;
791 : :
792 : 3 : static void test_ordered_hashmap_free(void) {
793 : : OrderedHashmap *h;
794 : 3 : bool slow = slow_tests_enabled();
795 : : usec_t ts, n;
796 : : char b[FORMAT_TIMESPAN_MAX];
797 [ + - ]: 3 : unsigned n_entries = slow ? 1 << 20 : 240;
798 : :
799 : : const struct {
800 : : const char *title;
801 : : const struct hash_ops *ops;
802 : : unsigned expect_counter;
803 : 6 : } tests[] = {
804 : 3 : { "string_hash_ops", &boring_hash_ops, 2 * n_entries},
805 : : { "custom_free_hash_ops", &custom_hash_ops, 0 },
806 : : };
807 : :
808 [ + - + - ]: 3 : log_info("/* %s (%s, %u entries) */", __func__, slow ? "slow" : "fast", n_entries);
809 : :
810 [ + + ]: 9 : for (unsigned j = 0; j < ELEMENTSOF(tests); j++) {
811 : 6 : ts = now(CLOCK_MONOTONIC);
812 [ - + ]: 6 : assert_se(h = ordered_hashmap_new(tests[j].ops));
813 : :
814 : 6 : custom_counter = 0;
815 [ + + ]: 6291462 : for (unsigned i = 0; i < n_entries; i++) {
816 : : char s[DECIMAL_STR_MAX(unsigned)];
817 : : char *k, *v;
818 : :
819 [ - + ]: 6291456 : xsprintf(s, "%u", i);
820 [ - + ]: 6291456 : assert_se(k = strdup(s));
821 [ - + ]: 6291456 : assert_se(v = strdup(s));
822 : 6291456 : custom_counter += 2;
823 : :
824 [ - + ]: 6291456 : assert_se(ordered_hashmap_put(h, k, v) >= 0);
825 : : }
826 : :
827 : 6 : ordered_hashmap_free(h);
828 : :
829 : 6 : n = now(CLOCK_MONOTONIC);
830 [ + - ]: 6 : log_info("%s test took %s", tests[j].title, format_timespan(b, sizeof b, n - ts, 0));
831 : :
832 [ - + ]: 6 : assert_se(custom_counter == tests[j].expect_counter);
833 : : }
834 : 3 : }
835 : :
836 : : typedef struct Item {
837 : : int seen;
838 : : } Item;
839 : 9 : static void item_seen(Item *item) {
840 : 9 : item->seen++;
841 : 9 : }
842 : :
843 : 3 : static void test_ordered_hashmap_free_with_destructor(void) {
844 : : OrderedHashmap *m;
845 : 3 : struct Item items[4] = {};
846 : : unsigned i;
847 : :
848 [ + - ]: 3 : log_info("/* %s */", __func__);
849 : :
850 [ - + ]: 3 : assert_se(m = ordered_hashmap_new(NULL));
851 [ + + ]: 12 : for (i = 0; i < ELEMENTSOF(items) - 1; i++)
852 [ - + ]: 9 : assert_se(ordered_hashmap_put(m, INT_TO_PTR(i), items + i) == 1);
853 : :
854 [ + + ]: 12 : m = ordered_hashmap_free_with_destructor(m, item_seen);
855 [ - + ]: 3 : assert_se(items[0].seen == 1);
856 [ - + ]: 3 : assert_se(items[1].seen == 1);
857 [ - + ]: 3 : assert_se(items[2].seen == 1);
858 [ - + ]: 3 : assert_se(items[3].seen == 0);
859 : 3 : }
860 : :
861 : 3 : static void test_ordered_hashmap_first(void) {
862 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
863 : :
864 [ + - ]: 3 : log_info("/* %s */", __func__);
865 : :
866 : 3 : m = ordered_hashmap_new(&string_hash_ops);
867 [ - + ]: 3 : assert_se(m);
868 : :
869 [ - + ]: 3 : assert_se(!ordered_hashmap_first(m));
870 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, "key 1", (void*) "val 1") == 1);
871 [ - + ]: 3 : assert_se(streq(ordered_hashmap_first(m), "val 1"));
872 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, "key 2", (void*) "val 2") == 1);
873 : : #ifdef ORDERED
874 [ - + ]: 3 : assert_se(streq(ordered_hashmap_first(m), "val 1"));
875 [ - + ]: 3 : assert_se(ordered_hashmap_remove(m, "key 1"));
876 [ - + ]: 3 : assert_se(streq(ordered_hashmap_first(m), "val 2"));
877 : : #endif
878 : 3 : }
879 : :
880 : 3 : static void test_ordered_hashmap_first_key(void) {
881 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
882 : :
883 [ + - ]: 3 : log_info("/* %s */", __func__);
884 : :
885 : 3 : m = ordered_hashmap_new(&string_hash_ops);
886 [ - + ]: 3 : assert_se(m);
887 : :
888 [ - + ]: 3 : assert_se(!ordered_hashmap_first_key(m));
889 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, "key 1", NULL) == 1);
890 [ - + ]: 3 : assert_se(streq(ordered_hashmap_first_key(m), "key 1"));
891 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, "key 2", NULL) == 1);
892 : : #ifdef ORDERED
893 [ - + ]: 3 : assert_se(streq(ordered_hashmap_first_key(m), "key 1"));
894 [ - + ]: 3 : assert_se(ordered_hashmap_remove(m, "key 1") == NULL);
895 [ - + ]: 3 : assert_se(streq(ordered_hashmap_first_key(m), "key 2"));
896 : : #endif
897 : 3 : }
898 : :
899 : 3 : static void test_ordered_hashmap_steal_first_key(void) {
900 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
901 : :
902 [ + - ]: 3 : log_info("/* %s */", __func__);
903 : :
904 : 3 : m = ordered_hashmap_new(&string_hash_ops);
905 [ - + ]: 3 : assert_se(m);
906 : :
907 [ - + ]: 3 : assert_se(!ordered_hashmap_steal_first_key(m));
908 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, "key 1", NULL) == 1);
909 [ - + ]: 3 : assert_se(streq(ordered_hashmap_steal_first_key(m), "key 1"));
910 : :
911 [ - + ]: 3 : assert_se(ordered_hashmap_isempty(m));
912 : 3 : }
913 : :
914 : 3 : static void test_ordered_hashmap_steal_first(void) {
915 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
916 : 3 : int seen[3] = {};
917 : : char *val;
918 : :
919 [ + - ]: 3 : log_info("/* %s */", __func__);
920 : :
921 : 3 : m = ordered_hashmap_new(&string_hash_ops);
922 [ - + ]: 3 : assert_se(m);
923 : :
924 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, "key 1", (void*) "1") == 1);
925 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, "key 2", (void*) "22") == 1);
926 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, "key 3", (void*) "333") == 1);
927 : :
928 [ + + ]: 12 : while ((val = ordered_hashmap_steal_first(m)))
929 : 9 : seen[strlen(val) - 1]++;
930 : :
931 [ + - - + : 3 : assert_se(seen[0] == 1 && seen[1] == 1 && seen[2] == 1);
+ - - + ]
932 : :
933 [ - + ]: 3 : assert_se(ordered_hashmap_isempty(m));
934 : 3 : }
935 : :
936 : 3 : static void test_ordered_hashmap_clear_free_free(void) {
937 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
938 : :
939 [ + - ]: 3 : log_info("/* %s */", __func__);
940 : :
941 : 3 : m = ordered_hashmap_new(&string_hash_ops);
942 [ - + ]: 3 : assert_se(m);
943 : :
944 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, strdup("key 1"), NULL) == 1);
945 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, strdup("key 2"), NULL) == 1);
946 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, strdup("key 3"), NULL) == 1);
947 : :
948 : 3 : ordered_hashmap_clear_free_free(m);
949 [ - + ]: 3 : assert_se(ordered_hashmap_isempty(m));
950 : :
951 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, strdup("key 1"), strdup("value 1")) == 1);
952 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, strdup("key 2"), strdup("value 2")) == 1);
953 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, strdup("key 3"), strdup("value 3")) == 1);
954 : :
955 : 3 : ordered_hashmap_clear_free_free(m);
956 [ - + ]: 3 : assert_se(ordered_hashmap_isempty(m));
957 : 3 : }
958 : :
959 : 9 : DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(test_hash_ops_key, char, string_hash_func, string_compare_func, free);
960 : 18 : DEFINE_PRIVATE_HASH_OPS_FULL(test_hash_ops_full, char, string_hash_func, string_compare_func, free, char, free);
961 : :
962 : 3 : static void test_ordered_hashmap_clear_free_with_destructor(void) {
963 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
964 : :
965 [ + - ]: 3 : log_info("/* %s */", __func__);
966 : :
967 : 3 : m = ordered_hashmap_new(&test_hash_ops_key);
968 [ - + ]: 3 : assert_se(m);
969 : :
970 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, strdup("key 1"), NULL) == 1);
971 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, strdup("key 2"), NULL) == 1);
972 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, strdup("key 3"), NULL) == 1);
973 : :
974 : 3 : ordered_hashmap_clear_free(m);
975 [ - + ]: 3 : assert_se(ordered_hashmap_isempty(m));
976 : 3 : m = ordered_hashmap_free(m);
977 : :
978 : 3 : m = ordered_hashmap_new(&test_hash_ops_full);
979 [ - + ]: 3 : assert_se(m);
980 : :
981 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, strdup("key 1"), strdup("value 1")) == 1);
982 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, strdup("key 2"), strdup("value 2")) == 1);
983 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, strdup("key 3"), strdup("value 3")) == 1);
984 : :
985 : 3 : ordered_hashmap_clear_free(m);
986 [ - + ]: 3 : assert_se(ordered_hashmap_isempty(m));
987 : 3 : }
988 : :
989 : 3 : static void test_ordered_hashmap_reserve(void) {
990 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
991 : :
992 [ + - ]: 3 : log_info("/* %s */", __func__);
993 : :
994 : 3 : m = ordered_hashmap_new(&string_hash_ops);
995 : :
996 [ - + ]: 3 : assert_se(ordered_hashmap_reserve(m, 1) == 0);
997 [ - + ]: 3 : assert_se(ordered_hashmap_buckets(m) < 1000);
998 [ - + ]: 3 : assert_se(ordered_hashmap_reserve(m, 1000) == 0);
999 [ - + ]: 3 : assert_se(ordered_hashmap_buckets(m) >= 1000);
1000 [ - + ]: 3 : assert_se(ordered_hashmap_isempty(m));
1001 : :
1002 [ - + ]: 3 : assert_se(ordered_hashmap_put(m, "key 1", (void*) "val 1") == 1);
1003 : :
1004 [ - + ]: 3 : assert_se(ordered_hashmap_reserve(m, UINT_MAX) == -ENOMEM);
1005 [ - + ]: 3 : assert_se(ordered_hashmap_reserve(m, UINT_MAX - 1) == -ENOMEM);
1006 : 3 : }
1007 : :
1008 : 3 : static void test_path_ordered_hashmap(void) {
1009 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *h = NULL;
1010 : :
1011 [ + - ]: 3 : log_info("/* %s */", __func__);
1012 : :
1013 [ - + ]: 3 : assert_se(h = ordered_hashmap_new(&path_hash_ops));
1014 : :
1015 [ - + ]: 3 : assert_se(ordered_hashmap_put(h, "foo", INT_TO_PTR(1)) >= 0);
1016 [ - + ]: 3 : assert_se(ordered_hashmap_put(h, "/foo", INT_TO_PTR(2)) >= 0);
1017 [ - + ]: 3 : assert_se(ordered_hashmap_put(h, "//foo", INT_TO_PTR(3)) == -EEXIST);
1018 [ - + ]: 3 : assert_se(ordered_hashmap_put(h, "//foox/", INT_TO_PTR(4)) >= 0);
1019 [ - + ]: 3 : assert_se(ordered_hashmap_put(h, "/foox////", INT_TO_PTR(5)) == -EEXIST);
1020 [ - + ]: 3 : assert_se(ordered_hashmap_put(h, "foo//////bar/quux//", INT_TO_PTR(6)) >= 0);
1021 [ - + ]: 3 : assert_se(ordered_hashmap_put(h, "foo/bar//quux/", INT_TO_PTR(8)) == -EEXIST);
1022 : :
1023 [ - + ]: 3 : assert_se(ordered_hashmap_get(h, "foo") == INT_TO_PTR(1));
1024 [ - + ]: 3 : assert_se(ordered_hashmap_get(h, "foo/") == INT_TO_PTR(1));
1025 [ - + ]: 3 : assert_se(ordered_hashmap_get(h, "foo////") == INT_TO_PTR(1));
1026 [ - + ]: 3 : assert_se(ordered_hashmap_get(h, "/foo") == INT_TO_PTR(2));
1027 [ - + ]: 3 : assert_se(ordered_hashmap_get(h, "//foo") == INT_TO_PTR(2));
1028 [ - + ]: 3 : assert_se(ordered_hashmap_get(h, "/////foo////") == INT_TO_PTR(2));
1029 [ - + ]: 3 : assert_se(ordered_hashmap_get(h, "/////foox////") == INT_TO_PTR(4));
1030 [ - + ]: 3 : assert_se(ordered_hashmap_get(h, "/foox/") == INT_TO_PTR(4));
1031 [ - + ]: 3 : assert_se(ordered_hashmap_get(h, "/foox") == INT_TO_PTR(4));
1032 [ - + ]: 3 : assert_se(!ordered_hashmap_get(h, "foox"));
1033 [ - + ]: 3 : assert_se(ordered_hashmap_get(h, "foo/bar/quux") == INT_TO_PTR(6));
1034 [ - + ]: 3 : assert_se(ordered_hashmap_get(h, "foo////bar////quux/////") == INT_TO_PTR(6));
1035 [ - + ]: 3 : assert_se(!ordered_hashmap_get(h, "/foo////bar////quux/////"));
1036 : 3 : }
1037 : :
1038 : 3 : static void test_string_strv_ordered_hashmap(void) {
1039 : 3 : _cleanup_ordered_hashmap_free_ OrderedHashmap *m = NULL;
1040 : : char **s;
1041 : :
1042 [ + - ]: 3 : log_info("/* %s */", __func__);
1043 : :
1044 [ - + ]: 3 : assert_se(string_strv_ordered_hashmap_put(&m, "foo", "bar") == 1);
1045 [ - + ]: 3 : assert_se(string_strv_ordered_hashmap_put(&m, "foo", "bar") == 0);
1046 [ - + ]: 3 : assert_se(string_strv_ordered_hashmap_put(&m, "foo", "BAR") == 1);
1047 [ - + ]: 3 : assert_se(string_strv_ordered_hashmap_put(&m, "foo", "BAR") == 0);
1048 [ - + ]: 3 : assert_se(string_strv_ordered_hashmap_put(&m, "foo", "bar") == 0);
1049 [ - + ]: 3 : assert_se(ordered_hashmap_contains(m, "foo"));
1050 : :
1051 : 3 : s = ordered_hashmap_get(m, "foo");
1052 [ - + ]: 3 : assert_se(strv_equal(s, STRV_MAKE("bar", "BAR")));
1053 : :
1054 [ - + ]: 3 : assert_se(string_strv_ordered_hashmap_put(&m, "xxx", "bar") == 1);
1055 [ - + ]: 3 : assert_se(string_strv_ordered_hashmap_put(&m, "xxx", "bar") == 0);
1056 [ - + ]: 3 : assert_se(string_strv_ordered_hashmap_put(&m, "xxx", "BAR") == 1);
1057 [ - + ]: 3 : assert_se(string_strv_ordered_hashmap_put(&m, "xxx", "BAR") == 0);
1058 [ - + ]: 3 : assert_se(string_strv_ordered_hashmap_put(&m, "xxx", "bar") == 0);
1059 [ - + ]: 3 : assert_se(ordered_hashmap_contains(m, "xxx"));
1060 : :
1061 : 3 : s = ordered_hashmap_get(m, "xxx");
1062 [ - + ]: 3 : assert_se(strv_equal(s, STRV_MAKE("bar", "BAR")));
1063 : 3 : }
1064 : :
1065 : 3 : void test_ordered_hashmap_funcs(void) {
1066 [ + - ]: 3 : log_info("/************ %s ************/", __func__);
1067 : :
1068 : 3 : test_ordered_hashmap_copy();
1069 : 3 : test_ordered_hashmap_get_strv();
1070 : 3 : test_ordered_hashmap_move_one();
1071 : 3 : test_ordered_hashmap_move();
1072 : 3 : test_ordered_hashmap_replace();
1073 : 3 : test_ordered_hashmap_update();
1074 : 3 : test_ordered_hashmap_put();
1075 : 3 : test_ordered_hashmap_remove();
1076 : 3 : test_ordered_hashmap_remove2();
1077 : 3 : test_ordered_hashmap_remove_value();
1078 : 3 : test_ordered_hashmap_remove_and_put();
1079 : 3 : test_ordered_hashmap_remove_and_replace();
1080 : 3 : test_ordered_hashmap_ensure_allocated();
1081 : 3 : test_ordered_hashmap_foreach();
1082 : 3 : test_ordered_hashmap_foreach_key();
1083 : 3 : test_ordered_hashmap_contains();
1084 : 3 : test_ordered_hashmap_merge();
1085 : 3 : test_ordered_hashmap_isempty();
1086 : 3 : test_ordered_hashmap_get();
1087 : 3 : test_ordered_hashmap_get2();
1088 : 3 : test_ordered_hashmap_size();
1089 : 3 : test_ordered_hashmap_many();
1090 : 3 : test_ordered_hashmap_free();
1091 : 3 : test_ordered_hashmap_free_with_destructor();
1092 : 3 : test_ordered_hashmap_first();
1093 : 3 : test_ordered_hashmap_first_key();
1094 : 3 : test_ordered_hashmap_steal_first_key();
1095 : 3 : test_ordered_hashmap_steal_first();
1096 : 3 : test_ordered_hashmap_clear_free_free();
1097 : 3 : test_ordered_hashmap_clear_free_with_destructor();
1098 : 3 : test_ordered_hashmap_reserve();
1099 : 3 : test_path_ordered_hashmap();
1100 : 3 : test_string_strv_ordered_hashmap();
1101 : 3 : }
|
