rtl8139: remove duplicate net/eth.h definitions
[qemu/ar7.git] / tests / check-qdict.c
bloba136f2addf2917a20d78d5eff0293bbfbaabeee1
1 /*
2 * QDict unit-tests.
4 * Copyright (C) 2009 Red Hat Inc.
6 * Authors:
7 * Luiz Capitulino <lcapitulino@redhat.com>
9 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
10 * See the COPYING.LIB file in the top-level directory.
12 #include <glib.h>
14 #include "qapi/qmp/qint.h"
15 #include "qapi/qmp/qdict.h"
16 #include "qapi/qmp/qstring.h"
17 #include "qemu-common.h"
20 * Public Interface test-cases
22 * (with some violations to access 'private' data)
25 static void qdict_new_test(void)
27 QDict *qdict;
29 qdict = qdict_new();
30 g_assert(qdict != NULL);
31 g_assert(qdict_size(qdict) == 0);
32 g_assert(qdict->base.refcnt == 1);
33 g_assert(qobject_type(QOBJECT(qdict)) == QTYPE_QDICT);
35 // destroy doesn't exit yet
36 g_free(qdict);
39 static void qdict_put_obj_test(void)
41 QInt *qi;
42 QDict *qdict;
43 QDictEntry *ent;
44 const int num = 42;
46 qdict = qdict_new();
48 // key "" will have tdb hash 12345
49 qdict_put_obj(qdict, "", QOBJECT(qint_from_int(num)));
51 g_assert(qdict_size(qdict) == 1);
52 ent = QLIST_FIRST(&qdict->table[12345 % QDICT_BUCKET_MAX]);
53 qi = qobject_to_qint(ent->value);
54 g_assert(qint_get_int(qi) == num);
56 // destroy doesn't exit yet
57 QDECREF(qi);
58 g_free(ent->key);
59 g_free(ent);
60 g_free(qdict);
63 static void qdict_destroy_simple_test(void)
65 QDict *qdict;
67 qdict = qdict_new();
68 qdict_put_obj(qdict, "num", QOBJECT(qint_from_int(0)));
69 qdict_put_obj(qdict, "str", QOBJECT(qstring_from_str("foo")));
71 QDECREF(qdict);
74 static void qdict_get_test(void)
76 QInt *qi;
77 QObject *obj;
78 const int value = -42;
79 const char *key = "test";
80 QDict *tests_dict = qdict_new();
82 qdict_put(tests_dict, key, qint_from_int(value));
84 obj = qdict_get(tests_dict, key);
85 g_assert(obj != NULL);
87 qi = qobject_to_qint(obj);
88 g_assert(qint_get_int(qi) == value);
90 QDECREF(tests_dict);
93 static void qdict_get_int_test(void)
95 int ret;
96 const int value = 100;
97 const char *key = "int";
98 QDict *tests_dict = qdict_new();
100 qdict_put(tests_dict, key, qint_from_int(value));
102 ret = qdict_get_int(tests_dict, key);
103 g_assert(ret == value);
105 QDECREF(tests_dict);
108 static void qdict_get_try_int_test(void)
110 int ret;
111 const int value = 100;
112 const char *key = "int";
113 QDict *tests_dict = qdict_new();
115 qdict_put(tests_dict, key, qint_from_int(value));
117 ret = qdict_get_try_int(tests_dict, key, 0);
118 g_assert(ret == value);
120 QDECREF(tests_dict);
123 static void qdict_get_str_test(void)
125 const char *p;
126 const char *key = "key";
127 const char *str = "string";
128 QDict *tests_dict = qdict_new();
130 qdict_put(tests_dict, key, qstring_from_str(str));
132 p = qdict_get_str(tests_dict, key);
133 g_assert(p != NULL);
134 g_assert(strcmp(p, str) == 0);
136 QDECREF(tests_dict);
139 static void qdict_get_try_str_test(void)
141 const char *p;
142 const char *key = "key";
143 const char *str = "string";
144 QDict *tests_dict = qdict_new();
146 qdict_put(tests_dict, key, qstring_from_str(str));
148 p = qdict_get_try_str(tests_dict, key);
149 g_assert(p != NULL);
150 g_assert(strcmp(p, str) == 0);
152 QDECREF(tests_dict);
155 static void qdict_defaults_test(void)
157 QDict *dict, *copy;
159 dict = qdict_new();
160 copy = qdict_new();
162 qdict_set_default_str(dict, "foo", "abc");
163 qdict_set_default_str(dict, "foo", "def");
164 g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "abc");
165 qdict_set_default_str(dict, "bar", "ghi");
167 qdict_copy_default(copy, dict, "foo");
168 g_assert_cmpstr(qdict_get_str(copy, "foo"), ==, "abc");
169 qdict_set_default_str(copy, "bar", "xyz");
170 qdict_copy_default(copy, dict, "bar");
171 g_assert_cmpstr(qdict_get_str(copy, "bar"), ==, "xyz");
173 QDECREF(copy);
174 QDECREF(dict);
177 static void qdict_haskey_not_test(void)
179 QDict *tests_dict = qdict_new();
180 g_assert(qdict_haskey(tests_dict, "test") == 0);
182 QDECREF(tests_dict);
185 static void qdict_haskey_test(void)
187 const char *key = "test";
188 QDict *tests_dict = qdict_new();
190 qdict_put(tests_dict, key, qint_from_int(0));
191 g_assert(qdict_haskey(tests_dict, key) == 1);
193 QDECREF(tests_dict);
196 static void qdict_del_test(void)
198 const char *key = "key test";
199 QDict *tests_dict = qdict_new();
201 qdict_put(tests_dict, key, qstring_from_str("foo"));
202 g_assert(qdict_size(tests_dict) == 1);
204 qdict_del(tests_dict, key);
206 g_assert(qdict_size(tests_dict) == 0);
207 g_assert(qdict_haskey(tests_dict, key) == 0);
209 QDECREF(tests_dict);
212 static void qobject_to_qdict_test(void)
214 QDict *tests_dict = qdict_new();
215 g_assert(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);
217 QDECREF(tests_dict);
220 static void qdict_iterapi_test(void)
222 int count;
223 const QDictEntry *ent;
224 QDict *tests_dict = qdict_new();
226 g_assert(qdict_first(tests_dict) == NULL);
228 qdict_put(tests_dict, "key1", qint_from_int(1));
229 qdict_put(tests_dict, "key2", qint_from_int(2));
230 qdict_put(tests_dict, "key3", qint_from_int(3));
232 count = 0;
233 for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
234 g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
235 count++;
238 g_assert(count == qdict_size(tests_dict));
240 /* Do it again to test restarting */
241 count = 0;
242 for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
243 g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
244 count++;
247 g_assert(count == qdict_size(tests_dict));
249 QDECREF(tests_dict);
252 static void qdict_flatten_test(void)
254 QList *list1 = qlist_new();
255 QList *list2 = qlist_new();
256 QDict *dict1 = qdict_new();
257 QDict *dict2 = qdict_new();
258 QDict *dict3 = qdict_new();
261 * Test the flattening of
264 * "e": [
265 * 42,
267 * 23,
268 * 66,
270 * "a": 0,
271 * "b": 1
274 * ],
275 * "f": {
276 * "c": 2,
277 * "d": 3,
278 * },
279 * "g": 4
282 * to
285 * "e.0": 42,
286 * "e.1.0": 23,
287 * "e.1.1": 66,
288 * "e.1.2.a": 0,
289 * "e.1.2.b": 1,
290 * "f.c": 2,
291 * "f.d": 3,
292 * "g": 4
296 qdict_put(dict1, "a", qint_from_int(0));
297 qdict_put(dict1, "b", qint_from_int(1));
299 qlist_append_obj(list1, QOBJECT(qint_from_int(23)));
300 qlist_append_obj(list1, QOBJECT(qint_from_int(66)));
301 qlist_append_obj(list1, QOBJECT(dict1));
302 qlist_append_obj(list2, QOBJECT(qint_from_int(42)));
303 qlist_append_obj(list2, QOBJECT(list1));
305 qdict_put(dict2, "c", qint_from_int(2));
306 qdict_put(dict2, "d", qint_from_int(3));
307 qdict_put_obj(dict3, "e", QOBJECT(list2));
308 qdict_put_obj(dict3, "f", QOBJECT(dict2));
309 qdict_put(dict3, "g", qint_from_int(4));
311 qdict_flatten(dict3);
313 g_assert(qdict_get_int(dict3, "e.0") == 42);
314 g_assert(qdict_get_int(dict3, "e.1.0") == 23);
315 g_assert(qdict_get_int(dict3, "e.1.1") == 66);
316 g_assert(qdict_get_int(dict3, "e.1.2.a") == 0);
317 g_assert(qdict_get_int(dict3, "e.1.2.b") == 1);
318 g_assert(qdict_get_int(dict3, "f.c") == 2);
319 g_assert(qdict_get_int(dict3, "f.d") == 3);
320 g_assert(qdict_get_int(dict3, "g") == 4);
322 g_assert(qdict_size(dict3) == 8);
324 QDECREF(dict3);
327 static void qdict_array_split_test(void)
329 QDict *test_dict = qdict_new();
330 QDict *dict1, *dict2;
331 QInt *int1;
332 QList *test_list;
335 * Test the split of
338 * "1.x": 0,
339 * "4.y": 1,
340 * "0.a": 42,
341 * "o.o": 7,
342 * "0.b": 23,
343 * "2": 66
346 * to
350 * "a": 42,
351 * "b": 23
352 * },
354 * "x": 0
355 * },
356 * 66
359 * and
362 * "4.y": 1,
363 * "o.o": 7
366 * (remaining in the old QDict)
368 * This example is given in the comment of qdict_array_split().
371 qdict_put(test_dict, "1.x", qint_from_int(0));
372 qdict_put(test_dict, "4.y", qint_from_int(1));
373 qdict_put(test_dict, "0.a", qint_from_int(42));
374 qdict_put(test_dict, "o.o", qint_from_int(7));
375 qdict_put(test_dict, "0.b", qint_from_int(23));
376 qdict_put(test_dict, "2", qint_from_int(66));
378 qdict_array_split(test_dict, &test_list);
380 dict1 = qobject_to_qdict(qlist_pop(test_list));
381 dict2 = qobject_to_qdict(qlist_pop(test_list));
382 int1 = qobject_to_qint(qlist_pop(test_list));
384 g_assert(dict1);
385 g_assert(dict2);
386 g_assert(int1);
387 g_assert(qlist_empty(test_list));
389 QDECREF(test_list);
391 g_assert(qdict_get_int(dict1, "a") == 42);
392 g_assert(qdict_get_int(dict1, "b") == 23);
394 g_assert(qdict_size(dict1) == 2);
396 QDECREF(dict1);
398 g_assert(qdict_get_int(dict2, "x") == 0);
400 g_assert(qdict_size(dict2) == 1);
402 QDECREF(dict2);
404 g_assert(qint_get_int(int1) == 66);
406 QDECREF(int1);
408 g_assert(qdict_get_int(test_dict, "4.y") == 1);
409 g_assert(qdict_get_int(test_dict, "o.o") == 7);
411 g_assert(qdict_size(test_dict) == 2);
413 QDECREF(test_dict);
417 * Test the split of
420 * "0": 42,
421 * "1": 23,
422 * "1.x": 84
425 * to
428 * 42
431 * and
434 * "1": 23,
435 * "1.x": 84
438 * That is, test whether splitting stops if there is both an entry with key
439 * of "%u" and other entries with keys prefixed "%u." for the same index.
442 test_dict = qdict_new();
444 qdict_put(test_dict, "0", qint_from_int(42));
445 qdict_put(test_dict, "1", qint_from_int(23));
446 qdict_put(test_dict, "1.x", qint_from_int(84));
448 qdict_array_split(test_dict, &test_list);
450 int1 = qobject_to_qint(qlist_pop(test_list));
452 g_assert(int1);
453 g_assert(qlist_empty(test_list));
455 QDECREF(test_list);
457 g_assert(qint_get_int(int1) == 42);
459 QDECREF(int1);
461 g_assert(qdict_get_int(test_dict, "1") == 23);
462 g_assert(qdict_get_int(test_dict, "1.x") == 84);
464 g_assert(qdict_size(test_dict) == 2);
466 QDECREF(test_dict);
469 static void qdict_array_entries_test(void)
471 QDict *dict = qdict_new();
473 g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
475 qdict_put(dict, "bar", qint_from_int(0));
476 qdict_put(dict, "baz.0", qint_from_int(0));
477 g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
479 qdict_put(dict, "foo.1", qint_from_int(0));
480 g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
481 qdict_put(dict, "foo.0", qint_from_int(0));
482 g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 2);
483 qdict_put(dict, "foo.bar", qint_from_int(0));
484 g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
485 qdict_del(dict, "foo.bar");
487 qdict_put(dict, "foo.2.a", qint_from_int(0));
488 qdict_put(dict, "foo.2.b", qint_from_int(0));
489 qdict_put(dict, "foo.2.c", qint_from_int(0));
490 g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 3);
491 g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
493 QDECREF(dict);
495 dict = qdict_new();
496 qdict_put(dict, "1", qint_from_int(0));
497 g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
498 qdict_put(dict, "0", qint_from_int(0));
499 g_assert_cmpint(qdict_array_entries(dict, ""), ==, 2);
500 qdict_put(dict, "bar", qint_from_int(0));
501 g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
502 qdict_del(dict, "bar");
504 qdict_put(dict, "2.a", qint_from_int(0));
505 qdict_put(dict, "2.b", qint_from_int(0));
506 qdict_put(dict, "2.c", qint_from_int(0));
507 g_assert_cmpint(qdict_array_entries(dict, ""), ==, 3);
509 QDECREF(dict);
512 static void qdict_join_test(void)
514 QDict *dict1, *dict2;
515 bool overwrite = false;
516 int i;
518 dict1 = qdict_new();
519 dict2 = qdict_new();
522 /* Test everything once without overwrite and once with */
525 /* Test empty dicts */
526 qdict_join(dict1, dict2, overwrite);
528 g_assert(qdict_size(dict1) == 0);
529 g_assert(qdict_size(dict2) == 0);
532 /* First iteration: Test movement */
533 /* Second iteration: Test empty source and non-empty destination */
534 qdict_put(dict2, "foo", qint_from_int(42));
536 for (i = 0; i < 2; i++) {
537 qdict_join(dict1, dict2, overwrite);
539 g_assert(qdict_size(dict1) == 1);
540 g_assert(qdict_size(dict2) == 0);
542 g_assert(qdict_get_int(dict1, "foo") == 42);
546 /* Test non-empty source and destination without conflict */
547 qdict_put(dict2, "bar", qint_from_int(23));
549 qdict_join(dict1, dict2, overwrite);
551 g_assert(qdict_size(dict1) == 2);
552 g_assert(qdict_size(dict2) == 0);
554 g_assert(qdict_get_int(dict1, "foo") == 42);
555 g_assert(qdict_get_int(dict1, "bar") == 23);
558 /* Test conflict */
559 qdict_put(dict2, "foo", qint_from_int(84));
561 qdict_join(dict1, dict2, overwrite);
563 g_assert(qdict_size(dict1) == 2);
564 g_assert(qdict_size(dict2) == !overwrite);
566 g_assert(qdict_get_int(dict1, "foo") == overwrite ? 84 : 42);
567 g_assert(qdict_get_int(dict1, "bar") == 23);
569 if (!overwrite) {
570 g_assert(qdict_get_int(dict2, "foo") == 84);
574 /* Check the references */
575 g_assert(qdict_get(dict1, "foo")->refcnt == 1);
576 g_assert(qdict_get(dict1, "bar")->refcnt == 1);
578 if (!overwrite) {
579 g_assert(qdict_get(dict2, "foo")->refcnt == 1);
583 /* Clean up */
584 qdict_del(dict1, "foo");
585 qdict_del(dict1, "bar");
587 if (!overwrite) {
588 qdict_del(dict2, "foo");
591 while (overwrite ^= true);
594 QDECREF(dict1);
595 QDECREF(dict2);
599 * Errors test-cases
602 static void qdict_put_exists_test(void)
604 int value;
605 const char *key = "exists";
606 QDict *tests_dict = qdict_new();
608 qdict_put(tests_dict, key, qint_from_int(1));
609 qdict_put(tests_dict, key, qint_from_int(2));
611 value = qdict_get_int(tests_dict, key);
612 g_assert(value == 2);
614 g_assert(qdict_size(tests_dict) == 1);
616 QDECREF(tests_dict);
619 static void qdict_get_not_exists_test(void)
621 QDict *tests_dict = qdict_new();
622 g_assert(qdict_get(tests_dict, "foo") == NULL);
624 QDECREF(tests_dict);
628 * Stress test-case
630 * This is a lot big for a unit-test, but there is no other place
631 * to have it.
634 static void remove_dots(char *string)
636 char *p = strchr(string, ':');
637 if (p)
638 *p = '\0';
641 static QString *read_line(FILE *file, char *key)
643 char value[128];
645 if (fscanf(file, "%127s%127s", key, value) == EOF) {
646 return NULL;
648 remove_dots(key);
649 return qstring_from_str(value);
652 #define reset_file(file) fseek(file, 0L, SEEK_SET)
654 static void qdict_stress_test(void)
656 size_t lines;
657 char key[128];
658 FILE *test_file;
659 QDict *qdict;
660 QString *value;
661 const char *test_file_path = "qdict-test-data.txt";
663 test_file = fopen(test_file_path, "r");
664 g_assert(test_file != NULL);
666 // Create the dict
667 qdict = qdict_new();
668 g_assert(qdict != NULL);
670 // Add everything from the test file
671 for (lines = 0;; lines++) {
672 value = read_line(test_file, key);
673 if (!value)
674 break;
676 qdict_put(qdict, key, value);
678 g_assert(qdict_size(qdict) == lines);
680 // Check if everything is really in there
681 reset_file(test_file);
682 for (;;) {
683 const char *str1, *str2;
685 value = read_line(test_file, key);
686 if (!value)
687 break;
689 str1 = qstring_get_str(value);
691 str2 = qdict_get_str(qdict, key);
692 g_assert(str2 != NULL);
694 g_assert(strcmp(str1, str2) == 0);
696 QDECREF(value);
699 // Delete everything
700 reset_file(test_file);
701 for (;;) {
702 value = read_line(test_file, key);
703 if (!value)
704 break;
706 qdict_del(qdict, key);
707 QDECREF(value);
709 g_assert(qdict_haskey(qdict, key) == 0);
711 fclose(test_file);
713 g_assert(qdict_size(qdict) == 0);
714 QDECREF(qdict);
717 int main(int argc, char **argv)
719 g_test_init(&argc, &argv, NULL);
721 g_test_add_func("/public/new", qdict_new_test);
722 g_test_add_func("/public/put_obj", qdict_put_obj_test);
723 g_test_add_func("/public/destroy_simple", qdict_destroy_simple_test);
725 /* Continue, but now with fixtures */
726 g_test_add_func("/public/get", qdict_get_test);
727 g_test_add_func("/public/get_int", qdict_get_int_test);
728 g_test_add_func("/public/get_try_int", qdict_get_try_int_test);
729 g_test_add_func("/public/get_str", qdict_get_str_test);
730 g_test_add_func("/public/get_try_str", qdict_get_try_str_test);
731 g_test_add_func("/public/defaults", qdict_defaults_test);
732 g_test_add_func("/public/haskey_not", qdict_haskey_not_test);
733 g_test_add_func("/public/haskey", qdict_haskey_test);
734 g_test_add_func("/public/del", qdict_del_test);
735 g_test_add_func("/public/to_qdict", qobject_to_qdict_test);
736 g_test_add_func("/public/iterapi", qdict_iterapi_test);
737 g_test_add_func("/public/flatten", qdict_flatten_test);
738 g_test_add_func("/public/array_split", qdict_array_split_test);
739 g_test_add_func("/public/array_entries", qdict_array_entries_test);
740 g_test_add_func("/public/join", qdict_join_test);
742 g_test_add_func("/errors/put_exists", qdict_put_exists_test);
743 g_test_add_func("/errors/get_not_exists", qdict_get_not_exists_test);
745 /* The Big one */
746 if (g_test_slow()) {
747 g_test_add_func("/stress/test", qdict_stress_test);
750 return g_test_run();