LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/json/json_write.c - json_write_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 591 592 99.8 %
Date: 2024-12-17 07:41:55 Functions: 20 20 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 800 1586 50.4 %

           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_write.c"
      11                 :            : #include "json/json_parse.c"
      12                 :            : 
      13                 :            : #include "spdk/util.h"
      14                 :            : 
      15                 :            : static uint8_t g_buf[1000];
      16                 :            : static uint8_t *g_write_pos;
      17                 :            : 
      18                 :            : static int
      19                 :       1044 : write_cb(void *cb_ctx, const void *data, size_t size)
      20                 :            : {
      21   [ +  -  +  - ]:       1044 :         size_t buf_free = g_buf + sizeof(g_buf) - g_write_pos;
      22                 :            : 
      23         [ -  + ]:       1044 :         if (size > buf_free) {
      24                 :          0 :                 return -1;
      25                 :            :         }
      26                 :            : 
      27   [ +  +  +  + ]:       1044 :         memcpy(g_write_pos, data, size);
      28         [ +  - ]:       1044 :         g_write_pos += size;
      29                 :            : 
      30                 :       1044 :         return 0;
      31                 :        174 : }
      32                 :            : 
      33                 :            : #define BEGIN() \
      34                 :            :         memset(g_buf, 0, sizeof(g_buf)); \
      35                 :            :         g_write_pos = g_buf; \
      36                 :            :         w = spdk_json_write_begin(write_cb, NULL, 0); \
      37                 :            :         SPDK_CU_ASSERT_FATAL(w != NULL)
      38                 :            : 
      39                 :            : #define END(json) \
      40                 :            :         CU_ASSERT(spdk_json_write_end(w) == 0); \
      41                 :            :         CU_ASSERT(g_write_pos - g_buf == sizeof(json) - 1); \
      42                 :            :         CU_ASSERT(memcmp(json, g_buf, sizeof(json) - 1) == 0)
      43                 :            : 
      44                 :            : #define END_SIZE(val, size) \
      45                 :            :         CU_ASSERT(spdk_json_write_end(w) == 0); \
      46                 :            :         CU_ASSERT(g_write_pos - g_buf == size); \
      47                 :            :         CU_ASSERT(memcmp(val, g_buf, size) == 0)
      48                 :            : 
      49                 :            : #define END_NOCMP() \
      50                 :            :         CU_ASSERT(spdk_json_write_end(w) == 0)
      51                 :            : 
      52                 :            : #define END_SIZE_NOCMP(size) \
      53                 :            :         CU_ASSERT(spdk_json_write_end(w) == 0); \
      54                 :            :         CU_ASSERT(g_write_pos - g_buf == size)
      55                 :            : 
      56                 :            : #define END_FAIL() \
      57                 :            :         CU_ASSERT(spdk_json_write_end(w) < 0)
      58                 :            : 
      59                 :            : #define VAL_STRING(str) \
      60                 :            :         CU_ASSERT(spdk_json_write_string_raw(w, str, sizeof(str) - 1) == 0)
      61                 :            : 
      62                 :            : #define VAL_STRING_FAIL(str) \
      63                 :            :         CU_ASSERT(spdk_json_write_string_raw(w, str, sizeof(str) - 1) < 0)
      64                 :            : 
      65                 :            : #define STR_PASS(in, out) \
      66                 :            :         BEGIN(); VAL_STRING(in); END("\"" out "\"")
      67                 :            : 
      68                 :            : #define STR_FAIL(in) \
      69                 :            :         BEGIN(); VAL_STRING_FAIL(in); END_FAIL()
      70                 :            : 
      71                 :            : #define VAL_STRING_UTF16LE(str) \
      72                 :            :         CU_ASSERT(spdk_json_write_string_utf16le_raw(w, (const uint16_t *)str, sizeof(str) / sizeof(uint16_t) - 1) == 0)
      73                 :            : 
      74                 :            : #define VAL_STRING_UTF16LE_FAIL(str) \
      75                 :            :         CU_ASSERT(spdk_json_write_string_utf16le_raw(w, (const uint16_t *)str, sizeof(str) / sizeof(uint16_t) - 1) < 0)
      76                 :            : 
      77                 :            : #define STR_UTF16LE_PASS(in, out) \
      78                 :            :         BEGIN(); VAL_STRING_UTF16LE(in); END("\"" out "\"")
      79                 :            : 
      80                 :            : #define STR_UTF16LE_FAIL(in) \
      81                 :            :         BEGIN(); VAL_STRING_UTF16LE_FAIL(in); END_FAIL()
      82                 :            : 
      83                 :            : #define VAL_NAME(name) \
      84                 :            :         CU_ASSERT(spdk_json_write_name_raw(w, name, sizeof(name) - 1) == 0)
      85                 :            : 
      86                 :            : #define VAL_NULL() CU_ASSERT(spdk_json_write_null(w) == 0)
      87                 :            : #define VAL_TRUE() CU_ASSERT(spdk_json_write_bool(w, true) == 0)
      88                 :            : #define VAL_FALSE() CU_ASSERT(spdk_json_write_bool(w, false) == 0)
      89                 :            : 
      90                 :            : #define VAL_INT32(i) CU_ASSERT(spdk_json_write_int32(w, i) == 0);
      91                 :            : #define VAL_UINT32(u) CU_ASSERT(spdk_json_write_uint32(w, u) == 0);
      92                 :            : 
      93                 :            : #define VAL_INT64(i) CU_ASSERT(spdk_json_write_int64(w, i) == 0);
      94                 :            : #define VAL_UINT64(u) CU_ASSERT(spdk_json_write_uint64(w, u) == 0);
      95                 :            : 
      96                 :            : #define VAL_UINT128(low, high) \
      97                 :            :         CU_ASSERT(spdk_json_write_uint128(w, low, high) == 0);
      98                 :            : #define VAL_NAME_UINT128(name, low, high) \
      99                 :            :         CU_ASSERT(spdk_json_write_named_uint128(w, name, low, high) == 0);
     100                 :            : 
     101                 :            : #define VAL_DOUBLE(d) CU_ASSERT(spdk_json_write_double(w, d) == 0);
     102                 :            : 
     103                 :            : #define VAL_UUID(u) CU_ASSERT(spdk_json_write_uuid(w, u) == 0)
     104                 :            : 
     105                 :            : #define VAL_ARRAY_BEGIN() CU_ASSERT(spdk_json_write_array_begin(w) == 0)
     106                 :            : #define VAL_ARRAY_END() CU_ASSERT(spdk_json_write_array_end(w) == 0)
     107                 :            : 
     108                 :            : #define VAL_OBJECT_BEGIN() CU_ASSERT(spdk_json_write_object_begin(w) == 0)
     109                 :            : #define VAL_OBJECT_END() CU_ASSERT(spdk_json_write_object_end(w) == 0)
     110                 :            : 
     111                 :            : #define VAL(v) CU_ASSERT(spdk_json_write_val(w, v) == 0)
     112                 :            : 
     113                 :            : static void
     114                 :          6 : test_write_literal(void)
     115                 :            : {
     116                 :          1 :         struct spdk_json_write_ctx *w;
     117                 :            : 
     118   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     119                 :          6 :         VAL_NULL();
     120   [ +  -  +  - ]:          6 :         END("null");
     121                 :            : 
     122   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     123                 :          6 :         VAL_TRUE();
     124   [ +  -  +  - ]:          6 :         END("true");
     125                 :            : 
     126   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     127                 :          6 :         VAL_FALSE();
     128   [ +  -  +  - ]:          6 :         END("false");
     129                 :          6 : }
     130                 :            : 
     131                 :            : static void
     132                 :          6 : test_write_string_simple(void)
     133                 :            : {
     134                 :          1 :         struct spdk_json_write_ctx *w;
     135                 :            : 
     136   [ +  +  +  -  :          6 :         STR_PASS("hello world", "hello world");
          #  #  +  -  +  
                      - ]
     137   [ +  +  +  -  :          6 :         STR_PASS(" ", " ");
          #  #  +  -  +  
                      - ]
     138   [ +  +  +  -  :          6 :         STR_PASS("~", "~");
          #  #  +  -  +  
                      - ]
     139                 :          6 : }
     140                 :            : 
     141                 :            : static void
     142                 :          6 : test_write_string_escapes(void)
     143                 :            : {
     144                 :          1 :         struct spdk_json_write_ctx *w;
     145                 :            : 
     146                 :            :         /* Two-character escapes */
     147   [ +  +  +  -  :          6 :         STR_PASS("\b", "\\b");
          #  #  +  -  +  
                      - ]
     148   [ +  +  +  -  :          6 :         STR_PASS("\f", "\\f");
          #  #  +  -  +  
                      - ]
     149   [ +  +  +  -  :          6 :         STR_PASS("\n", "\\n");
          #  #  +  -  +  
                      - ]
     150   [ +  +  +  -  :          6 :         STR_PASS("\r", "\\r");
          #  #  +  -  +  
                      - ]
     151   [ +  +  +  -  :          6 :         STR_PASS("\t", "\\t");
          #  #  +  -  +  
                      - ]
     152   [ +  +  +  -  :          6 :         STR_PASS("\"", "\\\"");
          #  #  +  -  +  
                      - ]
     153   [ +  +  +  -  :          6 :         STR_PASS("\\", "\\\\");
          #  #  +  -  +  
                      - ]
     154                 :            : 
     155                 :            :         /* JSON defines an escape for forward slash, but it is optional */
     156   [ +  +  +  -  :          6 :         STR_PASS("/", "/");
          #  #  +  -  +  
                      - ]
     157                 :            : 
     158   [ +  +  +  -  :          6 :         STR_PASS("hello\nworld", "hello\\nworld");
          #  #  +  -  +  
                      - ]
     159                 :            : 
     160   [ +  +  +  -  :          6 :         STR_PASS("\x00", "\\u0000");
          #  #  +  -  +  
                      - ]
     161   [ +  +  +  -  :          6 :         STR_PASS("\x01", "\\u0001");
          #  #  +  -  +  
                      - ]
     162   [ +  +  +  -  :          6 :         STR_PASS("\x02", "\\u0002");
          #  #  +  -  +  
                      - ]
     163                 :            : 
     164   [ +  +  +  -  :          6 :         STR_PASS("\xC3\xB6", "\\u00F6");
          #  #  +  -  +  
                      - ]
     165   [ +  +  +  -  :          6 :         STR_PASS("\xE2\x88\x9A", "\\u221A");
          #  #  +  -  +  
                      - ]
     166   [ +  +  +  -  :          6 :         STR_PASS("\xEA\xAA\xAA", "\\uAAAA");
          #  #  +  -  +  
                      - ]
     167                 :            : 
     168                 :            :         /* Surrogate pairs */
     169   [ +  +  +  -  :          6 :         STR_PASS("\xF0\x9D\x84\x9E", "\\uD834\\uDD1E");
          #  #  +  -  +  
                      - ]
     170   [ +  +  +  -  :          6 :         STR_PASS("\xF0\xA0\x9C\x8E", "\\uD841\\uDF0E");
          #  #  +  -  +  
                      - ]
     171                 :            : 
     172                 :            :         /* Examples from RFC 3629 */
     173   [ +  +  +  -  :          6 :         STR_PASS("\x41\xE2\x89\xA2\xCE\x91\x2E", "A\\u2262\\u0391.");
          #  #  +  -  +  
                      - ]
     174   [ +  +  +  -  :          6 :         STR_PASS("\xED\x95\x9C\xEA\xB5\xAD\xEC\x96\xB4", "\\uD55C\\uAD6D\\uC5B4");
          #  #  +  -  +  
                      - ]
     175   [ +  +  +  -  :          6 :         STR_PASS("\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E", "\\u65E5\\u672C\\u8A9E");
          #  #  +  -  +  
                      - ]
     176   [ +  +  +  -  :          6 :         STR_PASS("\xEF\xBB\xBF\xF0\xA3\x8E\xB4", "\\uFEFF\\uD84C\\uDFB4");
          #  #  +  -  +  
                      - ]
     177                 :            : 
     178                 :            :         /* UTF-8 edge cases */
     179   [ +  +  +  -  :          6 :         STR_PASS("\x7F", "\\u007F");
          #  #  +  -  +  
                      - ]
     180   [ +  +  +  -  :          6 :         STR_FAIL("\x80");
                   #  # ]
     181   [ +  +  +  -  :          6 :         STR_FAIL("\xC1");
                   #  # ]
     182   [ +  +  +  -  :          6 :         STR_FAIL("\xC2");
                   #  # ]
     183   [ +  +  +  -  :          6 :         STR_PASS("\xC2\x80", "\\u0080");
          #  #  +  -  +  
                      - ]
     184   [ +  +  +  -  :          6 :         STR_PASS("\xC2\xBF", "\\u00BF");
          #  #  +  -  +  
                      - ]
     185   [ +  +  +  -  :          6 :         STR_PASS("\xDF\x80", "\\u07C0");
          #  #  +  -  +  
                      - ]
     186   [ +  +  +  -  :          6 :         STR_PASS("\xDF\xBF", "\\u07FF");
          #  #  +  -  +  
                      - ]
     187   [ +  +  +  -  :          6 :         STR_FAIL("\xDF");
                   #  # ]
     188   [ +  +  +  -  :          6 :         STR_FAIL("\xE0\x80");
                   #  # ]
     189   [ +  +  +  -  :          6 :         STR_FAIL("\xE0\x1F");
                   #  # ]
     190   [ +  +  +  -  :          6 :         STR_FAIL("\xE0\x1F\x80");
                   #  # ]
     191   [ +  +  +  -  :          6 :         STR_FAIL("\xE0");
                   #  # ]
     192   [ +  +  +  -  :          6 :         STR_FAIL("\xE0\xA0");
                   #  # ]
     193   [ +  +  +  -  :          6 :         STR_PASS("\xE0\xA0\x80", "\\u0800");
          #  #  +  -  +  
                      - ]
     194   [ +  +  +  -  :          6 :         STR_PASS("\xE0\xA0\xBF", "\\u083F");
          #  #  +  -  +  
                      - ]
     195   [ +  +  +  -  :          6 :         STR_FAIL("\xE0\xA0\xC0");
                   #  # ]
     196   [ +  +  +  -  :          6 :         STR_PASS("\xE0\xBF\x80", "\\u0FC0");
          #  #  +  -  +  
                      - ]
     197   [ +  +  +  -  :          6 :         STR_PASS("\xE0\xBF\xBF", "\\u0FFF");
          #  #  +  -  +  
                      - ]
     198   [ +  +  +  -  :          6 :         STR_FAIL("\xE0\xC0\x80");
                   #  # ]
     199   [ +  +  +  -  :          6 :         STR_FAIL("\xE1");
                   #  # ]
     200   [ +  +  +  -  :          6 :         STR_FAIL("\xE1\x80");
                   #  # ]
     201   [ +  +  +  -  :          6 :         STR_FAIL("\xE1\x7F\x80");
                   #  # ]
     202   [ +  +  +  -  :          6 :         STR_FAIL("\xE1\x80\x7F");
                   #  # ]
     203   [ +  +  +  -  :          6 :         STR_PASS("\xE1\x80\x80", "\\u1000");
          #  #  +  -  +  
                      - ]
     204   [ +  +  +  -  :          6 :         STR_PASS("\xE1\x80\xBF", "\\u103F");
          #  #  +  -  +  
                      - ]
     205   [ +  +  +  -  :          6 :         STR_PASS("\xE1\xBF\x80", "\\u1FC0");
          #  #  +  -  +  
                      - ]
     206   [ +  +  +  -  :          6 :         STR_PASS("\xE1\xBF\xBF", "\\u1FFF");
          #  #  +  -  +  
                      - ]
     207   [ +  +  +  -  :          6 :         STR_FAIL("\xE1\xC0\x80");
                   #  # ]
     208   [ +  +  +  -  :          6 :         STR_FAIL("\xE1\x80\xC0");
                   #  # ]
     209   [ +  +  +  -  :          6 :         STR_PASS("\xEF\x80\x80", "\\uF000");
          #  #  +  -  +  
                      - ]
     210   [ +  +  +  -  :          6 :         STR_PASS("\xEF\xBF\xBF", "\\uFFFF");
          #  #  +  -  +  
                      - ]
     211   [ +  +  +  -  :          6 :         STR_FAIL("\xF0");
                   #  # ]
     212   [ +  +  +  -  :          6 :         STR_FAIL("\xF0\x90");
                   #  # ]
     213   [ +  +  +  -  :          6 :         STR_FAIL("\xF0\x90\x80");
                   #  # ]
     214   [ +  +  +  -  :          6 :         STR_FAIL("\xF0\x80\x80\x80");
                   #  # ]
     215   [ +  +  +  -  :          6 :         STR_FAIL("\xF0\x8F\x80\x80");
                   #  # ]
     216   [ +  +  +  -  :          6 :         STR_PASS("\xF0\x90\x80\x80", "\\uD800\\uDC00");
          #  #  +  -  +  
                      - ]
     217   [ +  +  +  -  :          6 :         STR_PASS("\xF0\x90\x80\xBF", "\\uD800\\uDC3F");
          #  #  +  -  +  
                      - ]
     218   [ +  +  +  -  :          6 :         STR_PASS("\xF0\x90\xBF\x80", "\\uD803\\uDFC0");
          #  #  +  -  +  
                      - ]
     219   [ +  +  +  -  :          6 :         STR_PASS("\xF0\xBF\x80\x80", "\\uD8BC\\uDC00");
          #  #  +  -  +  
                      - ]
     220   [ +  +  +  -  :          6 :         STR_FAIL("\xF0\xC0\x80\x80");
                   #  # ]
     221   [ +  +  +  -  :          6 :         STR_FAIL("\xF1");
                   #  # ]
     222   [ +  +  +  -  :          6 :         STR_FAIL("\xF1\x80");
                   #  # ]
     223   [ +  +  +  -  :          6 :         STR_FAIL("\xF1\x80\x80");
                   #  # ]
     224   [ +  +  +  -  :          6 :         STR_FAIL("\xF1\x80\x80\x7F");
                   #  # ]
     225   [ +  +  +  -  :          6 :         STR_PASS("\xF1\x80\x80\x80", "\\uD8C0\\uDC00");
          #  #  +  -  +  
                      - ]
     226   [ +  +  +  -  :          6 :         STR_PASS("\xF1\x80\x80\xBF", "\\uD8C0\\uDC3F");
          #  #  +  -  +  
                      - ]
     227   [ +  +  +  -  :          6 :         STR_PASS("\xF1\x80\xBF\x80", "\\uD8C3\\uDFC0");
          #  #  +  -  +  
                      - ]
     228   [ +  +  +  -  :          6 :         STR_PASS("\xF1\xBF\x80\x80", "\\uD9BC\\uDC00");
          #  #  +  -  +  
                      - ]
     229   [ +  +  +  -  :          6 :         STR_PASS("\xF3\x80\x80\x80", "\\uDAC0\\uDC00");
          #  #  +  -  +  
                      - ]
     230   [ +  +  +  -  :          6 :         STR_FAIL("\xF3\xC0\x80\x80");
                   #  # ]
     231   [ +  +  +  -  :          6 :         STR_FAIL("\xF3\x80\xC0\x80");
                   #  # ]
     232   [ +  +  +  -  :          6 :         STR_FAIL("\xF3\x80\x80\xC0");
                   #  # ]
     233   [ +  +  +  -  :          6 :         STR_FAIL("\xF4");
                   #  # ]
     234   [ +  +  +  -  :          6 :         STR_FAIL("\xF4\x80");
                   #  # ]
     235   [ +  +  +  -  :          6 :         STR_FAIL("\xF4\x80\x80");
                   #  # ]
     236   [ +  +  +  -  :          6 :         STR_PASS("\xF4\x80\x80\x80", "\\uDBC0\\uDC00");
          #  #  +  -  +  
                      - ]
     237   [ +  +  +  -  :          6 :         STR_PASS("\xF4\x8F\x80\x80", "\\uDBFC\\uDC00");
          #  #  +  -  +  
                      - ]
     238   [ +  +  +  -  :          6 :         STR_PASS("\xF4\x8F\xBF\xBF", "\\uDBFF\\uDFFF");
          #  #  +  -  +  
                      - ]
     239   [ +  +  +  -  :          6 :         STR_FAIL("\xF4\x90\x80\x80");
                   #  # ]
     240   [ +  +  +  -  :          6 :         STR_FAIL("\xF5");
                   #  # ]
     241   [ +  +  +  -  :          6 :         STR_FAIL("\xF5\x80");
                   #  # ]
     242   [ +  +  +  -  :          6 :         STR_FAIL("\xF5\x80\x80");
                   #  # ]
     243   [ +  +  +  -  :          6 :         STR_FAIL("\xF5\x80\x80\x80");
                   #  # ]
     244   [ +  +  +  -  :          6 :         STR_FAIL("\xF5\x80\x80\x80\x80");
                   #  # ]
     245                 :            : 
     246                 :            :         /* Overlong encodings */
     247   [ +  +  +  -  :          6 :         STR_FAIL("\xC0\x80");
                   #  # ]
     248                 :            : 
     249                 :            :         /* Surrogate pairs */
     250   [ +  +  +  -  :          6 :         STR_FAIL("\xED\xA0\x80"); /* U+D800 First high surrogate */
                   #  # ]
     251   [ +  +  +  -  :          6 :         STR_FAIL("\xED\xAF\xBF"); /* U+DBFF Last high surrogate */
                   #  # ]
     252   [ +  +  +  -  :          6 :         STR_FAIL("\xED\xB0\x80"); /* U+DC00 First low surrogate */
                   #  # ]
     253   [ +  +  +  -  :          6 :         STR_FAIL("\xED\xBF\xBF"); /* U+DFFF Last low surrogate */
                   #  # ]
     254   [ +  +  +  -  :          6 :         STR_FAIL("\xED\xA1\x8C\xED\xBE\xB4"); /* U+233B4 (invalid surrogate pair encoding) */
                   #  # ]
     255                 :          6 : }
     256                 :            : 
     257                 :            : static void
     258                 :          6 : test_write_string_utf16le(void)
     259                 :            : {
     260                 :          1 :         struct spdk_json_write_ctx *w;
     261                 :            : 
     262                 :            :         /* All characters in BMP */
     263   [ +  +  +  -  :         10 :         STR_UTF16LE_PASS(((uint8_t[]) {
          #  #  +  -  +  
                      - ]
     264                 :            :                 'H', 0, 'e', 0, 'l', 0, 'l', 0, 'o', 0, 0x15, 0xFE, 0, 0
     265                 :            :         }), "Hello\\uFE15");
     266                 :            : 
     267                 :            :         /* Surrogate pair */
     268   [ +  +  +  -  :         10 :         STR_UTF16LE_PASS(((uint8_t[]) {
          #  #  +  -  +  
                      - ]
     269                 :            :                 'H', 0, 'i', 0,  0x34, 0xD8, 0x1E, 0xDD, '!', 0, 0, 0
     270                 :            :         }), "Hi\\uD834\\uDD1E!");
     271                 :            : 
     272                 :            :         /* Valid high surrogate, but no low surrogate */
     273   [ +  +  +  -  :         10 :         STR_UTF16LE_FAIL(((uint8_t[]) {
                   #  # ]
     274                 :            :                 0x00, 0xD8, 0, 0 /* U+D800 */
     275                 :            :         }));
     276                 :            : 
     277                 :            :         /* Invalid leading low surrogate */
     278   [ +  +  +  -  :         10 :         STR_UTF16LE_FAIL(((uint8_t[]) {
                   #  # ]
     279                 :            :                 0x00, 0xDC, 0x00, 0xDC, 0, 0 /* U+DC00 U+DC00 */
     280                 :            :         }));
     281                 :            : 
     282                 :            :         /* Valid high surrogate followed by another high surrogate (invalid) */
     283   [ +  +  +  -  :         10 :         STR_UTF16LE_FAIL(((uint8_t[]) {
                   #  # ]
     284                 :            :                 0x00, 0xD8, 0x00, 0xD8, 0, 0 /* U+D800 U+D800 */
     285                 :            :         }));
     286                 :          6 : }
     287                 :            : 
     288                 :            : static void
     289                 :          6 : test_write_number_int32(void)
     290                 :            : {
     291                 :          1 :         struct spdk_json_write_ctx *w;
     292                 :            : 
     293   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     294                 :          6 :         VAL_INT32(0);
     295   [ +  -  +  - ]:          6 :         END("0");
     296                 :            : 
     297   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     298                 :          6 :         VAL_INT32(1);
     299   [ +  -  +  - ]:          6 :         END("1");
     300                 :            : 
     301   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     302                 :          6 :         VAL_INT32(123);
     303   [ +  -  +  - ]:          6 :         END("123");
     304                 :            : 
     305   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     306                 :          6 :         VAL_INT32(-123);
     307   [ +  -  +  - ]:          6 :         END("-123");
     308                 :            : 
     309   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     310                 :          6 :         VAL_INT32(2147483647);
     311   [ +  -  +  - ]:          6 :         END("2147483647");
     312                 :            : 
     313   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     314                 :          6 :         VAL_INT32(-2147483648);
     315   [ +  -  +  - ]:          6 :         END("-2147483648");
     316                 :          6 : }
     317                 :            : 
     318                 :            : static void
     319                 :          6 : test_write_number_uint32(void)
     320                 :            : {
     321                 :          1 :         struct spdk_json_write_ctx *w;
     322                 :            : 
     323   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     324                 :          6 :         VAL_UINT32(0);
     325   [ +  -  +  - ]:          6 :         END("0");
     326                 :            : 
     327   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     328                 :          6 :         VAL_UINT32(1);
     329   [ +  -  +  - ]:          6 :         END("1");
     330                 :            : 
     331   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     332                 :          6 :         VAL_UINT32(123);
     333   [ +  -  +  - ]:          6 :         END("123");
     334                 :            : 
     335   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     336                 :          6 :         VAL_UINT32(2147483647);
     337   [ +  -  +  - ]:          6 :         END("2147483647");
     338                 :            : 
     339   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     340                 :          6 :         VAL_UINT32(4294967295);
     341   [ +  -  +  - ]:          6 :         END("4294967295");
     342                 :          6 : }
     343                 :            : 
     344                 :            : static int
     345                 :         84 : test_generate_string_uint128(char *buf, int buf_size, uint64_t low, uint64_t high)
     346                 :            : {
     347                 :         84 :         char tmp_buf[256] = {0};
     348                 :         14 :         unsigned __int128 total;
     349                 :         14 :         uint64_t seg;
     350                 :         84 :         int count = 0;
     351                 :            : 
     352         [ +  + ]:         84 :         memset(buf, 0, buf_size);
     353         [ +  - ]:         84 :         total = ((unsigned __int128)high << 64) + (unsigned __int128)low;
     354         [ +  + ]:        216 :         while (total) {
     355                 :            :                 /* Use the different calculation to get the 128bits decimal value in UT */
     356         [ +  - ]:        132 :                 seg = total % 1000000000000000;
     357         [ +  - ]:        132 :                 total = total / 1000000000000000;
     358         [ +  + ]:        132 :                 if (total) {
     359         [ -  + ]:         48 :                         snprintf(tmp_buf, buf_size, "%015" PRIu64 "%s", seg, buf);
     360                 :          8 :                 } else {
     361         [ -  + ]:         84 :                         snprintf(tmp_buf, buf_size, "%" PRIu64 "%s", seg, buf);
     362                 :            :                 }
     363                 :            : 
     364         [ -  + ]:        132 :                 count = snprintf(buf, buf_size, "%s", tmp_buf);
     365                 :            :         }
     366                 :            : 
     367                 :         98 :         return count;
     368                 :         14 : }
     369                 :            : 
     370                 :            : static int
     371                 :         42 : test_generate_string_name_uint128(char *name, char *buf, int buf_size, uint64_t low, uint64_t high)
     372                 :            : {
     373                 :         42 :         char tmp_buf[256] = {0};
     374                 :         42 :         int count = test_generate_string_uint128(buf, buf_size, low, high);
     375                 :            : 
     376   [ +  +  +  + ]:         42 :         memcpy(tmp_buf, buf, buf_size);
     377         [ -  + ]:         42 :         count = snprintf(buf, 256, "\"%s\":%s", name, tmp_buf);
     378                 :            : 
     379                 :         49 :         return count;
     380                 :          7 : }
     381                 :            : 
     382                 :            : static void
     383                 :          6 : test_write_number_uint128(void)
     384                 :            : {
     385                 :          1 :         struct spdk_json_write_ctx *w;
     386                 :          6 :         char buf[256] = {0};
     387                 :          6 :         int used_count = 0;
     388                 :            : 
     389   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     390                 :          6 :         VAL_UINT128(0, 0);
     391   [ +  -  +  - ]:          6 :         END("0");
     392                 :            : 
     393   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     394                 :          6 :         VAL_UINT128(1, 0);
     395                 :          6 :         used_count = test_generate_string_uint128(buf, sizeof(buf), 1, 0);
     396   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     397                 :            : 
     398   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     399                 :          6 :         VAL_UINT128(123, 0);
     400                 :          6 :         used_count = test_generate_string_uint128(buf, sizeof(buf), 123, 0);
     401   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     402                 :            : 
     403   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     404                 :          6 :         VAL_UINT128(2147483647, 0);
     405                 :          6 :         used_count = test_generate_string_uint128(buf, sizeof(buf), 2147483647, 0);
     406   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     407                 :            : 
     408   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     409                 :          6 :         VAL_UINT128(0, 1);
     410                 :          6 :         used_count = test_generate_string_uint128(buf, sizeof(buf), 0, 1);
     411   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     412                 :            : 
     413   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     414                 :          6 :         VAL_UINT128(4294967295, 1);
     415                 :          6 :         used_count = test_generate_string_uint128(buf, sizeof(buf), 4294967295, 1);
     416   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     417                 :            : 
     418   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     419                 :          6 :         VAL_UINT128(2147483647, 4294967295);
     420                 :          6 :         used_count = test_generate_string_uint128(buf, sizeof(buf), 2147483647, 4294967295);
     421   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     422                 :            : 
     423   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     424                 :          6 :         VAL_UINT128(4294967295, 4294967295);
     425                 :          6 :         used_count = test_generate_string_uint128(buf, sizeof(buf), 4294967295, 4294967295);
     426   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     427                 :          6 : }
     428                 :            : 
     429                 :            : static void
     430                 :          6 : test_write_string_number_uint128(void)
     431                 :            : {
     432                 :          1 :         struct spdk_json_write_ctx *w;
     433                 :          6 :         char buf[256] = {0};
     434                 :          6 :         int used_count = 0;
     435                 :            : 
     436   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     437                 :          6 :         VAL_NAME_UINT128("case1", 0, 0);
     438   [ +  -  +  - ]:          6 :         END("\"case1\":0");
     439                 :            : 
     440   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     441                 :          6 :         VAL_NAME_UINT128("case2", 1, 0);
     442                 :          6 :         used_count = test_generate_string_name_uint128("case2", buf, sizeof(buf), 1, 0);
     443   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     444                 :            : 
     445   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     446                 :          6 :         VAL_NAME_UINT128("case3", 123, 0);
     447                 :          6 :         used_count = test_generate_string_name_uint128("case3", buf, sizeof(buf), 123, 0);
     448   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     449                 :            : 
     450   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     451                 :          6 :         VAL_NAME_UINT128("case4", 2147483647, 0);
     452                 :          6 :         used_count = test_generate_string_name_uint128("case4", buf, sizeof(buf), 2147483647, 0);
     453   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     454                 :            : 
     455   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     456                 :          6 :         VAL_NAME_UINT128("case5", 0, 1);
     457                 :          6 :         used_count = test_generate_string_name_uint128("case5", buf, sizeof(buf), 0, 1);
     458   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     459                 :            : 
     460   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     461                 :          6 :         VAL_NAME_UINT128("case6", 4294967295, 1);
     462                 :          6 :         used_count = test_generate_string_name_uint128("case6", buf, sizeof(buf), 4294967295, 1);
     463   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     464                 :            : 
     465   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     466                 :          6 :         VAL_NAME_UINT128("case7", 2147483647, 4294967295);
     467                 :          6 :         used_count = test_generate_string_name_uint128("case7", buf, sizeof(buf), 2147483647, 4294967295);
     468   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     469                 :            : 
     470   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     471                 :          6 :         VAL_NAME_UINT128("case8", 4294967295, 4294967295);
     472                 :          6 :         used_count = test_generate_string_name_uint128("case8", buf, sizeof(buf), 4294967295, 4294967295);
     473   [ +  -  +  - ]:          6 :         END_SIZE(buf, used_count);
     474                 :          6 : }
     475                 :            : 
     476                 :            : static void
     477                 :          6 : test_write_number_int64(void)
     478                 :            : {
     479                 :          1 :         struct spdk_json_write_ctx *w;
     480                 :            : 
     481   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     482                 :          6 :         VAL_INT64(0);
     483   [ +  -  +  - ]:          6 :         END("0");
     484                 :            : 
     485   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     486                 :          6 :         VAL_INT64(1);
     487   [ +  -  +  - ]:          6 :         END("1");
     488                 :            : 
     489   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     490                 :          6 :         VAL_INT64(123);
     491   [ +  -  +  - ]:          6 :         END("123");
     492                 :            : 
     493   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     494                 :          6 :         VAL_INT64(-123);
     495   [ +  -  +  - ]:          6 :         END("-123");
     496                 :            : 
     497   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     498                 :          6 :         VAL_INT64(INT64_MAX);
     499   [ +  -  +  - ]:          6 :         END("9223372036854775807");
     500                 :            : 
     501   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     502                 :          6 :         VAL_INT64(INT64_MIN);
     503   [ +  -  +  - ]:          6 :         END("-9223372036854775808");
     504                 :          6 : }
     505                 :            : 
     506                 :            : static void
     507                 :          6 : test_write_number_uint64(void)
     508                 :            : {
     509                 :          1 :         struct spdk_json_write_ctx *w;
     510                 :            : 
     511   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     512                 :          6 :         VAL_UINT64(0);
     513   [ +  -  +  - ]:          6 :         END("0");
     514                 :            : 
     515   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     516                 :          6 :         VAL_UINT64(1);
     517   [ +  -  +  - ]:          6 :         END("1");
     518                 :            : 
     519   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     520                 :          6 :         VAL_UINT64(123);
     521   [ +  -  +  - ]:          6 :         END("123");
     522                 :            : 
     523   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     524                 :          6 :         VAL_UINT64(INT64_MAX);
     525   [ +  -  +  - ]:          6 :         END("9223372036854775807");
     526                 :            : 
     527   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     528                 :          6 :         VAL_UINT64(UINT64_MAX);
     529   [ +  -  +  - ]:          6 :         END("18446744073709551615");
     530                 :          6 : }
     531                 :            : 
     532                 :            : static void
     533                 :          6 : test_write_number_double(void)
     534                 :            : {
     535                 :          1 :         struct spdk_json_write_ctx *w;
     536                 :            : 
     537   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     538                 :          6 :         VAL_DOUBLE(0);
     539   [ +  -  +  - ]:          6 :         END_SIZE("0.00000000000000000000e+00", 26);
     540                 :            : 
     541   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     542                 :          6 :         VAL_DOUBLE(1.2);
     543   [ +  -  +  - ]:          6 :         END_SIZE("1.19999999999999995559e+00", 26);
     544                 :            : 
     545                 :            : 
     546   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     547                 :          6 :         VAL_DOUBLE(1234.5678);
     548   [ +  -  +  - ]:          6 :         END_SIZE("1.23456780000000003383e+03", 26);
     549                 :            : 
     550   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     551                 :          6 :         VAL_DOUBLE(-1234.5678);
     552   [ +  -  +  - ]:          6 :         END_SIZE("-1.23456780000000003383e+03", 27);
     553                 :          6 : }
     554                 :            : 
     555                 :            : static void
     556                 :          6 : test_write_uuid(void)
     557                 :            : {
     558                 :            : #define UT_UUID "e524acae-8c26-43e4-882a-461b8690583b"
     559                 :          1 :         struct spdk_json_write_ctx *w;
     560                 :          5 :         struct spdk_uuid uuid;
     561                 :          1 :         int rc;
     562                 :            : 
     563                 :          6 :         rc = spdk_uuid_parse(&uuid, UT_UUID);
     564                 :          6 :         CU_ASSERT_EQUAL(rc, 0);
     565                 :            : 
     566   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     567                 :          6 :         VAL_UUID(&uuid);
     568   [ +  -  +  - ]:          6 :         END("\"" UT_UUID "\"");
     569                 :          6 : }
     570                 :            : 
     571                 :            : static void
     572                 :          6 : test_write_array(void)
     573                 :            : {
     574                 :          1 :         struct spdk_json_write_ctx *w;
     575                 :            : 
     576   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     577                 :          6 :         VAL_ARRAY_BEGIN();
     578                 :          6 :         VAL_ARRAY_END();
     579   [ +  -  +  - ]:          6 :         END("[]");
     580                 :            : 
     581   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     582                 :          6 :         VAL_ARRAY_BEGIN();
     583                 :          6 :         VAL_INT32(0);
     584                 :          6 :         VAL_ARRAY_END();
     585   [ +  -  +  - ]:          6 :         END("[0]");
     586                 :            : 
     587   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     588                 :          6 :         VAL_ARRAY_BEGIN();
     589                 :          6 :         VAL_INT32(0);
     590                 :          6 :         VAL_INT32(1);
     591                 :          6 :         VAL_ARRAY_END();
     592   [ +  -  +  - ]:          6 :         END("[0,1]");
     593                 :            : 
     594   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     595                 :          6 :         VAL_ARRAY_BEGIN();
     596                 :          6 :         VAL_INT32(0);
     597                 :          6 :         VAL_INT32(1);
     598                 :          6 :         VAL_INT32(2);
     599                 :          6 :         VAL_ARRAY_END();
     600   [ +  -  +  - ]:          6 :         END("[0,1,2]");
     601                 :            : 
     602   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     603                 :          6 :         VAL_ARRAY_BEGIN();
     604                 :          6 :         VAL_STRING("a");
     605                 :          6 :         VAL_ARRAY_END();
     606   [ +  -  +  - ]:          6 :         END("[\"a\"]");
     607                 :            : 
     608   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     609                 :          6 :         VAL_ARRAY_BEGIN();
     610                 :          6 :         VAL_STRING("a");
     611                 :          6 :         VAL_STRING("b");
     612                 :          6 :         VAL_ARRAY_END();
     613   [ +  -  +  - ]:          6 :         END("[\"a\",\"b\"]");
     614                 :            : 
     615   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     616                 :          6 :         VAL_ARRAY_BEGIN();
     617                 :          6 :         VAL_STRING("a");
     618                 :          6 :         VAL_STRING("b");
     619                 :          6 :         VAL_STRING("c");
     620                 :          6 :         VAL_ARRAY_END();
     621   [ +  -  +  - ]:          6 :         END("[\"a\",\"b\",\"c\"]");
     622                 :            : 
     623   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     624                 :          6 :         VAL_ARRAY_BEGIN();
     625                 :          6 :         VAL_TRUE();
     626                 :          6 :         VAL_ARRAY_END();
     627   [ +  -  +  - ]:          6 :         END("[true]");
     628                 :            : 
     629   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     630                 :          6 :         VAL_ARRAY_BEGIN();
     631                 :          6 :         VAL_TRUE();
     632                 :          6 :         VAL_FALSE();
     633                 :          6 :         VAL_ARRAY_END();
     634   [ +  -  +  - ]:          6 :         END("[true,false]");
     635                 :            : 
     636   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     637                 :          6 :         VAL_ARRAY_BEGIN();
     638                 :          6 :         VAL_TRUE();
     639                 :          6 :         VAL_FALSE();
     640                 :          6 :         VAL_TRUE();
     641                 :          6 :         VAL_ARRAY_END();
     642   [ +  -  +  - ]:          6 :         END("[true,false,true]");
     643                 :          6 : }
     644                 :            : 
     645                 :            : static void
     646                 :          6 : test_write_object(void)
     647                 :            : {
     648                 :          1 :         struct spdk_json_write_ctx *w;
     649                 :            : 
     650   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     651                 :          6 :         VAL_OBJECT_BEGIN();
     652                 :          6 :         VAL_OBJECT_END();
     653   [ +  -  +  - ]:          6 :         END("{}");
     654                 :            : 
     655   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     656                 :          6 :         VAL_OBJECT_BEGIN();
     657                 :          6 :         VAL_NAME("a");
     658                 :          6 :         VAL_INT32(0);
     659                 :          6 :         VAL_OBJECT_END();
     660   [ +  -  +  - ]:          6 :         END("{\"a\":0}");
     661                 :            : 
     662   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     663                 :          6 :         VAL_OBJECT_BEGIN();
     664                 :          6 :         VAL_NAME("a");
     665                 :          6 :         VAL_INT32(0);
     666                 :          6 :         VAL_NAME("b");
     667                 :          6 :         VAL_INT32(1);
     668                 :          6 :         VAL_OBJECT_END();
     669   [ +  -  +  - ]:          6 :         END("{\"a\":0,\"b\":1}");
     670                 :            : 
     671   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     672                 :          6 :         VAL_OBJECT_BEGIN();
     673                 :          6 :         VAL_NAME("a");
     674                 :          6 :         VAL_INT32(0);
     675                 :          6 :         VAL_NAME("b");
     676                 :          6 :         VAL_INT32(1);
     677                 :          6 :         VAL_NAME("c");
     678                 :          6 :         VAL_INT32(2);
     679                 :          6 :         VAL_OBJECT_END();
     680   [ +  -  +  - ]:          6 :         END("{\"a\":0,\"b\":1,\"c\":2}");
     681                 :          6 : }
     682                 :            : 
     683                 :            : static void
     684                 :          6 : test_write_nesting(void)
     685                 :            : {
     686                 :          1 :         struct spdk_json_write_ctx *w;
     687                 :            : 
     688   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     689                 :          6 :         VAL_ARRAY_BEGIN();
     690                 :          6 :         VAL_ARRAY_BEGIN();
     691                 :          6 :         VAL_ARRAY_END();
     692                 :          6 :         VAL_ARRAY_END();
     693   [ +  -  +  - ]:          6 :         END("[[]]");
     694                 :            : 
     695   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     696                 :          6 :         VAL_ARRAY_BEGIN();
     697                 :          6 :         VAL_ARRAY_BEGIN();
     698                 :          6 :         VAL_ARRAY_BEGIN();
     699                 :          6 :         VAL_ARRAY_END();
     700                 :          6 :         VAL_ARRAY_END();
     701                 :          6 :         VAL_ARRAY_END();
     702   [ +  -  +  - ]:          6 :         END("[[[]]]");
     703                 :            : 
     704   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     705                 :          6 :         VAL_ARRAY_BEGIN();
     706                 :          6 :         VAL_INT32(0);
     707                 :          6 :         VAL_ARRAY_BEGIN();
     708                 :          6 :         VAL_ARRAY_END();
     709                 :          6 :         VAL_ARRAY_END();
     710   [ +  -  +  - ]:          6 :         END("[0,[]]");
     711                 :            : 
     712   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     713                 :          6 :         VAL_ARRAY_BEGIN();
     714                 :          6 :         VAL_ARRAY_BEGIN();
     715                 :          6 :         VAL_ARRAY_END();
     716                 :          6 :         VAL_INT32(0);
     717                 :          6 :         VAL_ARRAY_END();
     718   [ +  -  +  - ]:          6 :         END("[[],0]");
     719                 :            : 
     720   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     721                 :          6 :         VAL_ARRAY_BEGIN();
     722                 :          6 :         VAL_INT32(0);
     723                 :          6 :         VAL_ARRAY_BEGIN();
     724                 :          6 :         VAL_INT32(1);
     725                 :          6 :         VAL_ARRAY_END();
     726                 :          6 :         VAL_INT32(2);
     727                 :          6 :         VAL_ARRAY_END();
     728   [ +  -  +  - ]:          6 :         END("[0,[1],2]");
     729                 :            : 
     730   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     731                 :          6 :         VAL_ARRAY_BEGIN();
     732                 :          6 :         VAL_INT32(0);
     733                 :          6 :         VAL_INT32(1);
     734                 :          6 :         VAL_ARRAY_BEGIN();
     735                 :          6 :         VAL_INT32(2);
     736                 :          6 :         VAL_INT32(3);
     737                 :          6 :         VAL_ARRAY_END();
     738                 :          6 :         VAL_INT32(4);
     739                 :          6 :         VAL_INT32(5);
     740                 :          6 :         VAL_ARRAY_END();
     741   [ +  -  +  - ]:          6 :         END("[0,1,[2,3],4,5]");
     742                 :            : 
     743   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     744                 :          6 :         VAL_OBJECT_BEGIN();
     745                 :          6 :         VAL_NAME("a");
     746                 :          6 :         VAL_OBJECT_BEGIN();
     747                 :          6 :         VAL_OBJECT_END();
     748                 :          6 :         VAL_OBJECT_END();
     749   [ +  -  +  - ]:          6 :         END("{\"a\":{}}");
     750                 :            : 
     751   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     752                 :          6 :         VAL_OBJECT_BEGIN();
     753                 :          6 :         VAL_NAME("a");
     754                 :          6 :         VAL_OBJECT_BEGIN();
     755                 :          6 :         VAL_NAME("b");
     756                 :          6 :         VAL_INT32(0);
     757                 :          6 :         VAL_OBJECT_END();
     758                 :          6 :         VAL_OBJECT_END();
     759   [ +  -  +  - ]:          6 :         END("{\"a\":{\"b\":0}}");
     760                 :            : 
     761   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     762                 :          6 :         VAL_OBJECT_BEGIN();
     763                 :          6 :         VAL_NAME("a");
     764                 :          6 :         VAL_ARRAY_BEGIN();
     765                 :          6 :         VAL_INT32(0);
     766                 :          6 :         VAL_ARRAY_END();
     767                 :          6 :         VAL_OBJECT_END();
     768   [ +  -  +  - ]:          6 :         END("{\"a\":[0]}");
     769                 :            : 
     770   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     771                 :          6 :         VAL_ARRAY_BEGIN();
     772                 :          6 :         VAL_OBJECT_BEGIN();
     773                 :          6 :         VAL_NAME("a");
     774                 :          6 :         VAL_INT32(0);
     775                 :          6 :         VAL_OBJECT_END();
     776                 :          6 :         VAL_ARRAY_END();
     777   [ +  -  +  - ]:          6 :         END("[{\"a\":0}]");
     778                 :            : 
     779   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     780                 :          6 :         VAL_ARRAY_BEGIN();
     781                 :          6 :         VAL_OBJECT_BEGIN();
     782                 :          6 :         VAL_NAME("a");
     783                 :          6 :         VAL_OBJECT_BEGIN();
     784                 :          6 :         VAL_NAME("b");
     785                 :          6 :         VAL_ARRAY_BEGIN();
     786                 :          6 :         VAL_OBJECT_BEGIN();
     787                 :          6 :         VAL_NAME("c");
     788                 :          6 :         VAL_INT32(1);
     789                 :          6 :         VAL_OBJECT_END();
     790                 :          6 :         VAL_INT32(2);
     791                 :          6 :         VAL_ARRAY_END();
     792                 :          6 :         VAL_NAME("d");
     793                 :          6 :         VAL_INT32(3);
     794                 :          6 :         VAL_OBJECT_END();
     795                 :          6 :         VAL_NAME("e");
     796                 :          6 :         VAL_INT32(4);
     797                 :          6 :         VAL_OBJECT_END();
     798                 :          6 :         VAL_INT32(5);
     799                 :          6 :         VAL_ARRAY_END();
     800   [ +  -  +  - ]:          6 :         END("[{\"a\":{\"b\":[{\"c\":1},2],\"d\":3},\"e\":4},5]");
     801                 :            : 
     802                 :            :         /* Examples from RFC 7159 */
     803   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     804                 :          6 :         VAL_OBJECT_BEGIN();
     805                 :          6 :         VAL_NAME("Image");
     806                 :          6 :         VAL_OBJECT_BEGIN();
     807                 :          6 :         VAL_NAME("Width");
     808                 :          6 :         VAL_INT32(800);
     809                 :          6 :         VAL_NAME("Height");
     810                 :          6 :         VAL_INT32(600);
     811                 :          6 :         VAL_NAME("Title");
     812                 :          6 :         VAL_STRING("View from 15th Floor");
     813                 :          6 :         VAL_NAME("Thumbnail");
     814                 :          6 :         VAL_OBJECT_BEGIN();
     815                 :          6 :         VAL_NAME("Url");
     816                 :          6 :         VAL_STRING("http://www.example.com/image/481989943");
     817                 :          6 :         VAL_NAME("Height");
     818                 :          6 :         VAL_INT32(125);
     819                 :          6 :         VAL_NAME("Width");
     820                 :          6 :         VAL_INT32(100);
     821                 :          6 :         VAL_OBJECT_END();
     822                 :          6 :         VAL_NAME("Animated");
     823                 :          6 :         VAL_FALSE();
     824                 :          6 :         VAL_NAME("IDs");
     825                 :          6 :         VAL_ARRAY_BEGIN();
     826                 :          6 :         VAL_INT32(116);
     827                 :          6 :         VAL_INT32(943);
     828                 :          6 :         VAL_INT32(234);
     829                 :          6 :         VAL_INT32(38793);
     830                 :          6 :         VAL_ARRAY_END();
     831                 :          6 :         VAL_OBJECT_END();
     832                 :          6 :         VAL_OBJECT_END();
     833   [ +  -  +  - ]:          6 :         END(
     834                 :            :                 "{\"Image\":"
     835                 :            :                 "{"
     836                 :            :                 "\"Width\":800,"
     837                 :            :                 "\"Height\":600,"
     838                 :            :                 "\"Title\":\"View from 15th Floor\","
     839                 :            :                 "\"Thumbnail\":{"
     840                 :            :                 "\"Url\":\"http://www.example.com/image/481989943\","
     841                 :            :                 "\"Height\":125,"
     842                 :            :                 "\"Width\":100"
     843                 :            :                 "},"
     844                 :            :                 "\"Animated\":false,"
     845                 :            :                 "\"IDs\":[116,943,234,38793]"
     846                 :            :                 "}"
     847                 :            :                 "}");
     848                 :          6 : }
     849                 :            : 
     850                 :            : /* Round-trip parse and write test */
     851                 :            : static void
     852                 :          6 : test_write_val(void)
     853                 :            : {
     854                 :          1 :         struct spdk_json_write_ctx *w;
     855                 :          5 :         struct spdk_json_val values[100];
     856                 :          6 :         char src[] = "{\"a\":[1,2,3],\"b\":{\"c\":\"d\"},\"e\":true,\"f\":false,\"g\":null}";
     857                 :            : 
     858         [ +  - ]:          6 :         CU_ASSERT(spdk_json_parse(src, strlen(src), values, SPDK_COUNTOF(values), NULL,
     859                 :            :                                   SPDK_JSON_PARSE_FLAG_DECODE_IN_PLACE) == 19);
     860                 :            : 
     861   [ +  +  +  -  :          6 :         BEGIN();
                   #  # ]
     862                 :          6 :         VAL(values);
     863   [ +  -  +  - ]:          6 :         END("{\"a\":[1,2,3],\"b\":{\"c\":\"d\"},\"e\":true,\"f\":false,\"g\":null}");
     864                 :          6 : }
     865                 :            : 
     866                 :            : int
     867                 :          6 : main(int argc, char **argv)
     868                 :            : {
     869                 :          6 :         CU_pSuite       suite = NULL;
     870                 :          1 :         unsigned int    num_failures;
     871                 :            : 
     872                 :          6 :         CU_initialize_registry();
     873                 :            : 
     874                 :          6 :         suite = CU_add_suite("json", NULL, NULL);
     875                 :            : 
     876                 :          6 :         CU_ADD_TEST(suite, test_write_literal);
     877                 :          6 :         CU_ADD_TEST(suite, test_write_string_simple);
     878                 :          6 :         CU_ADD_TEST(suite, test_write_string_escapes);
     879                 :          6 :         CU_ADD_TEST(suite, test_write_string_utf16le);
     880                 :          6 :         CU_ADD_TEST(suite, test_write_number_int32);
     881                 :          6 :         CU_ADD_TEST(suite, test_write_number_uint32);
     882                 :          6 :         CU_ADD_TEST(suite, test_write_number_uint128);
     883                 :          6 :         CU_ADD_TEST(suite, test_write_string_number_uint128);
     884                 :          6 :         CU_ADD_TEST(suite, test_write_number_int64);
     885                 :          6 :         CU_ADD_TEST(suite, test_write_number_uint64);
     886                 :          6 :         CU_ADD_TEST(suite, test_write_number_double);
     887                 :          6 :         CU_ADD_TEST(suite, test_write_uuid);
     888                 :          6 :         CU_ADD_TEST(suite, test_write_array);
     889                 :          6 :         CU_ADD_TEST(suite, test_write_object);
     890                 :          6 :         CU_ADD_TEST(suite, test_write_nesting);
     891                 :          6 :         CU_ADD_TEST(suite, test_write_val);
     892                 :            : 
     893                 :            : 
     894                 :          6 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
     895                 :            : 
     896                 :          6 :         CU_cleanup_registry();
     897                 :            : 
     898                 :          7 :         return num_failures;
     899                 :          1 : }

Generated by: LCOV version 1.14