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