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