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