xref: /illumos-kvm-cmd/check-qdict.c (revision 68396ea9)
1 /*
2  * QDict unit-tests.
3  *
4  * Copyright (C) 2009 Red Hat Inc.
5  *
6  * Authors:
7  *  Luiz Capitulino <lcapitulino@redhat.com>
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 <check.h>
13 
14 #include "qint.h"
15 #include "qdict.h"
16 #include "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 
START_TEST(qdict_new_test)25 START_TEST(qdict_new_test)
26 {
27     QDict *qdict;
28 
29     qdict = qdict_new();
30     fail_unless(qdict != NULL);
31     fail_unless(qdict_size(qdict) == 0);
32     fail_unless(qdict->base.refcnt == 1);
33     fail_unless(qobject_type(QOBJECT(qdict)) == QTYPE_QDICT);
34 
35     // destroy doesn't exit yet
36     free(qdict);
37 }
38 END_TEST
39 
START_TEST(qdict_put_obj_test)40 START_TEST(qdict_put_obj_test)
41 {
42     QInt *qi;
43     QDict *qdict;
44     QDictEntry *ent;
45     const int num = 42;
46 
47     qdict = qdict_new();
48 
49     // key "" will have tdb hash 12345
50     qdict_put_obj(qdict, "", QOBJECT(qint_from_int(num)));
51 
52     fail_unless(qdict_size(qdict) == 1);
53     ent = QLIST_FIRST(&qdict->table[12345 % QDICT_BUCKET_MAX]);
54     qi = qobject_to_qint(ent->value);
55     fail_unless(qint_get_int(qi) == num);
56 
57     // destroy doesn't exit yet
58     QDECREF(qi);
59     qemu_free(ent->key);
60     qemu_free(ent);
61     qemu_free(qdict);
62 }
63 END_TEST
64 
START_TEST(qdict_destroy_simple_test)65 START_TEST(qdict_destroy_simple_test)
66 {
67     QDict *qdict;
68 
69     qdict = qdict_new();
70     qdict_put_obj(qdict, "num", QOBJECT(qint_from_int(0)));
71     qdict_put_obj(qdict, "str", QOBJECT(qstring_from_str("foo")));
72 
73     QDECREF(qdict);
74 }
75 END_TEST
76 
77 static QDict *tests_dict = NULL;
78 
qdict_setup(void)79 static void qdict_setup(void)
80 {
81     tests_dict = qdict_new();
82     fail_unless(tests_dict != NULL);
83 }
84 
qdict_teardown(void)85 static void qdict_teardown(void)
86 {
87     QDECREF(tests_dict);
88     tests_dict = NULL;
89 }
90 
START_TEST(qdict_get_test)91 START_TEST(qdict_get_test)
92 {
93     QInt *qi;
94     QObject *obj;
95     const int value = -42;
96     const char *key = "test";
97 
98     qdict_put(tests_dict, key, qint_from_int(value));
99 
100     obj = qdict_get(tests_dict, key);
101     fail_unless(obj != NULL);
102 
103     qi = qobject_to_qint(obj);
104     fail_unless(qint_get_int(qi) == value);
105 }
106 END_TEST
107 
START_TEST(qdict_get_int_test)108 START_TEST(qdict_get_int_test)
109 {
110     int ret;
111     const int value = 100;
112     const char *key = "int";
113 
114     qdict_put(tests_dict, key, qint_from_int(value));
115 
116     ret = qdict_get_int(tests_dict, key);
117     fail_unless(ret == value);
118 }
119 END_TEST
120 
START_TEST(qdict_get_try_int_test)121 START_TEST(qdict_get_try_int_test)
122 {
123     int ret;
124     const int value = 100;
125     const char *key = "int";
126 
127     qdict_put(tests_dict, key, qint_from_int(value));
128 
129     ret = qdict_get_try_int(tests_dict, key, 0);
130     fail_unless(ret == value);
131 }
132 END_TEST
133 
START_TEST(qdict_get_str_test)134 START_TEST(qdict_get_str_test)
135 {
136     const char *p;
137     const char *key = "key";
138     const char *str = "string";
139 
140     qdict_put(tests_dict, key, qstring_from_str(str));
141 
142     p = qdict_get_str(tests_dict, key);
143     fail_unless(p != NULL);
144     fail_unless(strcmp(p, str) == 0);
145 }
146 END_TEST
147 
START_TEST(qdict_get_try_str_test)148 START_TEST(qdict_get_try_str_test)
149 {
150     const char *p;
151     const char *key = "key";
152     const char *str = "string";
153 
154     qdict_put(tests_dict, key, qstring_from_str(str));
155 
156     p = qdict_get_try_str(tests_dict, key);
157     fail_unless(p != NULL);
158     fail_unless(strcmp(p, str) == 0);
159 }
160 END_TEST
161 
START_TEST(qdict_haskey_not_test)162 START_TEST(qdict_haskey_not_test)
163 {
164     fail_unless(qdict_haskey(tests_dict, "test") == 0);
165 }
166 END_TEST
167 
START_TEST(qdict_haskey_test)168 START_TEST(qdict_haskey_test)
169 {
170     const char *key = "test";
171 
172     qdict_put(tests_dict, key, qint_from_int(0));
173     fail_unless(qdict_haskey(tests_dict, key) == 1);
174 }
175 END_TEST
176 
START_TEST(qdict_del_test)177 START_TEST(qdict_del_test)
178 {
179     const char *key = "key test";
180 
181     qdict_put(tests_dict, key, qstring_from_str("foo"));
182     fail_unless(qdict_size(tests_dict) == 1);
183 
184     qdict_del(tests_dict, key);
185 
186     fail_unless(qdict_size(tests_dict) == 0);
187     fail_unless(qdict_haskey(tests_dict, key) == 0);
188 }
189 END_TEST
190 
START_TEST(qobject_to_qdict_test)191 START_TEST(qobject_to_qdict_test)
192 {
193     fail_unless(qobject_to_qdict(QOBJECT(tests_dict)) == tests_dict);
194 }
195 END_TEST
196 
START_TEST(qdict_iterapi_test)197 START_TEST(qdict_iterapi_test)
198 {
199     int count;
200     const QDictEntry *ent;
201 
202     fail_unless(qdict_first(tests_dict) == NULL);
203 
204     qdict_put(tests_dict, "key1", qint_from_int(1));
205     qdict_put(tests_dict, "key2", qint_from_int(2));
206     qdict_put(tests_dict, "key3", qint_from_int(3));
207 
208     count = 0;
209     for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
210         fail_unless(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
211         count++;
212     }
213 
214     fail_unless(count == qdict_size(tests_dict));
215 
216     /* Do it again to test restarting */
217     count = 0;
218     for (ent = qdict_first(tests_dict); ent; ent = qdict_next(tests_dict, ent)){
219         fail_unless(qdict_haskey(tests_dict, qdict_entry_key(ent)) == 1);
220         count++;
221     }
222 
223     fail_unless(count == qdict_size(tests_dict));
224 }
225 END_TEST
226 
227 /*
228  * Errors test-cases
229  */
230 
START_TEST(qdict_put_exists_test)231 START_TEST(qdict_put_exists_test)
232 {
233     int value;
234     const char *key = "exists";
235 
236     qdict_put(tests_dict, key, qint_from_int(1));
237     qdict_put(tests_dict, key, qint_from_int(2));
238 
239     value = qdict_get_int(tests_dict, key);
240     fail_unless(value == 2);
241 
242     fail_unless(qdict_size(tests_dict) == 1);
243 }
244 END_TEST
245 
START_TEST(qdict_get_not_exists_test)246 START_TEST(qdict_get_not_exists_test)
247 {
248     fail_unless(qdict_get(tests_dict, "foo") == NULL);
249 }
250 END_TEST
251 
252 /*
253  * Stress test-case
254  *
255  * This is a lot big for a unit-test, but there is no other place
256  * to have it.
257  */
258 
remove_dots(char * string)259 static void remove_dots(char *string)
260 {
261     char *p = strchr(string, ':');
262     if (p)
263         *p = '\0';
264 }
265 
read_line(FILE * file,char * key)266 static QString *read_line(FILE *file, char *key)
267 {
268     char value[128];
269 
270     if (fscanf(file, "%s%s", key, value) == EOF)
271         return NULL;
272     remove_dots(key);
273     return qstring_from_str(value);
274 }
275 
276 #define reset_file(file)    fseek(file, 0L, SEEK_SET)
277 
START_TEST(qdict_stress_test)278 START_TEST(qdict_stress_test)
279 {
280     size_t lines;
281     char key[128];
282     FILE *test_file;
283     QDict *qdict;
284     QString *value;
285     const char *test_file_path = "qdict-test-data.txt";
286 
287     test_file = fopen(test_file_path, "r");
288     fail_unless(test_file != NULL);
289 
290     // Create the dict
291     qdict = qdict_new();
292     fail_unless(qdict != NULL);
293 
294     // Add everything from the test file
295     for (lines = 0;; lines++) {
296         value = read_line(test_file, key);
297         if (!value)
298             break;
299 
300         qdict_put(qdict, key, value);
301     }
302     fail_unless(qdict_size(qdict) == lines);
303 
304     // Check if everything is really in there
305     reset_file(test_file);
306     for (;;) {
307         const char *str1, *str2;
308 
309         value = read_line(test_file, key);
310         if (!value)
311             break;
312 
313         str1 = qstring_get_str(value);
314 
315         str2 = qdict_get_str(qdict, key);
316         fail_unless(str2 != NULL);
317 
318         fail_unless(strcmp(str1, str2) == 0);
319 
320         QDECREF(value);
321     }
322 
323     // Delete everything
324     reset_file(test_file);
325     for (;;) {
326         value = read_line(test_file, key);
327         if (!value)
328             break;
329 
330         qdict_del(qdict, key);
331         QDECREF(value);
332 
333         fail_unless(qdict_haskey(qdict, key) == 0);
334     }
335     fclose(test_file);
336 
337     fail_unless(qdict_size(qdict) == 0);
338     QDECREF(qdict);
339 }
340 END_TEST
341 
qdict_suite(void)342 static Suite *qdict_suite(void)
343 {
344     Suite *s;
345     TCase *qdict_public_tcase;
346     TCase *qdict_public2_tcase;
347     TCase *qdict_stress_tcase;
348     TCase *qdict_errors_tcase;
349 
350     s = suite_create("QDict test-suite");
351 
352     qdict_public_tcase = tcase_create("Public Interface");
353     suite_add_tcase(s, qdict_public_tcase);
354     tcase_add_test(qdict_public_tcase, qdict_new_test);
355     tcase_add_test(qdict_public_tcase, qdict_put_obj_test);
356     tcase_add_test(qdict_public_tcase, qdict_destroy_simple_test);
357 
358     /* Continue, but now with fixtures */
359     qdict_public2_tcase = tcase_create("Public Interface (2)");
360     suite_add_tcase(s, qdict_public2_tcase);
361     tcase_add_checked_fixture(qdict_public2_tcase, qdict_setup, qdict_teardown);
362     tcase_add_test(qdict_public2_tcase, qdict_get_test);
363     tcase_add_test(qdict_public2_tcase, qdict_get_int_test);
364     tcase_add_test(qdict_public2_tcase, qdict_get_try_int_test);
365     tcase_add_test(qdict_public2_tcase, qdict_get_str_test);
366     tcase_add_test(qdict_public2_tcase, qdict_get_try_str_test);
367     tcase_add_test(qdict_public2_tcase, qdict_haskey_not_test);
368     tcase_add_test(qdict_public2_tcase, qdict_haskey_test);
369     tcase_add_test(qdict_public2_tcase, qdict_del_test);
370     tcase_add_test(qdict_public2_tcase, qobject_to_qdict_test);
371     tcase_add_test(qdict_public2_tcase, qdict_iterapi_test);
372 
373     qdict_errors_tcase = tcase_create("Errors");
374     suite_add_tcase(s, qdict_errors_tcase);
375     tcase_add_checked_fixture(qdict_errors_tcase, qdict_setup, qdict_teardown);
376     tcase_add_test(qdict_errors_tcase, qdict_put_exists_test);
377     tcase_add_test(qdict_errors_tcase, qdict_get_not_exists_test);
378 
379     /* The Big one */
380     qdict_stress_tcase = tcase_create("Stress Test");
381     suite_add_tcase(s, qdict_stress_tcase);
382     tcase_add_test(qdict_stress_tcase, qdict_stress_test);
383 
384     return s;
385 }
386 
main(void)387 int main(void)
388 {
389 	int nf;
390 	Suite *s;
391 	SRunner *sr;
392 
393 	s = qdict_suite();
394 	sr = srunner_create(s);
395 
396 	srunner_run_all(sr, CK_NORMAL);
397 	nf = srunner_ntests_failed(sr);
398 	srunner_free(sr);
399 
400 	return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
401 }
402