← Back to branch summary

~stub/ubuntu/trusty/avro-c/trunk

« back to all changes in this revision

Viewing changes to jansson/test/suites/api/test_unpack.c

  • Committer: Stuart Bishop
  • Date: 2015-05-14 11:53:53 UTC
  • Revision ID: stuart@stuartbishop.net-20150514115353-0cvnrcyohcq5l7yj
Tags: upstream-1.7.7
Import upstream version 1.7.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
jansson/test/suites/api/test_unpack.c
 
1
/*
 
2
 * Copyright (c) 2009-2011 Petri Lehtinen <petri@digip.org>
 
3
 * Copyright (c) 2010-2011 Graeme Smecher <graeme.smecher@mail.mcgill.ca>
 
4
 *
 
5
 * Jansson is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the MIT license. See LICENSE for details.
 
7
 */
 
8
 
 
9
#include <string.h>
 
10
#include <jansson.h>
 
11
#include <stdio.h>
 
12
#include "util.h"
 
13
 
 
14
int main()
 
15
{
 
16
    json_t *j, *j2;
 
17
    int i1, i2, i3;
 
18
    json_int_t I1;
 
19
    int rv;
 
20
    double f;
 
21
    char *s;
 
22
 
 
23
    json_error_t error;
 
24
 
 
25
    /*
 
26
     * Simple, valid json_pack cases
 
27
     */
 
28
 
 
29
    /* true */
 
30
    rv = json_unpack(json_true(), "b", &i1);
 
31
    if(rv || !i1)
 
32
        fail("json_unpack boolean failed");
 
33
 
 
34
    /* false */
 
35
    rv = json_unpack(json_false(), "b", &i1);
 
36
    if(rv || i1)
 
37
        fail("json_unpack boolean failed");
 
38
 
 
39
    /* null */
 
40
    if(json_unpack(json_null(), "n"))
 
41
        fail("json_unpack null failed");
 
42
 
 
43
    /* integer */
 
44
    j = json_integer(42);
 
45
    rv = json_unpack(j, "i", &i1);
 
46
    if(rv || i1 != 42)
 
47
        fail("json_unpack integer failed");
 
48
    json_decref(j);
 
49
 
 
50
    /* json_int_t */
 
51
    j = json_integer(5555555);
 
52
    rv = json_unpack(j, "I", &I1);
 
53
    if(rv || I1 != 5555555)
 
54
        fail("json_unpack json_int_t failed");
 
55
    json_decref(j);
 
56
 
 
57
    /* real */
 
58
    j = json_real(1.7);
 
59
    rv = json_unpack(j, "f", &f);
 
60
    if(rv || f != 1.7)
 
61
        fail("json_unpack real failed");
 
62
    json_decref(j);
 
63
 
 
64
    /* number */
 
65
    j = json_integer(12345);
 
66
    rv = json_unpack(j, "F", &f);
 
67
    if(rv || f != 12345.0)
 
68
        fail("json_unpack (real or) integer failed");
 
69
    json_decref(j);
 
70
 
 
71
    j = json_real(1.7);
 
72
    rv = json_unpack(j, "F", &f);
 
73
    if(rv || f != 1.7)
 
74
        fail("json_unpack real (or integer) failed");
 
75
    json_decref(j);
 
76
 
 
77
    /* string */
 
78
    j = json_string("foo");
 
79
    rv = json_unpack(j, "s", &s);
 
80
    if(rv || strcmp(s, "foo"))
 
81
        fail("json_unpack string failed");
 
82
    json_decref(j);
 
83
 
 
84
    /* empty object */
 
85
    j = json_object();
 
86
    if(json_unpack(j, "{}"))
 
87
        fail("json_unpack empty object failed");
 
88
    json_decref(j);
 
89
 
 
90
    /* empty list */
 
91
    j = json_array();
 
92
    if(json_unpack(j, "[]"))
 
93
        fail("json_unpack empty list failed");
 
94
    json_decref(j);
 
95
 
 
96
    /* non-incref'd object */
 
97
    j = json_object();
 
98
    rv = json_unpack(j, "o", &j2);
 
99
    if(j2 != j || j->refcount != 1)
 
100
        fail("json_unpack object failed");
 
101
    json_decref(j);
 
102
 
 
103
    /* incref'd object */
 
104
    j = json_object();
 
105
    rv = json_unpack(j, "O", &j2);
 
106
    if(j2 != j || j->refcount != 2)
 
107
        fail("json_unpack object failed");
 
108
    json_decref(j);
 
109
    json_decref(j);
 
110
 
 
111
    /* simple object */
 
112
    j = json_pack("{s:i}", "foo", 42);
 
113
    rv = json_unpack(j, "{s:i}", "foo", &i1);
 
114
    if(rv || i1 != 42)
 
115
        fail("json_unpack simple object failed");
 
116
    json_decref(j);
 
117
 
 
118
    /* simple array */
 
119
    j = json_pack("[iii]", 1, 2, 3);
 
120
    rv = json_unpack(j, "[i,i,i]", &i1, &i2, &i3);
 
121
    if(rv || i1 != 1 || i2 != 2 || i3 != 3)
 
122
        fail("json_unpack simple array failed");
 
123
    json_decref(j);
 
124
 
 
125
    /* object with many items & strict checking */
 
126
    j = json_pack("{s:i, s:i, s:i}", "a", 1, "b", 2, "c", 3);
 
127
    rv = json_unpack(j, "{s:i, s:i, s:i}", "a", &i1, "b", &i2, "c", &i3);
 
128
    if(rv || i1 != 1 || i2 != 2 || i3 != 3)
 
129
        fail("json_unpack object with many items failed");
 
130
    json_decref(j);
 
131
 
 
132
    /*
 
133
     * Invalid cases
 
134
     */
 
135
 
 
136
    j = json_integer(42);
 
137
    if(!json_unpack_ex(j, &error, 0, "z"))
 
138
        fail("json_unpack succeeded with invalid format character");
 
139
    check_error("Unexpected format character 'z'", "<format>", 1, 1, 1);
 
140
 
 
141
    if(!json_unpack_ex(NULL, &error, 0, "[i]"))
 
142
        fail("json_unpack succeeded with NULL root");
 
143
    check_error("NULL root value", "<root>", -1, -1, 0);
 
144
    json_decref(j);
 
145
 
 
146
    /* mismatched open/close array/object */
 
147
    j = json_pack("[]");
 
148
    if(!json_unpack_ex(j, &error, 0, "[}"))
 
149
        fail("json_unpack failed to catch mismatched ']'");
 
150
    check_error("Unexpected format character '}'", "<format>", 1, 2, 2);
 
151
    json_decref(j);
 
152
 
 
153
    j = json_pack("{}");
 
154
    if(!json_unpack_ex(j, &error, 0, "{]"))
 
155
        fail("json_unpack failed to catch mismatched '}'");
 
156
    check_error("Expected format 's', got ']'", "<format>", 1, 2, 2);
 
157
    json_decref(j);
 
158
 
 
159
    /* missing close array */
 
160
    j = json_pack("[]");
 
161
    if(!json_unpack_ex(j, &error, 0, "["))
 
162
        fail("json_unpack failed to catch missing ']'");
 
163
    check_error("Unexpected end of format string", "<format>", 1, 2, 2);
 
164
    json_decref(j);
 
165
 
 
166
    /* missing close object */
 
167
    j = json_pack("{}");
 
168
    if(!json_unpack_ex(j, &error, 0, "{"))
 
169
        fail("json_unpack failed to catch missing '}'");
 
170
    check_error("Unexpected end of format string", "<format>", 1, 2, 2);
 
171
    json_decref(j);
 
172
 
 
173
    /* garbage after format string */
 
174
    j = json_pack("[i]", 42);
 
175
    if(!json_unpack_ex(j, &error, 0, "[i]a", &i1))
 
176
        fail("json_unpack failed to catch garbage after format string");
 
177
    check_error("Garbage after format string", "<format>", 1, 4, 4);
 
178
    json_decref(j);
 
179
 
 
180
    j = json_integer(12345);
 
181
    if(!json_unpack_ex(j, &error, 0, "ia", &i1))
 
182
        fail("json_unpack failed to catch garbage after format string");
 
183
    check_error("Garbage after format string", "<format>", 1, 2, 2);
 
184
    json_decref(j);
 
185
 
 
186
    /* NULL format string */
 
187
    j = json_pack("[]");
 
188
    if(!json_unpack_ex(j, &error, 0, NULL))
 
189
        fail("json_unpack failed to catch null format string");
 
190
    check_error("NULL or empty format string", "<format>", -1, -1, 0);
 
191
    json_decref(j);
 
192
 
 
193
    /* NULL string pointer */
 
194
    j = json_string("foobie");
 
195
    if(!json_unpack_ex(j, &error, 0, "s", NULL))
 
196
        fail("json_unpack failed to catch null string pointer");
 
197
    check_error("NULL string argument", "<args>", 1, 1, 1);
 
198
    json_decref(j);
 
199
 
 
200
    /* invalid types */
 
201
    j = json_integer(42);
 
202
    j2 = json_string("foo");
 
203
    if(!json_unpack_ex(j, &error, 0, "s"))
 
204
        fail("json_unpack failed to catch invalid type");
 
205
    check_error("Expected string, got integer", "<validation>", 1, 1, 1);
 
206
 
 
207
    if(!json_unpack_ex(j, &error, 0, "n"))
 
208
        fail("json_unpack failed to catch invalid type");
 
209
    check_error("Expected null, got integer", "<validation>", 1, 1, 1);
 
210
 
 
211
    if(!json_unpack_ex(j, &error, 0, "b"))
 
212
        fail("json_unpack failed to catch invalid type");
 
213
    check_error("Expected true or false, got integer", "<validation>", 1, 1, 1);
 
214
 
 
215
    if(!json_unpack_ex(j2, &error, 0, "i"))
 
216
        fail("json_unpack failed to catch invalid type");
 
217
    check_error("Expected integer, got string", "<validation>", 1, 1, 1);
 
218
 
 
219
    if(!json_unpack_ex(j2, &error, 0, "I"))
 
220
        fail("json_unpack failed to catch invalid type");
 
221
    check_error("Expected integer, got string", "<validation>", 1, 1, 1);
 
222
 
 
223
    if(!json_unpack_ex(j, &error, 0, "f"))
 
224
        fail("json_unpack failed to catch invalid type");
 
225
    check_error("Expected real, got integer", "<validation>", 1, 1, 1);
 
226
 
 
227
    if(!json_unpack_ex(j2, &error, 0, "F"))
 
228
        fail("json_unpack failed to catch invalid type");
 
229
    check_error("Expected real or integer, got string", "<validation>", 1, 1, 1);
 
230
 
 
231
    if(!json_unpack_ex(j, &error, 0, "[i]"))
 
232
        fail("json_unpack failed to catch invalid type");
 
233
    check_error("Expected array, got integer", "<validation>", 1, 1, 1);
 
234
 
 
235
    if(!json_unpack_ex(j, &error, 0, "{si}", "foo"))
 
236
        fail("json_unpack failed to catch invalid type");
 
237
    check_error("Expected object, got integer", "<validation>", 1, 1, 1);
 
238
 
 
239
    json_decref(j);
 
240
    json_decref(j2);
 
241
 
 
242
    /* Array index out of range */
 
243
    j = json_pack("[i]", 1);
 
244
    if(!json_unpack_ex(j, &error, 0, "[ii]", &i1, &i2))
 
245
        fail("json_unpack failed to catch index out of array bounds");
 
246
    check_error("Array index 1 out of range", "<validation>", 1, 3, 3);
 
247
    json_decref(j);
 
248
 
 
249
    /* NULL object key */
 
250
    j = json_pack("{si}", "foo", 42);
 
251
    if(!json_unpack_ex(j, &error, 0, "{si}", NULL, &i1))
 
252
        fail("json_unpack failed to catch null string pointer");
 
253
    check_error("NULL object key", "<args>", 1, 2, 2);
 
254
    json_decref(j);
 
255
 
 
256
    /* Object key not found */
 
257
    j = json_pack("{si}", "foo", 42);
 
258
    if(!json_unpack_ex(j, &error, 0, "{si}", "baz", &i1))
 
259
        fail("json_unpack failed to catch null string pointer");
 
260
    check_error("Object item not found: baz", "<validation>", 1, 3, 3);
 
261
    json_decref(j);
 
262
 
 
263
    /*
 
264
     * Strict validation
 
265
     */
 
266
 
 
267
    j = json_pack("[iii]", 1, 2, 3);
 
268
    rv = json_unpack(j, "[iii!]", &i1, &i2, &i3);
 
269
    if(rv || i1 != 1 || i2 != 2 || i3 != 3)
 
270
        fail("json_unpack array with strict validation failed");
 
271
    json_decref(j);
 
272
 
 
273
    j = json_pack("[iii]", 1, 2, 3);
 
274
    if(!json_unpack_ex(j, &error, 0, "[ii!]", &i1, &i2))
 
275
        fail("json_unpack array with strict validation failed");
 
276
    check_error("1 array item(s) left unpacked", "<validation>", 1, 5, 5);
 
277
    json_decref(j);
 
278
 
 
279
    /* Like above, but with JSON_STRICT instead of '!' format */
 
280
    j = json_pack("[iii]", 1, 2, 3);
 
281
    if(!json_unpack_ex(j, &error, JSON_STRICT, "[ii]", &i1, &i2))
 
282
        fail("json_unpack array with strict validation failed");
 
283
    check_error("1 array item(s) left unpacked", "<validation>", 1, 4, 4);
 
284
    json_decref(j);
 
285
 
 
286
    j = json_pack("{s:s, s:i}", "foo", "bar", "baz", 42);
 
287
    rv = json_unpack(j, "{sssi!}", "foo", &s, "baz", &i1);
 
288
    if(rv || strcmp(s, "bar") != 0 || i1 != 42)
 
289
        fail("json_unpack object with strict validation failed");
 
290
    json_decref(j);
 
291
 
 
292
    /* Unpack the same item twice */
 
293
    j = json_pack("{s:s, s:i}", "foo", "bar", "baz", 42);
 
294
    if(!json_unpack_ex(j, &error, 0, "{s:s,s:s!}", "foo", &s, "foo", &s))
 
295
        fail("json_unpack object with strict validation failed");
 
296
    check_error("1 object item(s) left unpacked", "<validation>", 1, 10, 10);
 
297
    json_decref(j);
 
298
 
 
299
    j = json_pack("[i,{s:i,s:n},[i,i]]", 1, "foo", 2, "bar", 3, 4);
 
300
    if(json_unpack_ex(j, NULL, JSON_STRICT | JSON_VALIDATE_ONLY,
 
301
                      "[i{sisn}[ii]]", "foo", "bar"))
 
302
        fail("json_unpack complex value with strict validation failed");
 
303
    json_decref(j);
 
304
 
 
305
    /* ! and * must be last */
 
306
    j = json_pack("[ii]", 1, 2);
 
307
    if(!json_unpack_ex(j, &error, 0, "[i!i]", &i1, &i2))
 
308
        fail("json_unpack failed to catch ! in the middle of an array");
 
309
    check_error("Expected ']' after '!', got 'i'", "<format>", 1, 4, 4);
 
310
 
 
311
    if(!json_unpack_ex(j, &error, 0, "[i*i]", &i1, &i2))
 
312
        fail("json_unpack failed to catch * in the middle of an array");
 
313
    check_error("Expected ']' after '*', got 'i'", "<format>", 1, 4, 4);
 
314
    json_decref(j);
 
315
 
 
316
    j = json_pack("{sssi}", "foo", "bar", "baz", 42);
 
317
    if(!json_unpack_ex(j, &error, 0, "{ss!si}", "foo", &s, "baz", &i1))
 
318
        fail("json_unpack failed to catch ! in the middle of an object");
 
319
    check_error("Expected '}' after '!', got 's'", "<format>", 1, 5, 5);
 
320
 
 
321
    if(!json_unpack_ex(j, &error, 0, "{ss*si}", "foo", &s, "baz", &i1))
 
322
        fail("json_unpack failed to catch ! in the middle of an object");
 
323
    check_error("Expected '}' after '*', got 's'", "<format>", 1, 5, 5);
 
324
    json_decref(j);
 
325
 
 
326
    /* Error in nested object */
 
327
    j = json_pack("{s{snsn}}", "foo", "bar", "baz");
 
328
    if(!json_unpack_ex(j, &error, 0, "{s{sn!}}", "foo", "bar"))
 
329
        fail("json_unpack nested object with strict validation failed");
 
330
    check_error("1 object item(s) left unpacked", "<validation>", 1, 7, 7);
 
331
    json_decref(j);
 
332
 
 
333
    /* Error in nested array */
 
334
    j = json_pack("[[ii]]", 1, 2);
 
335
    if(!json_unpack_ex(j, &error, 0, "[[i!]]", &i1))
 
336
        fail("json_unpack nested array with strict validation failed");
 
337
    check_error("1 array item(s) left unpacked", "<validation>", 1, 5, 5);
 
338
    json_decref(j);
 
339
 
 
340
    return 0;
 
341
}