2 * Unit-tests for Block layer QDict extras
4 * Copyright (c) 2013-2018 Red Hat, Inc.
6 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
7 * See the COPYING.LIB file in the top-level directory.
10 #include "qemu/osdep.h"
11 #include "block/qdict.h"
12 #include "qapi/qmp/qlist.h"
13 #include "qapi/qmp/qnum.h"
14 #include "qapi/error.h"
16 static void qdict_defaults_test(void)
23 qdict_set_default_str(dict
, "foo", "abc");
24 qdict_set_default_str(dict
, "foo", "def");
25 g_assert_cmpstr(qdict_get_str(dict
, "foo"), ==, "abc");
26 qdict_set_default_str(dict
, "bar", "ghi");
28 qdict_copy_default(copy
, dict
, "foo");
29 g_assert_cmpstr(qdict_get_str(copy
, "foo"), ==, "abc");
30 qdict_set_default_str(copy
, "bar", "xyz");
31 qdict_copy_default(copy
, dict
, "bar");
32 g_assert_cmpstr(qdict_get_str(copy
, "bar"), ==, "xyz");
38 static void qdict_flatten_test(void)
40 QList
*e_1
= qlist_new();
41 QList
*e
= qlist_new();
42 QDict
*e_1_2
= qdict_new();
43 QDict
*f
= qdict_new();
44 QList
*y
= qlist_new();
45 QDict
*z
= qdict_new();
46 QDict
*root
= qdict_new();
49 * Test the flattening of
88 qdict_put_int(e_1_2
, "a", 0);
89 qdict_put_int(e_1_2
, "b", 1);
91 qlist_append_int(e_1
, 23);
92 qlist_append_int(e_1
, 66);
93 qlist_append(e_1
, e_1_2
);
94 qlist_append_int(e
, 42);
97 qdict_put_int(f
, "c", 2);
98 qdict_put_int(f
, "d", 3);
100 qlist_append(y
, qdict_new());
102 qdict_put(z
, "a", qlist_new());
104 qdict_put(root
, "e", e
);
105 qdict_put(root
, "f", f
);
106 qdict_put_int(root
, "g", 4);
107 qdict_put(root
, "y", y
);
108 qdict_put(root
, "z", z
);
112 g_assert(qdict_get_int(root
, "e.0") == 42);
113 g_assert(qdict_get_int(root
, "e.1.0") == 23);
114 g_assert(qdict_get_int(root
, "e.1.1") == 66);
115 g_assert(qdict_get_int(root
, "e.1.2.a") == 0);
116 g_assert(qdict_get_int(root
, "e.1.2.b") == 1);
117 g_assert(qdict_get_int(root
, "f.c") == 2);
118 g_assert(qdict_get_int(root
, "f.d") == 3);
119 g_assert(qdict_get_int(root
, "g") == 4);
120 g_assert(!qdict_size(qdict_get_qdict(root
, "y.0")));
121 g_assert(qlist_empty(qdict_get_qlist(root
, "z.a")));
123 g_assert(qdict_size(root
) == 10);
128 static void qdict_array_split_test(void)
130 QDict
*test_dict
= qdict_new();
131 QDict
*dict1
, *dict2
;
167 * (remaining in the old QDict)
169 * This example is given in the comment of qdict_array_split().
172 qdict_put_int(test_dict
, "1.x", 0);
173 qdict_put_int(test_dict
, "4.y", 1);
174 qdict_put_int(test_dict
, "0.a", 42);
175 qdict_put_int(test_dict
, "o.o", 7);
176 qdict_put_int(test_dict
, "0.b", 23);
177 qdict_put_int(test_dict
, "2", 66);
179 qdict_array_split(test_dict
, &test_list
);
181 dict1
= qobject_to(QDict
, qlist_pop(test_list
));
182 dict2
= qobject_to(QDict
, qlist_pop(test_list
));
183 int1
= qobject_to(QNum
, qlist_pop(test_list
));
188 g_assert(qlist_empty(test_list
));
190 qobject_unref(test_list
);
192 g_assert(qdict_get_int(dict1
, "a") == 42);
193 g_assert(qdict_get_int(dict1
, "b") == 23);
195 g_assert(qdict_size(dict1
) == 2);
197 qobject_unref(dict1
);
199 g_assert(qdict_get_int(dict2
, "x") == 0);
201 g_assert(qdict_size(dict2
) == 1);
203 qobject_unref(dict2
);
205 g_assert_cmpint(qnum_get_int(int1
), ==, 66);
209 g_assert(qdict_get_int(test_dict
, "4.y") == 1);
210 g_assert(qdict_get_int(test_dict
, "o.o") == 7);
212 g_assert(qdict_size(test_dict
) == 2);
214 qobject_unref(test_dict
);
238 * That is, test whether splitting stops if there is both an entry with key
239 * of "%u" and other entries with keys prefixed "%u." for the same index.
242 test_dict
= qdict_new();
244 qdict_put_int(test_dict
, "0", 42);
245 qdict_put_int(test_dict
, "1", 23);
246 qdict_put_int(test_dict
, "1.x", 84);
248 qdict_array_split(test_dict
, &test_list
);
250 int1
= qobject_to(QNum
, qlist_pop(test_list
));
253 g_assert(qlist_empty(test_list
));
255 qobject_unref(test_list
);
257 g_assert_cmpint(qnum_get_int(int1
), ==, 42);
261 g_assert(qdict_get_int(test_dict
, "1") == 23);
262 g_assert(qdict_get_int(test_dict
, "1.x") == 84);
264 g_assert(qdict_size(test_dict
) == 2);
266 qobject_unref(test_dict
);
269 static void qdict_array_entries_test(void)
271 QDict
*dict
= qdict_new();
273 g_assert_cmpint(qdict_array_entries(dict
, "foo."), ==, 0);
275 qdict_put_int(dict
, "bar", 0);
276 qdict_put_int(dict
, "baz.0", 0);
277 g_assert_cmpint(qdict_array_entries(dict
, "foo."), ==, 0);
279 qdict_put_int(dict
, "foo.1", 0);
280 g_assert_cmpint(qdict_array_entries(dict
, "foo."), ==, -EINVAL
);
281 qdict_put_int(dict
, "foo.0", 0);
282 g_assert_cmpint(qdict_array_entries(dict
, "foo."), ==, 2);
283 qdict_put_int(dict
, "foo.bar", 0);
284 g_assert_cmpint(qdict_array_entries(dict
, "foo."), ==, -EINVAL
);
285 qdict_del(dict
, "foo.bar");
287 qdict_put_int(dict
, "foo.2.a", 0);
288 qdict_put_int(dict
, "foo.2.b", 0);
289 qdict_put_int(dict
, "foo.2.c", 0);
290 g_assert_cmpint(qdict_array_entries(dict
, "foo."), ==, 3);
291 g_assert_cmpint(qdict_array_entries(dict
, ""), ==, -EINVAL
);
296 qdict_put_int(dict
, "1", 0);
297 g_assert_cmpint(qdict_array_entries(dict
, ""), ==, -EINVAL
);
298 qdict_put_int(dict
, "0", 0);
299 g_assert_cmpint(qdict_array_entries(dict
, ""), ==, 2);
300 qdict_put_int(dict
, "bar", 0);
301 g_assert_cmpint(qdict_array_entries(dict
, ""), ==, -EINVAL
);
302 qdict_del(dict
, "bar");
304 qdict_put_int(dict
, "2.a", 0);
305 qdict_put_int(dict
, "2.b", 0);
306 qdict_put_int(dict
, "2.c", 0);
307 g_assert_cmpint(qdict_array_entries(dict
, ""), ==, 3);
312 static void qdict_join_test(void)
314 QDict
*dict1
, *dict2
;
315 bool overwrite
= false;
321 /* Test everything once without overwrite and once with */
323 /* Test empty dicts */
324 qdict_join(dict1
, dict2
, overwrite
);
326 g_assert(qdict_size(dict1
) == 0);
327 g_assert(qdict_size(dict2
) == 0);
329 /* First iteration: Test movement */
330 /* Second iteration: Test empty source and non-empty destination */
331 qdict_put_int(dict2
, "foo", 42);
333 for (i
= 0; i
< 2; i
++) {
334 qdict_join(dict1
, dict2
, overwrite
);
336 g_assert(qdict_size(dict1
) == 1);
337 g_assert(qdict_size(dict2
) == 0);
339 g_assert(qdict_get_int(dict1
, "foo") == 42);
342 /* Test non-empty source and destination without conflict */
343 qdict_put_int(dict2
, "bar", 23);
345 qdict_join(dict1
, dict2
, overwrite
);
347 g_assert(qdict_size(dict1
) == 2);
348 g_assert(qdict_size(dict2
) == 0);
350 g_assert(qdict_get_int(dict1
, "foo") == 42);
351 g_assert(qdict_get_int(dict1
, "bar") == 23);
354 qdict_put_int(dict2
, "foo", 84);
356 qdict_join(dict1
, dict2
, overwrite
);
358 g_assert(qdict_size(dict1
) == 2);
359 g_assert(qdict_size(dict2
) == !overwrite
);
361 g_assert(qdict_get_int(dict1
, "foo") == (overwrite
? 84 : 42));
362 g_assert(qdict_get_int(dict1
, "bar") == 23);
365 g_assert(qdict_get_int(dict2
, "foo") == 84);
368 /* Check the references */
369 g_assert(qdict_get(dict1
, "foo")->base
.refcnt
== 1);
370 g_assert(qdict_get(dict1
, "bar")->base
.refcnt
== 1);
373 g_assert(qdict_get(dict2
, "foo")->base
.refcnt
== 1);
377 qdict_del(dict1
, "foo");
378 qdict_del(dict1
, "bar");
381 qdict_del(dict2
, "foo");
383 } while (overwrite
^= true);
385 qobject_unref(dict1
);
386 qobject_unref(dict2
);
389 static void qdict_crumple_test_recursive(void)
391 QDict
*src
, *dst
, *rule
, *vnc
, *acl
, *listen
;
392 QDict
*empty
, *empty_dict
, *empty_list_0
;
393 QList
*rules
, *empty_list
, *empty_dict_a
;
396 qdict_put_str(src
, "vnc.listen.addr", "127.0.0.1");
397 qdict_put_str(src
, "vnc.listen.port", "5901");
398 qdict_put_str(src
, "vnc.acl.rules.0.match", "fred");
399 qdict_put_str(src
, "vnc.acl.rules.0.policy", "allow");
400 qdict_put_str(src
, "vnc.acl.rules.1.match", "bob");
401 qdict_put_str(src
, "vnc.acl.rules.1.policy", "deny");
402 qdict_put_str(src
, "vnc.acl.default", "deny");
403 qdict_put_str(src
, "vnc.acl..name", "acl0");
404 qdict_put_str(src
, "vnc.acl.rule..name", "acl0");
405 qdict_put(src
, "empty.dict.a", qlist_new());
406 qdict_put(src
, "empty.list.0", qdict_new());
408 dst
= qobject_to(QDict
, qdict_crumple(src
, &error_abort
));
410 g_assert_cmpint(qdict_size(dst
), ==, 2);
412 vnc
= qdict_get_qdict(dst
, "vnc");
414 g_assert_cmpint(qdict_size(vnc
), ==, 3);
416 listen
= qdict_get_qdict(vnc
, "listen");
418 g_assert_cmpint(qdict_size(listen
), ==, 2);
419 g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(listen
, "addr"));
420 g_assert_cmpstr("5901", ==, qdict_get_str(listen
, "port"));
422 acl
= qdict_get_qdict(vnc
, "acl");
424 g_assert_cmpint(qdict_size(acl
), ==, 3);
426 rules
= qdict_get_qlist(acl
, "rules");
428 g_assert_cmpint(qlist_size(rules
), ==, 2);
430 rule
= qobject_to(QDict
, qlist_pop(rules
));
432 g_assert_cmpint(qdict_size(rule
), ==, 2);
433 g_assert_cmpstr("fred", ==, qdict_get_str(rule
, "match"));
434 g_assert_cmpstr("allow", ==, qdict_get_str(rule
, "policy"));
437 rule
= qobject_to(QDict
, qlist_pop(rules
));
439 g_assert_cmpint(qdict_size(rule
), ==, 2);
440 g_assert_cmpstr("bob", ==, qdict_get_str(rule
, "match"));
441 g_assert_cmpstr("deny", ==, qdict_get_str(rule
, "policy"));
444 /* With recursive crumpling, we should see all names unescaped */
445 g_assert_cmpstr("acl0", ==, qdict_get_str(vnc
, "acl.name"));
446 g_assert_cmpstr("acl0", ==, qdict_get_str(acl
, "rule.name"));
448 empty
= qdict_get_qdict(dst
, "empty");
450 g_assert_cmpint(qdict_size(empty
), ==, 2);
451 empty_dict
= qdict_get_qdict(empty
, "dict");
452 g_assert(empty_dict
);
453 g_assert_cmpint(qdict_size(empty_dict
), ==, 1);
454 empty_dict_a
= qdict_get_qlist(empty_dict
, "a");
455 g_assert(empty_dict_a
&& qlist_empty(empty_dict_a
));
456 empty_list
= qdict_get_qlist(empty
, "list");
457 g_assert(empty_list
);
458 g_assert_cmpint(qlist_size(empty_list
), ==, 1);
459 empty_list_0
= qobject_to(QDict
, qlist_pop(empty_list
));
460 g_assert(empty_list_0
);
461 g_assert_cmpint(qdict_size(empty_list_0
), ==, 0);
467 static void qdict_crumple_test_empty(void)
473 dst
= qobject_to(QDict
, qdict_crumple(src
, &error_abort
));
475 g_assert_cmpint(qdict_size(dst
), ==, 0);
481 static int qdict_count_entries(QDict
*dict
)
486 for (e
= qdict_first(dict
); e
; e
= qdict_next(dict
, e
)) {
493 static void qdict_rename_keys_test(void)
495 QDict
*dict
= qdict_new();
497 QDictRenames
*renames
;
498 Error
*local_err
= NULL
;
500 qdict_put_str(dict
, "abc", "foo");
501 qdict_put_str(dict
, "abcdef", "bar");
502 qdict_put_int(dict
, "number", 42);
503 qdict_put_bool(dict
, "flag", true);
504 qdict_put_null(dict
, "nothing");
506 /* Empty rename list */
507 renames
= (QDictRenames
[]) {
508 { NULL
, "this can be anything" }
510 copy
= qdict_clone_shallow(dict
);
511 qdict_rename_keys(copy
, renames
, &error_abort
);
513 g_assert_cmpstr(qdict_get_str(copy
, "abc"), ==, "foo");
514 g_assert_cmpstr(qdict_get_str(copy
, "abcdef"), ==, "bar");
515 g_assert_cmpint(qdict_get_int(copy
, "number"), ==, 42);
516 g_assert_cmpint(qdict_get_bool(copy
, "flag"), ==, true);
517 g_assert(qobject_type(qdict_get(copy
, "nothing")) == QTYPE_QNULL
);
518 g_assert_cmpint(qdict_count_entries(copy
), ==, 5);
522 /* Simple rename of all entries */
523 renames
= (QDictRenames
[]) {
525 { "abcdef", "str2" },
528 { "nothing", "null" },
531 copy
= qdict_clone_shallow(dict
);
532 qdict_rename_keys(copy
, renames
, &error_abort
);
534 g_assert(!qdict_haskey(copy
, "abc"));
535 g_assert(!qdict_haskey(copy
, "abcdef"));
536 g_assert(!qdict_haskey(copy
, "number"));
537 g_assert(!qdict_haskey(copy
, "flag"));
538 g_assert(!qdict_haskey(copy
, "nothing"));
540 g_assert_cmpstr(qdict_get_str(copy
, "str1"), ==, "foo");
541 g_assert_cmpstr(qdict_get_str(copy
, "str2"), ==, "bar");
542 g_assert_cmpint(qdict_get_int(copy
, "int"), ==, 42);
543 g_assert_cmpint(qdict_get_bool(copy
, "bool"), ==, true);
544 g_assert(qobject_type(qdict_get(copy
, "null")) == QTYPE_QNULL
);
545 g_assert_cmpint(qdict_count_entries(copy
), ==, 5);
549 /* Renames are processed top to bottom */
550 renames
= (QDictRenames
[]) {
553 { "number", "abcdef" },
554 { "flag", "number" },
555 { "nothing", "flag" },
556 { "tmp", "nothing" },
559 copy
= qdict_clone_shallow(dict
);
560 qdict_rename_keys(copy
, renames
, &error_abort
);
562 g_assert_cmpstr(qdict_get_str(copy
, "nothing"), ==, "foo");
563 g_assert_cmpstr(qdict_get_str(copy
, "abc"), ==, "bar");
564 g_assert_cmpint(qdict_get_int(copy
, "abcdef"), ==, 42);
565 g_assert_cmpint(qdict_get_bool(copy
, "number"), ==, true);
566 g_assert(qobject_type(qdict_get(copy
, "flag")) == QTYPE_QNULL
);
567 g_assert(!qdict_haskey(copy
, "tmp"));
568 g_assert_cmpint(qdict_count_entries(copy
), ==, 5);
572 /* Conflicting rename */
573 renames
= (QDictRenames
[]) {
577 copy
= qdict_clone_shallow(dict
);
578 qdict_rename_keys(copy
, renames
, &local_err
);
580 g_assert(local_err
!= NULL
);
581 error_free(local_err
);
584 g_assert_cmpstr(qdict_get_str(copy
, "abc"), ==, "foo");
585 g_assert_cmpstr(qdict_get_str(copy
, "abcdef"), ==, "bar");
586 g_assert_cmpint(qdict_get_int(copy
, "number"), ==, 42);
587 g_assert_cmpint(qdict_get_bool(copy
, "flag"), ==, true);
588 g_assert(qobject_type(qdict_get(copy
, "nothing")) == QTYPE_QNULL
);
589 g_assert_cmpint(qdict_count_entries(copy
), ==, 5);
593 /* Renames in an empty dict */
594 renames
= (QDictRenames
[]) {
602 qdict_rename_keys(dict
, renames
, &error_abort
);
603 g_assert(qdict_first(dict
) == NULL
);
608 static void qdict_crumple_test_bad_inputs(void)
614 /* rule.0 can't be both a string and a dict */
615 qdict_put_str(src
, "rule.0", "fred");
616 qdict_put_str(src
, "rule.0.policy", "allow");
618 g_assert(qdict_crumple(src
, &error
) == NULL
);
619 g_assert(error
!= NULL
);
625 /* rule can't be both a list and a dict */
626 qdict_put_str(src
, "rule.0", "fred");
627 qdict_put_str(src
, "rule.a", "allow");
629 g_assert(qdict_crumple(src
, &error
) == NULL
);
630 g_assert(error
!= NULL
);
636 /* The input should be flat, ie no dicts or lists */
637 nested
= qdict_new();
638 qdict_put(nested
, "x", qdict_new());
639 qdict_put(src
, "rule.a", nested
);
640 qdict_put_str(src
, "rule.b", "allow");
642 g_assert(qdict_crumple(src
, &error
) == NULL
);
643 g_assert(error
!= NULL
);
649 /* List indexes must not have gaps */
650 qdict_put_str(src
, "rule.0", "deny");
651 qdict_put_str(src
, "rule.3", "allow");
653 g_assert(qdict_crumple(src
, &error
) == NULL
);
654 g_assert(error
!= NULL
);
660 /* List indexes must be in %zu format */
661 qdict_put_str(src
, "rule.0", "deny");
662 qdict_put_str(src
, "rule.+1", "allow");
664 g_assert(qdict_crumple(src
, &error
) == NULL
);
665 g_assert(error
!= NULL
);
671 int main(int argc
, char **argv
)
673 g_test_init(&argc
, &argv
, NULL
);
675 g_test_add_func("/public/defaults", qdict_defaults_test
);
676 g_test_add_func("/public/flatten", qdict_flatten_test
);
677 g_test_add_func("/public/array_split", qdict_array_split_test
);
678 g_test_add_func("/public/array_entries", qdict_array_entries_test
);
679 g_test_add_func("/public/join", qdict_join_test
);
680 g_test_add_func("/public/crumple/recursive",
681 qdict_crumple_test_recursive
);
682 g_test_add_func("/public/crumple/empty",
683 qdict_crumple_test_empty
);
684 g_test_add_func("/public/crumple/bad_inputs",
685 qdict_crumple_test_bad_inputs
);
687 g_test_add_func("/public/rename_keys", qdict_rename_keys_test
);