]> Git Repo - qemu.git/blob - tests/check-qdict.c
image-fuzzer: Fuzzing functions for qcow2 images
[qemu.git] / tests / check-qdict.c
1 /*
2  * QDict unit-tests.
3  *
4  * Copyright (C) 2009 Red Hat Inc.
5  *
6  * Authors:
7  *  Luiz Capitulino <[email protected]>
8  *
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.
11  */
12 #include <glib.h>
13
14 #include "qapi/qmp/qint.h"
15 #include "qapi/qmp/qdict.h"
16 #include "qapi/qmp/qstring.h"
17 #include "qemu-common.h"
18
19 /*
20  * Public Interface test-cases
21  *
22  * (with some violations to access 'private' data)
23  */
24
25 static void qdict_new_test(void)
26 {
27     QDict *qdict;
28
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);
34
35     // destroy doesn't exit yet
36     g_free(qdict);
37 }
38
39 static void qdict_put_obj_test(void)
40 {
41     QInt *qi;
42     QDict *qdict;
43     QDictEntry *ent;
44     const int num = 42;
45
46     qdict = qdict_new();
47
48     // key "" will have tdb hash 12345
49     qdict_put_obj(qdict, "", QOBJECT(qint_from_int(num)));
50
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);
55
56     // destroy doesn't exit yet
57     QDECREF(qi);
58     g_free(ent->key);
59     g_free(ent);
60     g_free(qdict);
61 }
62
63 static void qdict_destroy_simple_test(void)
64 {
65     QDict *qdict;
66
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")));
70
71     QDECREF(qdict);
72 }
73
74 static void qdict_get_test(void)
75 {
76     QInt *qi;
77     QObject *obj;
78     const int value = -42;
79     const char *key = "test";
80     QDict *tests_dict = qdict_new();
81
82     qdict_put(tests_dict, key, qint_from_int(value));
83
84     obj = qdict_get(tests_dict, key);
85     g_assert(obj != NULL);
86
87     qi = qobject_to_qint(obj);
88     g_assert(qint_get_int(qi) == value);
89
90     QDECREF(tests_dict);
91 }
92
93 static void qdict_get_int_test(void)
94 {
95     int ret;
96     const int value = 100;
97     const char *key = "int";
98     QDict *tests_dict = qdict_new();
99
100     qdict_put(tests_dict, key, qint_from_int(value));
101
102     ret = qdict_get_int(tests_dict, key);
103     g_assert(ret == value);
104
105     QDECREF(tests_dict);
106 }
107
108 static void qdict_get_try_int_test(void)
109 {
110     int ret;
111     const int value = 100;
112     const char *key = "int";
113     QDict *tests_dict = qdict_new();
114
115     qdict_put(tests_dict, key, qint_from_int(value));
116
117     ret = qdict_get_try_int(tests_dict, key, 0);
118     g_assert(ret == value);
119
120     QDECREF(tests_dict);
121 }
122
123 static void qdict_get_str_test(void)
124 {
125     const char *p;
126     const char *key = "key";
127     const char *str = "string";
128     QDict *tests_dict = qdict_new();
129
130     qdict_put(tests_dict, key, qstring_from_str(str));
131
132     p = qdict_get_str(tests_dict, key);
133     g_assert(p != NULL);
134     g_assert(strcmp(p, str) == 0);
135
136     QDECREF(tests_dict);
137 }
138
139 static void qdict_get_try_str_test(void)
140 {
141     const char *p;
142     const char *key = "key";
143     const char *str = "string";
144     QDict *tests_dict = qdict_new();
145
146     qdict_put(tests_dict, key, qstring_from_str(str));
147
148     p = qdict_get_try_str(tests_dict, key);
149     g_assert(p != NULL);
150     g_assert(strcmp(p, str) == 0);
151
152     QDECREF(tests_dict);
153 }
154
155 static void qdict_haskey_not_test(void)
156 {
157     QDict *tests_dict = qdict_new();
158     g_assert(qdict_haskey(tests_dict, "test") == 0);
159
160     QDECREF(tests_dict);
161 }
162
163 static void qdict_haskey_test(void)
164 {
165     const char *key = "test";
166     QDict *tests_dict = qdict_new();
167
168     qdict_put(tests_dict, key, qint_from_int(0));
169     g_assert(qdict_haskey(tests_dict, key) == 1);
170
171     QDECREF(tests_dict);
172 }
173
174 static void qdict_del_test(void)
175 {
176     const char *key = "key test";
177     QDict *tests_dict = qdict_new();
178
179     qdict_put(tests_dict, key, qstring_from_str("foo"));
180     g_assert(qdict_size(tests_dict) == 1);
181
182     qdict_del(tests_dict, key);
183
184     g_assert(qdict_size(tests_dict) == 0);
185     g_assert(qdict_haskey(tests_dict, key) == 0);
186
187     QDECREF(tests_dict);
188 }
189
190 static void qobject_to_qdict_test(void)
191 {
192     QDict *tests_dict = qdict_new();
193     g_assert(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);
194
195     QDECREF(tests_dict);
196 }
197
198 static void qdict_iterapi_test(void)
199 {
200     int count;
201     const QDictEntry *ent;
202     QDict *tests_dict = qdict_new();
203
204     g_assert(qdict_first(tests_dict) == NULL);
205
206     qdict_put(tests_dict, "key1", qint_from_int(1));
207     qdict_put(tests_dict, "key2", qint_from_int(2));
208     qdict_put(tests_dict, "key3", qint_from_int(3));
209
210     count = 0;
211     for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
212         g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
213         count++;
214     }
215
216     g_assert(count == qdict_size(tests_dict));
217
218     /* Do it again to test restarting */
219     count = 0;
220     for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
221         g_assert(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
222         count++;
223     }
224
225     g_assert(count == qdict_size(tests_dict));
226
227     QDECREF(tests_dict);
228 }
229
230 static void qdict_flatten_test(void)
231 {
232     QList *list1 = qlist_new();
233     QList *list2 = qlist_new();
234     QDict *dict1 = qdict_new();
235     QDict *dict2 = qdict_new();
236     QDict *dict3 = qdict_new();
237
238     /*
239      * Test the flattening of
240      *
241      * {
242      *     "e": [
243      *         42,
244      *         [
245      *             23,
246      *             66,
247      *             {
248      *                 "a": 0,
249      *                 "b": 1
250      *             }
251      *         ]
252      *     ],
253      *     "f": {
254      *         "c": 2,
255      *         "d": 3,
256      *     },
257      *     "g": 4
258      * }
259      *
260      * to
261      *
262      * {
263      *     "e.0": 42,
264      *     "e.1.0": 23,
265      *     "e.1.1": 66,
266      *     "e.1.2.a": 0,
267      *     "e.1.2.b": 1,
268      *     "f.c": 2,
269      *     "f.d": 3,
270      *     "g": 4
271      * }
272      */
273
274     qdict_put(dict1, "a", qint_from_int(0));
275     qdict_put(dict1, "b", qint_from_int(1));
276
277     qlist_append_obj(list1, QOBJECT(qint_from_int(23)));
278     qlist_append_obj(list1, QOBJECT(qint_from_int(66)));
279     qlist_append_obj(list1, QOBJECT(dict1));
280     qlist_append_obj(list2, QOBJECT(qint_from_int(42)));
281     qlist_append_obj(list2, QOBJECT(list1));
282
283     qdict_put(dict2, "c", qint_from_int(2));
284     qdict_put(dict2, "d", qint_from_int(3));
285     qdict_put_obj(dict3, "e", QOBJECT(list2));
286     qdict_put_obj(dict3, "f", QOBJECT(dict2));
287     qdict_put(dict3, "g", qint_from_int(4));
288
289     qdict_flatten(dict3);
290
291     g_assert(qdict_get_int(dict3, "e.0") == 42);
292     g_assert(qdict_get_int(dict3, "e.1.0") == 23);
293     g_assert(qdict_get_int(dict3, "e.1.1") == 66);
294     g_assert(qdict_get_int(dict3, "e.1.2.a") == 0);
295     g_assert(qdict_get_int(dict3, "e.1.2.b") == 1);
296     g_assert(qdict_get_int(dict3, "f.c") == 2);
297     g_assert(qdict_get_int(dict3, "f.d") == 3);
298     g_assert(qdict_get_int(dict3, "g") == 4);
299
300     g_assert(qdict_size(dict3) == 8);
301
302     QDECREF(dict3);
303 }
304
305 static void qdict_array_split_test(void)
306 {
307     QDict *test_dict = qdict_new();
308     QDict *dict1, *dict2;
309     QInt *int1;
310     QList *test_list;
311
312     /*
313      * Test the split of
314      *
315      * {
316      *     "1.x": 0,
317      *     "4.y": 1,
318      *     "0.a": 42,
319      *     "o.o": 7,
320      *     "0.b": 23,
321      *     "2": 66
322      * }
323      *
324      * to
325      *
326      * [
327      *     {
328      *         "a": 42,
329      *         "b": 23
330      *     },
331      *     {
332      *         "x": 0
333      *     },
334      *     66
335      * ]
336      *
337      * and
338      *
339      * {
340      *     "4.y": 1,
341      *     "o.o": 7
342      * }
343      *
344      * (remaining in the old QDict)
345      *
346      * This example is given in the comment of qdict_array_split().
347      */
348
349     qdict_put(test_dict, "1.x", qint_from_int(0));
350     qdict_put(test_dict, "4.y", qint_from_int(1));
351     qdict_put(test_dict, "0.a", qint_from_int(42));
352     qdict_put(test_dict, "o.o", qint_from_int(7));
353     qdict_put(test_dict, "0.b", qint_from_int(23));
354     qdict_put(test_dict, "2", qint_from_int(66));
355
356     qdict_array_split(test_dict, &test_list);
357
358     dict1 = qobject_to_qdict(qlist_pop(test_list));
359     dict2 = qobject_to_qdict(qlist_pop(test_list));
360     int1 = qobject_to_qint(qlist_pop(test_list));
361
362     g_assert(dict1);
363     g_assert(dict2);
364     g_assert(int1);
365     g_assert(qlist_empty(test_list));
366
367     QDECREF(test_list);
368
369     g_assert(qdict_get_int(dict1, "a") == 42);
370     g_assert(qdict_get_int(dict1, "b") == 23);
371
372     g_assert(qdict_size(dict1) == 2);
373
374     QDECREF(dict1);
375
376     g_assert(qdict_get_int(dict2, "x") == 0);
377
378     g_assert(qdict_size(dict2) == 1);
379
380     QDECREF(dict2);
381
382     g_assert(qint_get_int(int1) == 66);
383
384     QDECREF(int1);
385
386     g_assert(qdict_get_int(test_dict, "4.y") == 1);
387     g_assert(qdict_get_int(test_dict, "o.o") == 7);
388
389     g_assert(qdict_size(test_dict) == 2);
390
391     QDECREF(test_dict);
392
393
394     /*
395      * Test the split of
396      *
397      * {
398      *     "0": 42,
399      *     "1": 23,
400      *     "1.x": 84
401      * }
402      *
403      * to
404      *
405      * [
406      *     42
407      * ]
408      *
409      * and
410      *
411      * {
412      *     "1": 23,
413      *     "1.x": 84
414      * }
415      *
416      * That is, test whether splitting stops if there is both an entry with key
417      * of "%u" and other entries with keys prefixed "%u." for the same index.
418      */
419
420     test_dict = qdict_new();
421
422     qdict_put(test_dict, "0", qint_from_int(42));
423     qdict_put(test_dict, "1", qint_from_int(23));
424     qdict_put(test_dict, "1.x", qint_from_int(84));
425
426     qdict_array_split(test_dict, &test_list);
427
428     int1 = qobject_to_qint(qlist_pop(test_list));
429
430     g_assert(int1);
431     g_assert(qlist_empty(test_list));
432
433     QDECREF(test_list);
434
435     g_assert(qint_get_int(int1) == 42);
436
437     QDECREF(int1);
438
439     g_assert(qdict_get_int(test_dict, "1") == 23);
440     g_assert(qdict_get_int(test_dict, "1.x") == 84);
441
442     g_assert(qdict_size(test_dict) == 2);
443
444     QDECREF(test_dict);
445 }
446
447 static void qdict_join_test(void)
448 {
449     QDict *dict1, *dict2;
450     bool overwrite = false;
451     int i;
452
453     dict1 = qdict_new();
454     dict2 = qdict_new();
455
456
457     /* Test everything once without overwrite and once with */
458     do
459     {
460         /* Test empty dicts */
461         qdict_join(dict1, dict2, overwrite);
462
463         g_assert(qdict_size(dict1) == 0);
464         g_assert(qdict_size(dict2) == 0);
465
466
467         /* First iteration: Test movement */
468         /* Second iteration: Test empty source and non-empty destination */
469         qdict_put(dict2, "foo", qint_from_int(42));
470
471         for (i = 0; i < 2; i++) {
472             qdict_join(dict1, dict2, overwrite);
473
474             g_assert(qdict_size(dict1) == 1);
475             g_assert(qdict_size(dict2) == 0);
476
477             g_assert(qdict_get_int(dict1, "foo") == 42);
478         }
479
480
481         /* Test non-empty source and destination without conflict */
482         qdict_put(dict2, "bar", qint_from_int(23));
483
484         qdict_join(dict1, dict2, overwrite);
485
486         g_assert(qdict_size(dict1) == 2);
487         g_assert(qdict_size(dict2) == 0);
488
489         g_assert(qdict_get_int(dict1, "foo") == 42);
490         g_assert(qdict_get_int(dict1, "bar") == 23);
491
492
493         /* Test conflict */
494         qdict_put(dict2, "foo", qint_from_int(84));
495
496         qdict_join(dict1, dict2, overwrite);
497
498         g_assert(qdict_size(dict1) == 2);
499         g_assert(qdict_size(dict2) == !overwrite);
500
501         g_assert(qdict_get_int(dict1, "foo") == overwrite ? 84 : 42);
502         g_assert(qdict_get_int(dict1, "bar") == 23);
503
504         if (!overwrite) {
505             g_assert(qdict_get_int(dict2, "foo") == 84);
506         }
507
508
509         /* Check the references */
510         g_assert(qdict_get(dict1, "foo")->refcnt == 1);
511         g_assert(qdict_get(dict1, "bar")->refcnt == 1);
512
513         if (!overwrite) {
514             g_assert(qdict_get(dict2, "foo")->refcnt == 1);
515         }
516
517
518         /* Clean up */
519         qdict_del(dict1, "foo");
520         qdict_del(dict1, "bar");
521
522         if (!overwrite) {
523             qdict_del(dict2, "foo");
524         }
525     }
526     while (overwrite ^= true);
527
528
529     QDECREF(dict1);
530     QDECREF(dict2);
531 }
532
533 /*
534  * Errors test-cases
535  */
536
537 static void qdict_put_exists_test(void)
538 {
539     int value;
540     const char *key = "exists";
541     QDict *tests_dict = qdict_new();
542
543     qdict_put(tests_dict, key, qint_from_int(1));
544     qdict_put(tests_dict, key, qint_from_int(2));
545
546     value = qdict_get_int(tests_dict, key);
547     g_assert(value == 2);
548
549     g_assert(qdict_size(tests_dict) == 1);
550
551     QDECREF(tests_dict);
552 }
553
554 static void qdict_get_not_exists_test(void)
555 {
556     QDict *tests_dict = qdict_new();
557     g_assert(qdict_get(tests_dict, "foo") == NULL);
558
559     QDECREF(tests_dict);
560 }
561
562 /*
563  * Stress test-case
564  *
565  * This is a lot big for a unit-test, but there is no other place
566  * to have it.
567  */
568
569 static void remove_dots(char *string)
570 {
571     char *p = strchr(string, ':');
572     if (p)
573         *p = '\0';
574 }
575
576 static QString *read_line(FILE *file, char *key)
577 {
578     char value[128];
579
580     if (fscanf(file, "%127s%127s", key, value) == EOF) {
581         return NULL;
582     }
583     remove_dots(key);
584     return qstring_from_str(value);
585 }
586
587 #define reset_file(file)    fseek(file, 0L, SEEK_SET)
588
589 static void qdict_stress_test(void)
590 {
591     size_t lines;
592     char key[128];
593     FILE *test_file;
594     QDict *qdict;
595     QString *value;
596     const char *test_file_path = "qdict-test-data.txt";
597
598     test_file = fopen(test_file_path, "r");
599     g_assert(test_file != NULL);
600
601     // Create the dict
602     qdict = qdict_new();
603     g_assert(qdict != NULL);
604
605     // Add everything from the test file
606     for (lines = 0;; lines++) {
607         value = read_line(test_file, key);
608         if (!value)
609             break;
610
611         qdict_put(qdict, key, value);
612     }
613     g_assert(qdict_size(qdict) == lines);
614
615     // Check if everything is really in there
616     reset_file(test_file);
617     for (;;) {
618         const char *str1, *str2;
619
620         value = read_line(test_file, key);
621         if (!value)
622             break;
623
624         str1 = qstring_get_str(value);
625
626         str2 = qdict_get_str(qdict, key);
627         g_assert(str2 != NULL);
628
629         g_assert(strcmp(str1, str2) == 0);
630
631         QDECREF(value);
632     }
633
634     // Delete everything
635     reset_file(test_file);
636     for (;;) {
637         value = read_line(test_file, key);
638         if (!value)
639             break;
640
641         qdict_del(qdict, key);
642         QDECREF(value);
643
644         g_assert(qdict_haskey(qdict, key) == 0);
645     }
646     fclose(test_file);
647
648     g_assert(qdict_size(qdict) == 0);
649     QDECREF(qdict);
650 }
651
652 int main(int argc, char **argv)
653 {
654     g_test_init(&argc, &argv, NULL);
655
656     g_test_add_func("/public/new", qdict_new_test);
657     g_test_add_func("/public/put_obj", qdict_put_obj_test);
658     g_test_add_func("/public/destroy_simple", qdict_destroy_simple_test);
659
660     /* Continue, but now with fixtures */
661     g_test_add_func("/public/get", qdict_get_test);
662     g_test_add_func("/public/get_int", qdict_get_int_test);
663     g_test_add_func("/public/get_try_int", qdict_get_try_int_test);
664     g_test_add_func("/public/get_str", qdict_get_str_test);
665     g_test_add_func("/public/get_try_str", qdict_get_try_str_test);
666     g_test_add_func("/public/haskey_not", qdict_haskey_not_test);
667     g_test_add_func("/public/haskey", qdict_haskey_test);
668     g_test_add_func("/public/del", qdict_del_test);
669     g_test_add_func("/public/to_qdict", qobject_to_qdict_test);
670     g_test_add_func("/public/iterapi", qdict_iterapi_test);
671     g_test_add_func("/public/flatten", qdict_flatten_test);
672     g_test_add_func("/public/array_split", qdict_array_split_test);
673     g_test_add_func("/public/join", qdict_join_test);
674
675     g_test_add_func("/errors/put_exists", qdict_put_exists_test);
676     g_test_add_func("/errors/get_not_exists", qdict_get_not_exists_test);
677
678     /* The Big one */
679     if (g_test_slow()) {
680         g_test_add_func("/stress/test", qdict_stress_test);
681     }
682
683     return g_test_run();
684 }
This page took 0.061465 seconds and 4 git commands to generate.