Add Tizen packaging files
[profile/ivi/jansson.git] / test / suites / api / test_object.c
1 /*
2  * Copyright (c) 2009-2012 Petri Lehtinen <petri@digip.org>
3  *
4  * Jansson is free software; you can redistribute it and/or modify
5  * it under the terms of the MIT license. See LICENSE for details.
6  */
7
8 #include <jansson.h>
9 #include <string.h>
10 #include "util.h"
11
12 static void test_clear()
13 {
14     json_t *object, *ten;
15
16     object = json_object();
17     ten = json_integer(10);
18
19     if(!object)
20         fail("unable to create object");
21     if(!ten)
22         fail("unable to create integer");
23
24     if(json_object_set(object, "a", ten) ||
25        json_object_set(object, "b", ten) ||
26        json_object_set(object, "c", ten) ||
27        json_object_set(object, "d", ten) ||
28        json_object_set(object, "e", ten))
29         fail("unable to set value");
30
31     if(json_object_size(object) != 5)
32         fail("invalid size");
33
34     json_object_clear(object);
35
36     if(json_object_size(object) != 0)
37         fail("invalid size after clear");
38
39     json_decref(ten);
40     json_decref(object);
41 }
42
43 static void test_update()
44 {
45     json_t *object, *other, *nine, *ten;
46
47     object = json_object();
48     other = json_object();
49
50     nine = json_integer(9);
51     ten = json_integer(10);
52
53     if(!object || !other)
54         fail("unable to create object");
55     if(!nine || !ten)
56         fail("unable to create integer");
57
58
59     /* update an empty object with an empty object */
60
61     if(json_object_update(object, other))
62         fail("unable to update an emtpy object with an empty object");
63
64     if(json_object_size(object) != 0)
65         fail("invalid size after update");
66
67     if(json_object_size(other) != 0)
68         fail("invalid size for updater after update");
69
70
71     /* update an empty object with a nonempty object */
72
73     if(json_object_set(other, "a", ten) ||
74        json_object_set(other, "b", ten) ||
75        json_object_set(other, "c", ten) ||
76        json_object_set(other, "d", ten) ||
77        json_object_set(other, "e", ten))
78         fail("unable to set value");
79
80     if(json_object_update(object, other))
81         fail("unable to update an empty object");
82
83     if(json_object_size(object) != 5)
84         fail("invalid size after update");
85
86     if(json_object_get(object, "a") != ten ||
87        json_object_get(object, "b") != ten ||
88        json_object_get(object, "c") != ten ||
89        json_object_get(object, "d") != ten ||
90        json_object_get(object, "e") != ten)
91         fail("update works incorrectly");
92
93
94     /* perform the same update again */
95
96     if(json_object_update(object, other))
97         fail("unable to update an empty object");
98
99     if(json_object_size(object) != 5)
100         fail("invalid size after update");
101
102     if(json_object_get(object, "a") != ten ||
103        json_object_get(object, "b") != ten ||
104        json_object_get(object, "c") != ten ||
105        json_object_get(object, "d") != ten ||
106        json_object_get(object, "e") != ten)
107         fail("update works incorrectly");
108
109
110     /* update a nonempty object with a nonempty object with both old
111        and new keys */
112
113     if(json_object_clear(other))
114         fail("clear failed");
115
116     if(json_object_set(other, "a", nine) ||
117        json_object_set(other, "b", nine) ||
118        json_object_set(other, "f", nine) ||
119        json_object_set(other, "g", nine) ||
120        json_object_set(other, "h", nine))
121         fail("unable to set value");
122
123     if(json_object_update(object, other))
124         fail("unable to update a nonempty object");
125
126     if(json_object_size(object) != 8)
127         fail("invalid size after update");
128
129     if(json_object_get(object, "a") != nine ||
130        json_object_get(object, "b") != nine ||
131        json_object_get(object, "f") != nine ||
132        json_object_get(object, "g") != nine ||
133        json_object_get(object, "h") != nine)
134         fail("update works incorrectly");
135
136     json_decref(nine);
137     json_decref(ten);
138     json_decref(other);
139     json_decref(object);
140 }
141
142 static void test_conditional_updates()
143 {
144     json_t *object, *other;
145
146     object = json_pack("{sisi}", "foo", 1, "bar", 2);
147     other = json_pack("{sisi}", "foo", 3, "baz", 4);
148
149     if(json_object_update_existing(object, other))
150         fail("json_object_update_existing failed");
151
152     if(json_object_size(object) != 2)
153         fail("json_object_update_existing added new items");
154
155     if(json_integer_value(json_object_get(object, "foo")) != 3)
156         fail("json_object_update_existing failed to update existing key");
157
158     if(json_integer_value(json_object_get(object, "bar")) != 2)
159         fail("json_object_update_existing updated wrong key");
160
161     json_decref(object);
162
163     object = json_pack("{sisi}", "foo", 1, "bar", 2);
164
165     if(json_object_update_missing(object, other))
166         fail("json_object_update_missing failed");
167
168     if(json_object_size(object) != 3)
169         fail("json_object_update_missing didn't add new items");
170
171     if(json_integer_value(json_object_get(object, "foo")) != 1)
172         fail("json_object_update_missing updated existing key");
173
174     if(json_integer_value(json_object_get(object, "bar")) != 2)
175         fail("json_object_update_missing updated wrong key");
176
177     if(json_integer_value(json_object_get(object, "baz")) != 4)
178         fail("json_object_update_missing didn't add new items");
179
180     json_decref(object);
181     json_decref(other);
182 }
183
184 static void test_circular()
185 {
186     json_t *object1, *object2;
187
188     object1 = json_object();
189     object2 = json_object();
190     if(!object1 || !object2)
191         fail("unable to create object");
192
193     /* the simple case is checked */
194     if(json_object_set(object1, "a", object1) == 0)
195         fail("able to set self");
196
197     /* create circular references */
198     if(json_object_set(object1, "a", object2) ||
199        json_object_set(object2, "a", object1))
200         fail("unable to set value");
201
202     /* circularity is detected when dumping */
203     if(json_dumps(object1, 0) != NULL)
204         fail("able to dump circulars");
205
206     /* decref twice to deal with the circular references */
207     json_decref(object1);
208     json_decref(object2);
209     json_decref(object1);
210 }
211
212 static void test_set_nocheck()
213 {
214     json_t *object, *string;
215
216     object = json_object();
217     string = json_string("bar");
218
219     if(!object)
220         fail("unable to create object");
221     if(!string)
222         fail("unable to create string");
223
224     if(json_object_set_nocheck(object, "foo", string))
225         fail("json_object_set_nocheck failed");
226     if(json_object_get(object, "foo") != string)
227         fail("json_object_get after json_object_set_nocheck failed");
228
229     /* invalid UTF-8 in key */
230     if(json_object_set_nocheck(object, "a\xefz", string))
231         fail("json_object_set_nocheck failed for invalid UTF-8");
232     if(json_object_get(object, "a\xefz") != string)
233         fail("json_object_get after json_object_set_nocheck failed");
234
235     if(json_object_set_new_nocheck(object, "bax", json_integer(123)))
236         fail("json_object_set_new_nocheck failed");
237     if(json_integer_value(json_object_get(object, "bax")) != 123)
238         fail("json_object_get after json_object_set_new_nocheck failed");
239
240     /* invalid UTF-8 in key */
241     if(json_object_set_new_nocheck(object, "asdf\xfe", json_integer(321)))
242         fail("json_object_set_new_nocheck failed for invalid UTF-8");
243     if(json_integer_value(json_object_get(object, "asdf\xfe")) != 321)
244         fail("json_object_get after json_object_set_new_nocheck failed");
245
246     json_decref(string);
247     json_decref(object);
248 }
249
250 static void test_iterators()
251 {
252     json_t *object, *foo, *bar, *baz;
253     void *iter;
254
255     if(json_object_iter(NULL))
256         fail("able to iterate over NULL");
257
258     if(json_object_iter_next(NULL, NULL))
259         fail("able to increment an iterator on a NULL object");
260
261     object = json_object();
262     foo = json_string("foo");
263     bar = json_string("bar");
264     baz = json_string("baz");
265     if(!object || !foo || !bar || !bar)
266         fail("unable to create values");
267
268     if(json_object_iter_next(object, NULL))
269         fail("able to increment a NULL iterator");
270
271     if(json_object_set(object, "a", foo) ||
272        json_object_set(object, "b", bar) ||
273        json_object_set(object, "c", baz))
274         fail("unable to populate object");
275
276     iter = json_object_iter(object);
277     if(!iter)
278         fail("unable to get iterator");
279     if(strcmp(json_object_iter_key(iter), "a"))
280         fail("iterating failed: wrong key");
281     if(json_object_iter_value(iter) != foo)
282         fail("iterating failed: wrong value");
283
284     iter = json_object_iter_next(object, iter);
285     if(!iter)
286         fail("unable to increment iterator");
287     if(strcmp(json_object_iter_key(iter), "b"))
288         fail("iterating failed: wrong key");
289     if(json_object_iter_value(iter) != bar)
290         fail("iterating failed: wrong value");
291
292     iter = json_object_iter_next(object, iter);
293     if(!iter)
294         fail("unable to increment iterator");
295     if(strcmp(json_object_iter_key(iter), "c"))
296         fail("iterating failed: wrong key");
297     if(json_object_iter_value(iter) != baz)
298         fail("iterating failed: wrong value");
299
300     if(json_object_iter_next(object, iter) != NULL)
301         fail("able to iterate over the end");
302
303     if(json_object_iter_at(object, "foo"))
304         fail("json_object_iter_at() succeeds for non-existent key");
305
306     iter = json_object_iter_at(object, "b");
307     if(!iter)
308         fail("json_object_iter_at() fails for an existing key");
309
310     if(strcmp(json_object_iter_key(iter), "b"))
311         fail("iterating failed: wrong key");
312     if(json_object_iter_value(iter) != bar)
313         fail("iterating failed: wrong value");
314
315     iter = json_object_iter_next(object, iter);
316     if(!iter)
317         fail("unable to increment iterator");
318     if(strcmp(json_object_iter_key(iter), "c"))
319         fail("iterating failed: wrong key");
320     if(json_object_iter_value(iter) != baz)
321         fail("iterating failed: wrong value");
322
323     if(json_object_iter_set(object, iter, bar))
324         fail("unable to set value at iterator");
325
326     if(strcmp(json_object_iter_key(iter), "c"))
327         fail("json_object_iter_key() fails after json_object_iter_set()");
328     if(json_object_iter_value(iter) != bar)
329         fail("json_object_iter_value() fails after json_object_iter_set()");
330     if(json_object_get(object, "c") != bar)
331         fail("json_object_get() fails after json_object_iter_set()");
332
333     json_decref(object);
334     json_decref(foo);
335     json_decref(bar);
336     json_decref(baz);
337 }
338
339 static void test_misc()
340 {
341     json_t *object, *string, *other_string, *value;
342
343     object = json_object();
344     string = json_string("test");
345     other_string = json_string("other");
346
347     if(!object)
348         fail("unable to create object");
349     if(!string || !other_string)
350         fail("unable to create string");
351
352     if(json_object_get(object, "a"))
353         fail("value for nonexisting key");
354
355     if(json_object_set(object, "a", string))
356         fail("unable to set value");
357
358     if(!json_object_set(object, NULL, string))
359         fail("able to set NULL key");
360
361     if(!json_object_set(object, "a", NULL))
362         fail("able to set NULL value");
363
364     /* invalid UTF-8 in key */
365     if(!json_object_set(object, "a\xefz", string))
366         fail("able to set invalid unicode key");
367
368     value = json_object_get(object, "a");
369     if(!value)
370         fail("no value for existing key");
371     if(value != string)
372         fail("got different value than what was added");
373
374     /* "a", "lp" and "px" collide in a five-bucket hashtable */
375     if(json_object_set(object, "b", string) ||
376        json_object_set(object, "lp", string) ||
377        json_object_set(object, "px", string))
378         fail("unable to set value");
379
380     value = json_object_get(object, "a");
381     if(!value)
382         fail("no value for existing key");
383     if(value != string)
384         fail("got different value than what was added");
385
386     if(json_object_set(object, "a", other_string))
387         fail("unable to replace an existing key");
388
389     value = json_object_get(object, "a");
390     if(!value)
391         fail("no value for existing key");
392     if(value != other_string)
393         fail("got different value than what was set");
394
395     if(!json_object_del(object, "nonexisting"))
396         fail("able to delete a nonexisting key");
397
398     if(json_object_del(object, "px"))
399         fail("unable to delete an existing key");
400
401     if(json_object_del(object, "a"))
402         fail("unable to delete an existing key");
403
404     if(json_object_del(object, "lp"))
405         fail("unable to delete an existing key");
406
407
408     /* add many keys to initiate rehashing */
409
410     if(json_object_set(object, "a", string))
411         fail("unable to set value");
412
413     if(json_object_set(object, "lp", string))
414         fail("unable to set value");
415
416     if(json_object_set(object, "px", string))
417         fail("unable to set value");
418
419     if(json_object_set(object, "c", string))
420         fail("unable to set value");
421
422     if(json_object_set(object, "d", string))
423         fail("unable to set value");
424
425     if(json_object_set(object, "e", string))
426         fail("unable to set value");
427
428
429     if(json_object_set_new(object, "foo", json_integer(123)))
430         fail("unable to set new value");
431
432     value = json_object_get(object, "foo");
433     if(!json_is_integer(value) || json_integer_value(value) != 123)
434         fail("json_object_set_new works incorrectly");
435
436     if(!json_object_set_new(object, NULL, json_integer(432)))
437         fail("able to set_new NULL key");
438
439     if(!json_object_set_new(object, "foo", NULL))
440         fail("able to set_new NULL value");
441
442     json_decref(string);
443     json_decref(other_string);
444     json_decref(object);
445 }
446
447 static void test_preserve_order()
448 {
449     json_t *object;
450     char *result;
451
452     const char *expected = "{\"foobar\": 1, \"bazquux\": 6, \"lorem ipsum\": 3, \"sit amet\": 5, \"helicopter\": 7}";
453
454     object = json_object();
455
456     json_object_set_new(object, "foobar", json_integer(1));
457     json_object_set_new(object, "bazquux", json_integer(2));
458     json_object_set_new(object, "lorem ipsum", json_integer(3));
459     json_object_set_new(object, "dolor", json_integer(4));
460     json_object_set_new(object, "sit amet", json_integer(5));
461
462     /* changing a value should preserve the order */
463     json_object_set_new(object, "bazquux", json_integer(6));
464
465     /* deletion shouldn't change the order of others */
466     json_object_del(object, "dolor");
467
468     /* add a new item just to make sure */
469     json_object_set_new(object, "helicopter", json_integer(7));
470
471     result = json_dumps(object, JSON_PRESERVE_ORDER);
472
473     if(strcmp(expected, result) != 0) {
474         fprintf(stderr, "%s != %s", expected, result);
475         fail("JSON_PRESERVE_ORDER doesn't work");
476     }
477
478     free(result);
479     json_decref(object);
480 }
481
482 static void test_foreach()
483 {
484     const char *key;
485     json_t *object1, *object2, *value;
486
487     object1 = json_pack("{sisisi}", "foo", 1, "bar", 2, "baz", 3);
488     object2 = json_object();
489
490     json_object_foreach(object1, key, value)
491         json_object_set(object2, key, value);
492
493     if(!json_equal(object1, object2))
494         fail("json_object_foreach failed to iterate all key-value pairs");
495
496     json_decref(object1);
497     json_decref(object2);
498 }
499
500 static void run_tests()
501 {
502     test_misc();
503     test_clear();
504     test_update();
505     test_conditional_updates();
506     test_circular();
507     test_set_nocheck();
508     test_iterators();
509     test_preserve_order();
510     test_foreach();
511 }