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