1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright (C) 2016 Intel Corporation.
3 * All rights reserved.
4 */
5
6 #include "spdk/stdinc.h"
7
8 #include "spdk_internal/cunit.h"
9
10 #include "json/json_parse.c"
11
12 #define JSONVALUE_NUM 100
13
14 static uint8_t g_buf[1000];
15 static void *g_end;
16 static struct spdk_json_val g_vals[JSONVALUE_NUM];
17 static int g_cur_val;
18
19 /* Fill buf with raw data */
20 #define BUF_SETUP(in) \
21 memset(g_buf, 0, sizeof(g_buf)); \
22 if (sizeof(in) > 1) { \
23 memcpy(g_buf, in, sizeof(in) - 1); \
24 } \
25 g_end = NULL
26
27 /*
28 * Do two checks - first pass NULL for values to ensure the count is correct,
29 * then pass g_vals to get the actual values.
30 */
31 #define PARSE_PASS_FLAGS(in, num_vals, trailing, flags) \
32 BUF_SETUP(in); \
33 CU_ASSERT(spdk_json_parse(g_buf, sizeof(in) - 1, NULL, 0, &g_end, flags) == num_vals); \
34 memset(g_vals, 0, sizeof(g_vals)); \
35 CU_ASSERT(spdk_json_parse(g_buf, sizeof(in) - 1, g_vals, JSONVALUE_NUM, &g_end, flags | SPDK_JSON_PARSE_FLAG_DECODE_IN_PLACE) == num_vals); \
36 CU_ASSERT(g_end == g_buf + sizeof(in) - sizeof(trailing)); \
37 CU_ASSERT(memcmp(g_end, trailing, sizeof(trailing) - 1) == 0); \
38 g_cur_val = 0
39
40 #define PARSE_PASS(in, num_vals, trailing) \
41 PARSE_PASS_FLAGS(in, num_vals, trailing, 0)
42
43 #define PARSE_FAIL_FLAGS(in, retval, flags) \
44 BUF_SETUP(in); \
45 CU_ASSERT(spdk_json_parse(g_buf, sizeof(in) - 1, NULL, 0, &g_end, flags) == retval)
46
47 #define PARSE_FAIL(in, retval) \
48 PARSE_FAIL_FLAGS(in, retval, 0)
49
50 #define VAL_STRING_MATCH(str, var_type) \
51 CU_ASSERT(g_vals[g_cur_val].type == var_type); \
52 CU_ASSERT(g_vals[g_cur_val].len == sizeof(str) - 1); \
53 if (g_vals[g_cur_val].len == sizeof(str) - 1 && sizeof(str) > 1) { \
54 CU_ASSERT(memcmp(g_vals[g_cur_val].start, str, g_vals[g_cur_val].len) == 0); \
55 } \
56 g_cur_val++
57
58 #define VAL_STRING(str) VAL_STRING_MATCH(str, SPDK_JSON_VAL_STRING)
59 #define VAL_NAME(str) VAL_STRING_MATCH(str, SPDK_JSON_VAL_NAME)
60 #define VAL_NUMBER(num) VAL_STRING_MATCH(num, SPDK_JSON_VAL_NUMBER)
61
62 #define VAL_LITERAL(str, val_type) \
63 CU_ASSERT(g_vals[g_cur_val].type == val_type); \
64 CU_ASSERT(g_vals[g_cur_val].len == strlen(str)); \
65 if (g_vals[g_cur_val].len == strlen(str)) { \
66 CU_ASSERT(memcmp(g_vals[g_cur_val].start, str, g_vals[g_cur_val].len) == 0); \
67 } \
68 g_cur_val++
69
70 #define VAL_TRUE() VAL_LITERAL("true", SPDK_JSON_VAL_TRUE)
71 #define VAL_FALSE() VAL_LITERAL("false", SPDK_JSON_VAL_FALSE)
72 #define VAL_NULL() VAL_LITERAL("null", SPDK_JSON_VAL_NULL)
73
74 #define VAL_ARRAY_BEGIN(count) \
75 CU_ASSERT(g_vals[g_cur_val].type == SPDK_JSON_VAL_ARRAY_BEGIN); \
76 CU_ASSERT(g_vals[g_cur_val].len == count); \
77 g_cur_val++
78
79 #define VAL_ARRAY_END() \
80 CU_ASSERT(g_vals[g_cur_val].type == SPDK_JSON_VAL_ARRAY_END); \
81 g_cur_val++
82
83 #define VAL_OBJECT_BEGIN(count) \
84 CU_ASSERT(g_vals[g_cur_val].type == SPDK_JSON_VAL_OBJECT_BEGIN); \
85 CU_ASSERT(g_vals[g_cur_val].len == count); \
86 g_cur_val++
87
88 #define VAL_OBJECT_END() \
89 CU_ASSERT(g_vals[g_cur_val].type == SPDK_JSON_VAL_OBJECT_END); \
90 g_cur_val++
91
92 /* Simplified macros for string-only testing */
93 #define STR_PASS(in, out) \
94 PARSE_PASS("\"" in "\"", 1, ""); \
95 VAL_STRING(out)
96
97 #define STR_FAIL(in, retval) \
98 PARSE_FAIL("\"" in "\"", retval)
99
100 /* Simplified macros for number-only testing (no whitespace allowed) */
101 #define NUM_PASS(in) \
102 PARSE_PASS(in, 1, ""); \
103 VAL_NUMBER(in)
104
105 #define NUM_FAIL(in, retval) \
106 PARSE_FAIL(in, retval)
107
108 static void
test_parse_literal(void)109 test_parse_literal(void)
110 {
111 PARSE_PASS("true", 1, "");
112 VAL_TRUE();
113
114 PARSE_PASS(" true ", 1, "");
115 VAL_TRUE();
116
117 PARSE_PASS("false", 1, "");
118 VAL_FALSE();
119
120 PARSE_PASS("null", 1, "");
121 VAL_NULL();
122
123 PARSE_PASS("trueaaa", 1, "aaa");
124 VAL_TRUE();
125
126 PARSE_PASS("truefalse", 1, "false");
127 VAL_TRUE();
128
129 PARSE_PASS("true false", 1, "false");
130 VAL_TRUE();
131
132 PARSE_PASS("true,false", 1, ",false");
133 VAL_TRUE();
134
135 PARSE_PASS("true,", 1, ",");
136 VAL_TRUE();
137
138 PARSE_FAIL("True", SPDK_JSON_PARSE_INVALID);
139 PARSE_FAIL("abcdef", SPDK_JSON_PARSE_INVALID);
140
141 PARSE_FAIL("t", SPDK_JSON_PARSE_INCOMPLETE);
142 PARSE_FAIL("tru", SPDK_JSON_PARSE_INCOMPLETE);
143 PARSE_FAIL("f", SPDK_JSON_PARSE_INCOMPLETE);
144 PARSE_FAIL("fals", SPDK_JSON_PARSE_INCOMPLETE);
145 PARSE_FAIL("n", SPDK_JSON_PARSE_INCOMPLETE);
146 PARSE_FAIL("nul", SPDK_JSON_PARSE_INCOMPLETE);
147
148 PARSE_FAIL("taaaaa", SPDK_JSON_PARSE_INVALID);
149 PARSE_FAIL("faaaaa", SPDK_JSON_PARSE_INVALID);
150 PARSE_FAIL("naaaaa", SPDK_JSON_PARSE_INVALID);
151 }
152
153 static void
test_parse_string_simple(void)154 test_parse_string_simple(void)
155 {
156 PARSE_PASS("\"\"", 1, "");
157 VAL_STRING("");
158
159 PARSE_PASS("\"hello world\"", 1, "");
160 VAL_STRING("hello world");
161
162 PARSE_PASS(" \"hello world\" ", 1, "");
163 VAL_STRING("hello world");
164
165 /* Unterminated string */
166 PARSE_FAIL("\"hello world", SPDK_JSON_PARSE_INCOMPLETE);
167
168 /* Trailing comma */
169 PARSE_PASS("\"hello world\",", 1, ",");
170 VAL_STRING("hello world");
171 }
172
173 static void
test_parse_string_control_chars(void)174 test_parse_string_control_chars(void)
175 {
176 /* U+0000 through U+001F must be escaped */
177 STR_FAIL("\x00", SPDK_JSON_PARSE_INVALID);
178 STR_FAIL("\x01", SPDK_JSON_PARSE_INVALID);
179 STR_FAIL("\x02", SPDK_JSON_PARSE_INVALID);
180 STR_FAIL("\x03", SPDK_JSON_PARSE_INVALID);
181 STR_FAIL("\x04", SPDK_JSON_PARSE_INVALID);
182 STR_FAIL("\x05", SPDK_JSON_PARSE_INVALID);
183 STR_FAIL("\x06", SPDK_JSON_PARSE_INVALID);
184 STR_FAIL("\x07", SPDK_JSON_PARSE_INVALID);
185 STR_FAIL("\x08", SPDK_JSON_PARSE_INVALID);
186 STR_FAIL("\x09", SPDK_JSON_PARSE_INVALID);
187 STR_FAIL("\x0A", SPDK_JSON_PARSE_INVALID);
188 STR_FAIL("\x0B", SPDK_JSON_PARSE_INVALID);
189 STR_FAIL("\x0C", SPDK_JSON_PARSE_INVALID);
190 STR_FAIL("\x0D", SPDK_JSON_PARSE_INVALID);
191 STR_FAIL("\x0E", SPDK_JSON_PARSE_INVALID);
192 STR_FAIL("\x0F", SPDK_JSON_PARSE_INVALID);
193 STR_FAIL("\x10", SPDK_JSON_PARSE_INVALID);
194 STR_FAIL("\x11", SPDK_JSON_PARSE_INVALID);
195 STR_FAIL("\x12", SPDK_JSON_PARSE_INVALID);
196 STR_FAIL("\x13", SPDK_JSON_PARSE_INVALID);
197 STR_FAIL("\x14", SPDK_JSON_PARSE_INVALID);
198 STR_FAIL("\x15", SPDK_JSON_PARSE_INVALID);
199 STR_FAIL("\x16", SPDK_JSON_PARSE_INVALID);
200 STR_FAIL("\x17", SPDK_JSON_PARSE_INVALID);
201 STR_FAIL("\x18", SPDK_JSON_PARSE_INVALID);
202 STR_FAIL("\x19", SPDK_JSON_PARSE_INVALID);
203 STR_FAIL("\x1A", SPDK_JSON_PARSE_INVALID);
204 STR_FAIL("\x1B", SPDK_JSON_PARSE_INVALID);
205 STR_FAIL("\x1C", SPDK_JSON_PARSE_INVALID);
206 STR_FAIL("\x1D", SPDK_JSON_PARSE_INVALID);
207 STR_FAIL("\x1E", SPDK_JSON_PARSE_INVALID);
208 STR_FAIL("\x1F", SPDK_JSON_PARSE_INVALID);
209 STR_PASS(" ", " "); /* \x20 (first valid unescaped char) */
210
211 /* Test control chars in the middle of a string */
212 STR_FAIL("abc\ndef", SPDK_JSON_PARSE_INVALID);
213 STR_FAIL("abc\tdef", SPDK_JSON_PARSE_INVALID);
214 }
215
216 static void
test_parse_string_utf8(void)217 test_parse_string_utf8(void)
218 {
219 /* Valid one-, two-, three-, and four-byte sequences */
220 STR_PASS("\x41", "A");
221 STR_PASS("\xC3\xB6", "\xC3\xB6");
222 STR_PASS("\xE2\x88\x9A", "\xE2\x88\x9A");
223 STR_PASS("\xF0\xA0\x9C\x8E", "\xF0\xA0\x9C\x8E");
224
225 /* Examples from RFC 3629 */
226 STR_PASS("\x41\xE2\x89\xA2\xCE\x91\x2E", "\x41\xE2\x89\xA2\xCE\x91\x2E");
227 STR_PASS("\xED\x95\x9C\xEA\xB5\xAD\xEC\x96\xB4", "\xED\x95\x9C\xEA\xB5\xAD\xEC\x96\xB4");
228 STR_PASS("\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E", "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E");
229 STR_PASS("\xEF\xBB\xBF\xF0\xA3\x8E\xB4", "\xEF\xBB\xBF\xF0\xA3\x8E\xB4");
230
231 /* Edge cases */
232 STR_PASS("\x7F", "\x7F");
233 STR_FAIL("\x80", SPDK_JSON_PARSE_INVALID);
234 STR_FAIL("\xC1", SPDK_JSON_PARSE_INVALID);
235 STR_FAIL("\xC2", SPDK_JSON_PARSE_INVALID);
236 STR_PASS("\xC2\x80", "\xC2\x80");
237 STR_PASS("\xC2\xBF", "\xC2\xBF");
238 STR_PASS("\xDF\x80", "\xDF\x80");
239 STR_PASS("\xDF\xBF", "\xDF\xBF");
240 STR_FAIL("\xDF", SPDK_JSON_PARSE_INVALID);
241 STR_FAIL("\xE0\x80", SPDK_JSON_PARSE_INVALID);
242 STR_FAIL("\xE0\x1F", SPDK_JSON_PARSE_INVALID);
243 STR_FAIL("\xE0\x1F\x80", SPDK_JSON_PARSE_INVALID);
244 STR_FAIL("\xE0", SPDK_JSON_PARSE_INVALID);
245 STR_FAIL("\xE0\xA0", SPDK_JSON_PARSE_INVALID);
246 STR_PASS("\xE0\xA0\x80", "\xE0\xA0\x80");
247 STR_PASS("\xE0\xA0\xBF", "\xE0\xA0\xBF");
248 STR_FAIL("\xE0\xA0\xC0", SPDK_JSON_PARSE_INVALID);
249 STR_PASS("\xE0\xBF\x80", "\xE0\xBF\x80");
250 STR_PASS("\xE0\xBF\xBF", "\xE0\xBF\xBF");
251 STR_FAIL("\xE0\xC0\x80", SPDK_JSON_PARSE_INVALID);
252 STR_FAIL("\xE1", SPDK_JSON_PARSE_INVALID);
253 STR_FAIL("\xE1\x80", SPDK_JSON_PARSE_INVALID);
254 STR_FAIL("\xE1\x7F\x80", SPDK_JSON_PARSE_INVALID);
255 STR_FAIL("\xE1\x80\x7F", SPDK_JSON_PARSE_INVALID);
256 STR_PASS("\xE1\x80\x80", "\xE1\x80\x80");
257 STR_PASS("\xE1\x80\xBF", "\xE1\x80\xBF");
258 STR_PASS("\xE1\xBF\x80", "\xE1\xBF\x80");
259 STR_PASS("\xE1\xBF\xBF", "\xE1\xBF\xBF");
260 STR_FAIL("\xE1\xC0\x80", SPDK_JSON_PARSE_INVALID);
261 STR_FAIL("\xE1\x80\xC0", SPDK_JSON_PARSE_INVALID);
262 STR_PASS("\xEF\x80\x80", "\xEF\x80\x80");
263 STR_PASS("\xEF\xBF\xBF", "\xEF\xBF\xBF");
264 STR_FAIL("\xF0", SPDK_JSON_PARSE_INVALID);
265 STR_FAIL("\xF0\x90", SPDK_JSON_PARSE_INVALID);
266 STR_FAIL("\xF0\x90\x80", SPDK_JSON_PARSE_INVALID);
267 STR_FAIL("\xF0\x80\x80\x80", SPDK_JSON_PARSE_INVALID);
268 STR_FAIL("\xF0\x8F\x80\x80", SPDK_JSON_PARSE_INVALID);
269 STR_PASS("\xF0\x90\x80\x80", "\xF0\x90\x80\x80");
270 STR_PASS("\xF0\x90\x80\xBF", "\xF0\x90\x80\xBF");
271 STR_PASS("\xF0\x90\xBF\x80", "\xF0\x90\xBF\x80");
272 STR_PASS("\xF0\xBF\x80\x80", "\xF0\xBF\x80\x80");
273 STR_FAIL("\xF0\xC0\x80\x80", SPDK_JSON_PARSE_INVALID);
274 STR_FAIL("\xF1", SPDK_JSON_PARSE_INVALID);
275 STR_FAIL("\xF1\x80", SPDK_JSON_PARSE_INVALID);
276 STR_FAIL("\xF1\x80\x80", SPDK_JSON_PARSE_INVALID);
277 STR_FAIL("\xF1\x80\x80\x7F", SPDK_JSON_PARSE_INVALID);
278 STR_PASS("\xF1\x80\x80\x80", "\xF1\x80\x80\x80");
279 STR_PASS("\xF1\x80\x80\xBF", "\xF1\x80\x80\xBF");
280 STR_PASS("\xF1\x80\xBF\x80", "\xF1\x80\xBF\x80");
281 STR_PASS("\xF1\xBF\x80\x80", "\xF1\xBF\x80\x80");
282 STR_PASS("\xF3\x80\x80\x80", "\xF3\x80\x80\x80");
283 STR_FAIL("\xF3\xC0\x80\x80", SPDK_JSON_PARSE_INVALID);
284 STR_FAIL("\xF3\x80\xC0\x80", SPDK_JSON_PARSE_INVALID);
285 STR_FAIL("\xF3\x80\x80\xC0", SPDK_JSON_PARSE_INVALID);
286 STR_FAIL("\xF4", SPDK_JSON_PARSE_INVALID);
287 STR_FAIL("\xF4\x80", SPDK_JSON_PARSE_INVALID);
288 STR_FAIL("\xF4\x80\x80", SPDK_JSON_PARSE_INVALID);
289 STR_PASS("\xF4\x80\x80\x80", "\xF4\x80\x80\x80");
290 STR_PASS("\xF4\x8F\x80\x80", "\xF4\x8F\x80\x80");
291 STR_PASS("\xF4\x8F\xBF\xBF", "\xF4\x8F\xBF\xBF");
292 STR_FAIL("\xF4\x90\x80\x80", SPDK_JSON_PARSE_INVALID);
293 STR_FAIL("\xF5", SPDK_JSON_PARSE_INVALID);
294 STR_FAIL("\xF5\x80", SPDK_JSON_PARSE_INVALID);
295 STR_FAIL("\xF5\x80\x80", SPDK_JSON_PARSE_INVALID);
296 STR_FAIL("\xF5\x80\x80\x80", SPDK_JSON_PARSE_INVALID);
297 STR_FAIL("\xF5\x80\x80\x80\x80", SPDK_JSON_PARSE_INVALID);
298
299 /* Overlong encodings */
300 STR_FAIL("\xC0\x80", SPDK_JSON_PARSE_INVALID);
301
302 /* Surrogate pairs */
303 STR_FAIL("\xED\xA0\x80", SPDK_JSON_PARSE_INVALID); /* U+D800 First high surrogate */
304 STR_FAIL("\xED\xAF\xBF", SPDK_JSON_PARSE_INVALID); /* U+DBFF Last high surrogate */
305 STR_FAIL("\xED\xB0\x80", SPDK_JSON_PARSE_INVALID); /* U+DC00 First low surrogate */
306 STR_FAIL("\xED\xBF\xBF", SPDK_JSON_PARSE_INVALID); /* U+DFFF Last low surrogate */
307 STR_FAIL("\xED\xA1\x8C\xED\xBE\xB4",
308 SPDK_JSON_PARSE_INVALID); /* U+233B4 (invalid surrogate pair encoding) */
309 }
310
311 static void
test_parse_string_escapes_twochar(void)312 test_parse_string_escapes_twochar(void)
313 {
314 STR_PASS("\\\"", "\"");
315 STR_PASS("\\\\", "\\");
316 STR_PASS("\\/", "/");
317 STR_PASS("\\b", "\b");
318 STR_PASS("\\f", "\f");
319 STR_PASS("\\n", "\n");
320 STR_PASS("\\r", "\r");
321 STR_PASS("\\t", "\t");
322
323 STR_PASS("abc\\tdef", "abc\tdef");
324 STR_PASS("abc\\\"def", "abc\"def");
325
326 /* Backslash at end of string (will be treated as escaped quote) */
327 STR_FAIL("\\", SPDK_JSON_PARSE_INCOMPLETE);
328 STR_FAIL("abc\\", SPDK_JSON_PARSE_INCOMPLETE);
329
330 /* Invalid C-like escapes */
331 STR_FAIL("\\a", SPDK_JSON_PARSE_INVALID);
332 STR_FAIL("\\v", SPDK_JSON_PARSE_INVALID);
333 STR_FAIL("\\'", SPDK_JSON_PARSE_INVALID);
334 STR_FAIL("\\?", SPDK_JSON_PARSE_INVALID);
335 STR_FAIL("\\0", SPDK_JSON_PARSE_INVALID);
336 STR_FAIL("\\x00", SPDK_JSON_PARSE_INVALID);
337
338 /* Other invalid escapes */
339 STR_FAIL("\\B", SPDK_JSON_PARSE_INVALID);
340 STR_FAIL("\\z", SPDK_JSON_PARSE_INVALID);
341 }
342
343 static void
test_parse_string_escapes_unicode(void)344 test_parse_string_escapes_unicode(void)
345 {
346 STR_PASS("\\u0000", "\0");
347 STR_PASS("\\u0001", "\1");
348 STR_PASS("\\u0041", "A");
349 STR_PASS("\\uAAAA", "\xEA\xAA\xAA");
350 STR_PASS("\\uaaaa", "\xEA\xAA\xAA");
351 STR_PASS("\\uAaAa", "\xEA\xAA\xAA");
352
353 STR_FAIL("\\u", SPDK_JSON_PARSE_INVALID);
354 STR_FAIL("\\u0", SPDK_JSON_PARSE_INVALID);
355 STR_FAIL("\\u00", SPDK_JSON_PARSE_INVALID);
356 STR_FAIL("\\u000", SPDK_JSON_PARSE_INVALID);
357 STR_FAIL("\\u000g", SPDK_JSON_PARSE_INVALID);
358 STR_FAIL("\\U", SPDK_JSON_PARSE_INVALID);
359 STR_FAIL("\\U0000", SPDK_JSON_PARSE_INVALID);
360
361 PARSE_FAIL("\"\\u", SPDK_JSON_PARSE_INCOMPLETE);
362 PARSE_FAIL("\"\\u0", SPDK_JSON_PARSE_INCOMPLETE);
363 PARSE_FAIL("\"\\u00", SPDK_JSON_PARSE_INCOMPLETE);
364 PARSE_FAIL("\"\\u000", SPDK_JSON_PARSE_INCOMPLETE);
365
366 /* Surrogate pair */
367 STR_PASS("\\uD834\\uDD1E", "\xF0\x9D\x84\x9E");
368
369 /* Low surrogate without high */
370 STR_FAIL("\\uDC00", SPDK_JSON_PARSE_INVALID);
371 STR_FAIL("\\uDC00\\uDC00", SPDK_JSON_PARSE_INVALID);
372 STR_FAIL("\\uDC00abcdef", SPDK_JSON_PARSE_INVALID);
373 STR_FAIL("\\uDEAD", SPDK_JSON_PARSE_INVALID);
374 PARSE_FAIL("\"\\uD834", SPDK_JSON_PARSE_INCOMPLETE);
375 PARSE_FAIL("\"\\uD834\\", SPDK_JSON_PARSE_INCOMPLETE);
376 PARSE_FAIL("\"\\uD834\\u", SPDK_JSON_PARSE_INCOMPLETE);
377 PARSE_FAIL("\"\\uD834\\uD", SPDK_JSON_PARSE_INCOMPLETE);
378 PARSE_FAIL("\"\\uD834\\uDD1", SPDK_JSON_PARSE_INCOMPLETE);
379
380 /* High surrogate without low */
381 STR_FAIL("\\uD800", SPDK_JSON_PARSE_INVALID);
382 STR_FAIL("\\uD800abcdef", SPDK_JSON_PARSE_INVALID);
383
384 /* High surrogate followed by high surrogate */
385 STR_FAIL("\\uD800\\uD800", SPDK_JSON_PARSE_INVALID);
386 }
387
388 static void
test_parse_number(void)389 test_parse_number(void)
390 {
391 NUM_PASS("0");
392 NUM_PASS("1");
393 NUM_PASS("100");
394 NUM_PASS("-1");
395 NUM_PASS("-0");
396 NUM_PASS("3.0");
397 NUM_PASS("3.00");
398 NUM_PASS("3.001");
399 NUM_PASS("3.14159");
400 NUM_PASS("3.141592653589793238462643383279");
401 NUM_PASS("1e400");
402 NUM_PASS("1E400");
403 NUM_PASS("0e10");
404 NUM_PASS("0e0");
405 NUM_PASS("-0e0");
406 NUM_PASS("-0e+0");
407 NUM_PASS("-0e-0");
408 NUM_PASS("1e+400");
409 NUM_PASS("1e-400");
410 NUM_PASS("6.022e23");
411 NUM_PASS("-1.234e+56");
412 NUM_PASS("1.23e+56");
413 NUM_PASS("-1.23e-56");
414 NUM_PASS("1.23e-56");
415 NUM_PASS("1e04");
416
417 /* Trailing garbage */
418 PARSE_PASS("0A", 1, "A");
419 VAL_NUMBER("0");
420
421 PARSE_PASS("0,", 1, ",");
422 VAL_NUMBER("0");
423
424 PARSE_PASS("0true", 1, "true");
425 VAL_NUMBER("0");
426
427 PARSE_PASS("00", 1, "0");
428 VAL_NUMBER("0");
429 PARSE_FAIL("[00", SPDK_JSON_PARSE_INVALID);
430
431 PARSE_PASS("007", 1, "07");
432 VAL_NUMBER("0");
433 PARSE_FAIL("[007]", SPDK_JSON_PARSE_INVALID);
434
435 PARSE_PASS("345.678.1", 1, ".1");
436 VAL_NUMBER("345.678");
437 PARSE_FAIL("[345.678.1]", SPDK_JSON_PARSE_INVALID);
438
439 PARSE_PASS("3.2e-4+5", 1, "+5");
440 VAL_NUMBER("3.2e-4");
441 PARSE_FAIL("[3.2e-4+5]", SPDK_JSON_PARSE_INVALID);
442
443 PARSE_PASS("3.4.5", 1, ".5");
444 VAL_NUMBER("3.4");
445 PARSE_FAIL("[3.4.5]", SPDK_JSON_PARSE_INVALID);
446
447 NUM_FAIL("345.", SPDK_JSON_PARSE_INCOMPLETE);
448 NUM_FAIL("+1", SPDK_JSON_PARSE_INVALID);
449 NUM_FAIL("--1", SPDK_JSON_PARSE_INVALID);
450 NUM_FAIL("3.", SPDK_JSON_PARSE_INCOMPLETE);
451 NUM_FAIL("3.+4", SPDK_JSON_PARSE_INVALID);
452 NUM_FAIL("3.2e+-4", SPDK_JSON_PARSE_INVALID);
453 NUM_FAIL("3.2e-+4", SPDK_JSON_PARSE_INVALID);
454 NUM_FAIL("3e+", SPDK_JSON_PARSE_INCOMPLETE);
455 NUM_FAIL("3e-", SPDK_JSON_PARSE_INCOMPLETE);
456 NUM_FAIL("3.e4", SPDK_JSON_PARSE_INVALID);
457 NUM_FAIL("3.2eX", SPDK_JSON_PARSE_INVALID);
458 NUM_FAIL("-", SPDK_JSON_PARSE_INCOMPLETE);
459 NUM_FAIL("NaN", SPDK_JSON_PARSE_INVALID);
460 NUM_FAIL(".123", SPDK_JSON_PARSE_INVALID);
461 }
462
463 static void
test_parse_array(void)464 test_parse_array(void)
465 {
466 char buffer[SPDK_JSON_MAX_NESTING_DEPTH + 2] = {0};
467
468 PARSE_PASS("[]", 2, "");
469 VAL_ARRAY_BEGIN(0);
470 VAL_ARRAY_END();
471
472 PARSE_PASS("[true]", 3, "");
473 VAL_ARRAY_BEGIN(1);
474 VAL_TRUE();
475 VAL_ARRAY_END();
476
477 PARSE_PASS("[true, false]", 4, "");
478 VAL_ARRAY_BEGIN(2);
479 VAL_TRUE();
480 VAL_FALSE();
481 VAL_ARRAY_END();
482
483 PARSE_PASS("[\"hello\"]", 3, "");
484 VAL_ARRAY_BEGIN(1);
485 VAL_STRING("hello");
486 VAL_ARRAY_END();
487
488 PARSE_PASS("[[]]", 4, "");
489 VAL_ARRAY_BEGIN(2);
490 VAL_ARRAY_BEGIN(0);
491 VAL_ARRAY_END();
492 VAL_ARRAY_END();
493
494 PARSE_PASS("[\"hello\", \"world\"]", 4, "");
495 VAL_ARRAY_BEGIN(2);
496 VAL_STRING("hello");
497 VAL_STRING("world");
498 VAL_ARRAY_END();
499
500 PARSE_PASS("[],", 2, ",");
501 VAL_ARRAY_BEGIN(0);
502 VAL_ARRAY_END();
503
504 PARSE_FAIL("]", SPDK_JSON_PARSE_INVALID);
505 PARSE_FAIL("[", SPDK_JSON_PARSE_INCOMPLETE);
506 PARSE_FAIL("[true", SPDK_JSON_PARSE_INCOMPLETE);
507 PARSE_FAIL("[\"hello", SPDK_JSON_PARSE_INCOMPLETE);
508 PARSE_FAIL("[\"hello\"", SPDK_JSON_PARSE_INCOMPLETE);
509 PARSE_FAIL("[true,]", SPDK_JSON_PARSE_INVALID);
510 PARSE_FAIL("[,]", SPDK_JSON_PARSE_INVALID);
511 PARSE_FAIL("[,true]", SPDK_JSON_PARSE_INVALID);
512 PARSE_FAIL("[true}", SPDK_JSON_PARSE_INVALID);
513 PARSE_FAIL("[true,,true]", SPDK_JSON_PARSE_INVALID);
514
515 /* Nested arrays exactly up to the allowed nesting depth */
516 memset(buffer, '[', SPDK_JSON_MAX_NESTING_DEPTH);
517 buffer[SPDK_JSON_MAX_NESTING_DEPTH] = ' ';
518 PARSE_FAIL(buffer, SPDK_JSON_PARSE_INCOMPLETE);
519
520 /* Nested arrays exceeding the maximum allowed nesting depth for this implementation */
521 buffer[SPDK_JSON_MAX_NESTING_DEPTH] = '[';
522 PARSE_FAIL(buffer, SPDK_JSON_PARSE_MAX_DEPTH_EXCEEDED);
523 }
524
525 static void
test_parse_object(void)526 test_parse_object(void)
527 {
528 PARSE_PASS("{}", 2, "");
529 VAL_OBJECT_BEGIN(0);
530 VAL_OBJECT_END();
531
532 PARSE_PASS("{\"a\": true}", 4, "");
533 VAL_OBJECT_BEGIN(2);
534 VAL_NAME("a");
535 VAL_TRUE();
536 VAL_OBJECT_END();
537
538 PARSE_PASS("{\"abc\": \"def\"}", 4, "");
539 VAL_OBJECT_BEGIN(2);
540 VAL_NAME("abc");
541 VAL_STRING("def");
542 VAL_OBJECT_END();
543
544 PARSE_PASS("{\"a\": true, \"b\": false}", 6, "");
545 VAL_OBJECT_BEGIN(4);
546 VAL_NAME("a");
547 VAL_TRUE();
548 VAL_NAME("b");
549 VAL_FALSE();
550 VAL_OBJECT_END();
551
552 PARSE_PASS("{\"a\": { \"b\": true } }", 7, "");
553 VAL_OBJECT_BEGIN(5);
554 VAL_NAME("a");
555 VAL_OBJECT_BEGIN(2);
556 VAL_NAME("b");
557 VAL_TRUE();
558 VAL_OBJECT_END();
559 VAL_OBJECT_END();
560
561 PARSE_PASS("{\"{test\": 0}", 4, "");
562 VAL_OBJECT_BEGIN(2);
563 VAL_NAME("{test");
564 VAL_NUMBER("0");
565 VAL_OBJECT_END();
566
567 PARSE_PASS("{\"test}\": 1}", 4, "");
568 VAL_OBJECT_BEGIN(2);
569 VAL_NAME("test}");
570 VAL_NUMBER("1");
571 VAL_OBJECT_END();
572
573 PARSE_PASS("{\"\\\"\": 2}", 4, "");
574 VAL_OBJECT_BEGIN(2);
575 VAL_NAME("\"");
576 VAL_NUMBER("2");
577 VAL_OBJECT_END();
578
579 PARSE_PASS("{\"a\":true},", 4, ",");
580 VAL_OBJECT_BEGIN(2);
581 VAL_NAME("a");
582 VAL_TRUE();
583 VAL_OBJECT_END();
584
585 /* Object end without object begin (trailing garbage) */
586 PARSE_PASS("true}", 1, "}");
587 VAL_TRUE();
588
589 PARSE_PASS("0}", 1, "}");
590 VAL_NUMBER("0");
591
592 PARSE_PASS("\"a\"}", 1, "}");
593 VAL_STRING("a");
594
595 PARSE_FAIL("}", SPDK_JSON_PARSE_INVALID);
596 PARSE_FAIL("{", SPDK_JSON_PARSE_INCOMPLETE);
597 PARSE_FAIL("{\"a", SPDK_JSON_PARSE_INCOMPLETE);
598 PARSE_FAIL("{\"a\"", SPDK_JSON_PARSE_INCOMPLETE);
599 PARSE_FAIL("{\"a\":", SPDK_JSON_PARSE_INCOMPLETE);
600 PARSE_FAIL("{\"a\":true", SPDK_JSON_PARSE_INCOMPLETE);
601 PARSE_FAIL("{\"a\":true,", SPDK_JSON_PARSE_INCOMPLETE);
602 PARSE_FAIL("{\"a\":true]", SPDK_JSON_PARSE_INVALID);
603 PARSE_FAIL("{\"a\":true,}", SPDK_JSON_PARSE_INVALID);
604 PARSE_FAIL("{\"a\":true,\"}", SPDK_JSON_PARSE_INCOMPLETE);
605 PARSE_FAIL("{\"a\":true,\"b}", SPDK_JSON_PARSE_INCOMPLETE);
606 PARSE_FAIL("{\"a\":true,\"b\"}", SPDK_JSON_PARSE_INVALID);
607 PARSE_FAIL("{\"a\":true,\"b\":}", SPDK_JSON_PARSE_INVALID);
608 PARSE_FAIL("{\"a\":true,\"b\",}", SPDK_JSON_PARSE_INVALID);
609 PARSE_FAIL("{\"a\",}", SPDK_JSON_PARSE_INVALID);
610 PARSE_FAIL("{,\"a\": true}", SPDK_JSON_PARSE_INVALID);
611 PARSE_FAIL("{a:true}", SPDK_JSON_PARSE_INVALID);
612 PARSE_FAIL("{'a':true}", SPDK_JSON_PARSE_INVALID);
613 }
614
615 static void
test_parse_nesting(void)616 test_parse_nesting(void)
617 {
618 PARSE_PASS("[[[[[[[[]]]]]]]]", 16, "");
619
620 PARSE_PASS("{\"a\": [0, 1, 2]}", 8, "");
621 VAL_OBJECT_BEGIN(6);
622 VAL_NAME("a");
623 VAL_ARRAY_BEGIN(3);
624 VAL_NUMBER("0");
625 VAL_NUMBER("1");
626 VAL_NUMBER("2");
627 VAL_ARRAY_END();
628 VAL_OBJECT_END();
629
630 PARSE_PASS("{\"a\": [0, 1, 2], \"b\": 3 }", 10, "");
631 VAL_OBJECT_BEGIN(8);
632 VAL_NAME("a");
633 VAL_ARRAY_BEGIN(3);
634 VAL_NUMBER("0");
635 VAL_NUMBER("1");
636 VAL_NUMBER("2");
637 VAL_ARRAY_END();
638 VAL_NAME("b");
639 VAL_NUMBER("3");
640 VAL_OBJECT_END();
641
642 PARSE_PASS("[0, 1, {\"a\": 3}, 4, 5]", 10, "");
643 VAL_ARRAY_BEGIN(8);
644 VAL_NUMBER("0");
645 VAL_NUMBER("1");
646 VAL_OBJECT_BEGIN(2);
647 VAL_NAME("a");
648 VAL_NUMBER("3");
649 VAL_OBJECT_END();
650 VAL_NUMBER("4");
651 VAL_NUMBER("5");
652 VAL_ARRAY_END();
653
654 PARSE_PASS("\t[ { \"a\": {\"b\": [ {\"c\": 1}, 2 ],\n\"d\": 3}, \"e\" : 4}, 5 ] ", 20, "");
655 VAL_ARRAY_BEGIN(18);
656 VAL_OBJECT_BEGIN(15);
657 VAL_NAME("a");
658 VAL_OBJECT_BEGIN(10);
659 VAL_NAME("b");
660 VAL_ARRAY_BEGIN(5);
661 VAL_OBJECT_BEGIN(2);
662 VAL_NAME("c");
663 VAL_NUMBER("1");
664 VAL_OBJECT_END();
665 VAL_NUMBER("2");
666 VAL_ARRAY_END();
667 VAL_NAME("d");
668 VAL_NUMBER("3");
669 VAL_OBJECT_END();
670 VAL_NAME("e");
671 VAL_NUMBER("4");
672 VAL_OBJECT_END();
673 VAL_NUMBER("5");
674 VAL_ARRAY_END();
675
676 /* Examples from RFC 7159 */
677 PARSE_PASS(
678 "{\n"
679 " \"Image\": {\n"
680 " \"Width\": 800,\n"
681 " \"Height\": 600,\n"
682 " \"Title\": \"View from 15th Floor\",\n"
683 " \"Thumbnail\": {\n"
684 " \"Url\": \"http://www.example.com/image/481989943\",\n"
685 " \"Height\": 125,\n"
686 " \"Width\": 100\n"
687 " },\n"
688 " \"Animated\" : false,\n"
689 " \"IDs\": [116, 943, 234, 38793]\n"
690 " }\n"
691 "}\n",
692 29, "");
693
694 VAL_OBJECT_BEGIN(27);
695 VAL_NAME("Image");
696 VAL_OBJECT_BEGIN(24);
697 VAL_NAME("Width");
698 VAL_NUMBER("800");
699 VAL_NAME("Height");
700 VAL_NUMBER("600");
701 VAL_NAME("Title");
702 VAL_STRING("View from 15th Floor");
703 VAL_NAME("Thumbnail");
704 VAL_OBJECT_BEGIN(6);
705 VAL_NAME("Url");
706 VAL_STRING("http://www.example.com/image/481989943");
707 VAL_NAME("Height");
708 VAL_NUMBER("125");
709 VAL_NAME("Width");
710 VAL_NUMBER("100");
711 VAL_OBJECT_END();
712 VAL_NAME("Animated");
713 VAL_FALSE();
714 VAL_NAME("IDs");
715 VAL_ARRAY_BEGIN(4);
716 VAL_NUMBER("116");
717 VAL_NUMBER("943");
718 VAL_NUMBER("234");
719 VAL_NUMBER("38793");
720 VAL_ARRAY_END();
721 VAL_OBJECT_END();
722 VAL_OBJECT_END();
723
724 PARSE_PASS(
725 "[\n"
726 " {\n"
727 " \"precision\": \"zip\",\n"
728 " \"Latitude\": 37.7668,\n"
729 " \"Longitude\": -122.3959,\n"
730 " \"Address\": \"\",\n"
731 " \"City\": \"SAN FRANCISCO\",\n"
732 " \"State\": \"CA\",\n"
733 " \"Zip\": \"94107\",\n"
734 " \"Country\": \"US\"\n"
735 " },\n"
736 " {\n"
737 " \"precision\": \"zip\",\n"
738 " \"Latitude\": 37.371991,\n"
739 " \"Longitude\": -122.026020,\n"
740 " \"Address\": \"\",\n"
741 " \"City\": \"SUNNYVALE\",\n"
742 " \"State\": \"CA\",\n"
743 " \"Zip\": \"94085\",\n"
744 " \"Country\": \"US\"\n"
745 " }\n"
746 "]",
747 38, "");
748
749 VAL_ARRAY_BEGIN(36);
750 VAL_OBJECT_BEGIN(16);
751 VAL_NAME("precision");
752 VAL_STRING("zip");
753 VAL_NAME("Latitude");
754 VAL_NUMBER("37.7668");
755 VAL_NAME("Longitude");
756 VAL_NUMBER("-122.3959");
757 VAL_NAME("Address");
758 VAL_STRING("");
759 VAL_NAME("City");
760 VAL_STRING("SAN FRANCISCO");
761 VAL_NAME("State");
762 VAL_STRING("CA");
763 VAL_NAME("Zip");
764 VAL_STRING("94107");
765 VAL_NAME("Country");
766 VAL_STRING("US");
767 VAL_OBJECT_END();
768 VAL_OBJECT_BEGIN(16);
769 VAL_NAME("precision");
770 VAL_STRING("zip");
771 VAL_NAME("Latitude");
772 VAL_NUMBER("37.371991");
773 VAL_NAME("Longitude");
774 VAL_NUMBER("-122.026020");
775 VAL_NAME("Address");
776 VAL_STRING("");
777 VAL_NAME("City");
778 VAL_STRING("SUNNYVALE");
779 VAL_NAME("State");
780 VAL_STRING("CA");
781 VAL_NAME("Zip");
782 VAL_STRING("94085");
783 VAL_NAME("Country");
784 VAL_STRING("US");
785 VAL_OBJECT_END();
786 VAL_ARRAY_END();
787
788 /* Trailing garbage */
789 PARSE_PASS("{\"a\": [0, 1, 2]}]", 8, "]");
790 VAL_OBJECT_BEGIN(6);
791 VAL_NAME("a");
792 VAL_ARRAY_BEGIN(3);
793 VAL_NUMBER("0");
794 VAL_NUMBER("1");
795 VAL_NUMBER("2");
796 VAL_ARRAY_END();
797 VAL_OBJECT_END();
798
799 PARSE_PASS("{\"a\": [0, 1, 2]}}", 8, "}");
800 PARSE_PASS("{\"a\": [0, 1, 2]}]", 8, "]");
801 VAL_OBJECT_BEGIN(6);
802 VAL_NAME("a");
803 VAL_ARRAY_BEGIN(3);
804 VAL_NUMBER("0");
805 VAL_NUMBER("1");
806 VAL_NUMBER("2");
807 VAL_ARRAY_END();
808 VAL_OBJECT_END();
809
810 PARSE_FAIL("{\"a\": [0, 1, 2}]", SPDK_JSON_PARSE_INVALID);
811 PARSE_FAIL("{\"a\": [0, 1, 2]", SPDK_JSON_PARSE_INCOMPLETE);
812 }
813
814
815 static void
test_parse_comment(void)816 test_parse_comment(void)
817 {
818 /* Comments are not allowed by the JSON RFC */
819 PARSE_PASS("[0]", 3, "");
820 PARSE_FAIL("/* test */[0]", SPDK_JSON_PARSE_INVALID);
821 PARSE_FAIL("[/* test */0]", SPDK_JSON_PARSE_INVALID);
822 PARSE_FAIL("[0/* test */]", SPDK_JSON_PARSE_INVALID);
823
824 /*
825 * This is allowed since the parser stops once it reads a complete JSON object.
826 * The next parse call would fail (see tests above) when parsing the comment.
827 */
828 PARSE_PASS("[0]/* test */", 3, "/* test */");
829
830 /*
831 * Test with non-standard comments enabled.
832 */
833 PARSE_PASS_FLAGS("/* test */[0]", 3, "", SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
834 VAL_ARRAY_BEGIN(1);
835 VAL_NUMBER("0");
836 VAL_ARRAY_END();
837
838 PARSE_PASS_FLAGS("[/* test */0]", 3, "", SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
839 VAL_ARRAY_BEGIN(1);
840 VAL_NUMBER("0");
841 VAL_ARRAY_END();
842
843 PARSE_PASS_FLAGS("[0/* test */]", 3, "", SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
844 VAL_ARRAY_BEGIN(1);
845 VAL_NUMBER("0");
846 VAL_ARRAY_END();
847
848 PARSE_FAIL_FLAGS("/* test */", SPDK_JSON_PARSE_INCOMPLETE, SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
849 PARSE_FAIL_FLAGS("[/* test */", SPDK_JSON_PARSE_INCOMPLETE, SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
850 PARSE_FAIL_FLAGS("[0/* test */", SPDK_JSON_PARSE_INCOMPLETE, SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
851
852 /*
853 * Single-line comments
854 */
855 PARSE_PASS_FLAGS("// test\n0", 1, "", SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
856 VAL_NUMBER("0");
857
858 PARSE_PASS_FLAGS("// test\r\n0", 1, "", SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
859 VAL_NUMBER("0");
860
861 PARSE_PASS_FLAGS("// [0] test\n0", 1, "", SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
862 VAL_NUMBER("0");
863
864 PARSE_FAIL_FLAGS("//", SPDK_JSON_PARSE_INCOMPLETE, SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
865 PARSE_FAIL_FLAGS("// test", SPDK_JSON_PARSE_INCOMPLETE, SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
866 PARSE_FAIL_FLAGS("//\n", SPDK_JSON_PARSE_INCOMPLETE, SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
867
868 /* Invalid character following slash */
869 PARSE_FAIL_FLAGS("[0/x", SPDK_JSON_PARSE_INVALID, SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
870
871 /* Single slash at end of buffer */
872 PARSE_FAIL_FLAGS("[0/", SPDK_JSON_PARSE_INCOMPLETE, SPDK_JSON_PARSE_FLAG_ALLOW_COMMENTS);
873 }
874
875 int
main(int argc,char ** argv)876 main(int argc, char **argv)
877 {
878 CU_pSuite suite = NULL;
879 unsigned int num_failures;
880
881 CU_initialize_registry();
882
883 suite = CU_add_suite("json", NULL, NULL);
884
885 CU_ADD_TEST(suite, test_parse_literal);
886 CU_ADD_TEST(suite, test_parse_string_simple);
887 CU_ADD_TEST(suite, test_parse_string_control_chars);
888 CU_ADD_TEST(suite, test_parse_string_utf8);
889 CU_ADD_TEST(suite, test_parse_string_escapes_twochar);
890 CU_ADD_TEST(suite, test_parse_string_escapes_unicode);
891 CU_ADD_TEST(suite, test_parse_number);
892 CU_ADD_TEST(suite, test_parse_array);
893 CU_ADD_TEST(suite, test_parse_object);
894 CU_ADD_TEST(suite, test_parse_nesting);
895 CU_ADD_TEST(suite, test_parse_comment);
896
897
898 num_failures = spdk_ut_run_tests(argc, argv, NULL);
899
900 CU_cleanup_registry();
901
902 return num_failures;
903 }
904