LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/json/json_parse.c - json_parse_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 594 594 100.0 %
Date: 2024-07-13 11:15:58 Functions: 12 12 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 444 888 50.0 %

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

Generated by: LCOV version 1.14