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