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_util.c"
11 : :
12 : : /* For spdk_json_parse() */
13 : : #include "json/json_parse.c"
14 : :
15 : : #define NUM_SETUP(x) \
16 : : snprintf(buf, sizeof(buf), "%s", x); \
17 : : v.type = SPDK_JSON_VAL_NUMBER; \
18 : : v.start = buf; \
19 : : v.len = sizeof(x) - 1
20 : :
21 : : #define NUM_UINT16_PASS(s, i) \
22 : : NUM_SETUP(s); \
23 : : CU_ASSERT(spdk_json_number_to_uint16(&v, &u16) == 0); \
24 : : CU_ASSERT(u16 == i)
25 : :
26 : : #define NUM_UINT16_FAIL(s) \
27 : : NUM_SETUP(s); \
28 : : CU_ASSERT(spdk_json_number_to_uint16(&v, &u16) != 0)
29 : :
30 : : #define NUM_INT32_PASS(s, i) \
31 : : NUM_SETUP(s); \
32 : : CU_ASSERT(spdk_json_number_to_int32(&v, &i32) == 0); \
33 : : CU_ASSERT(i32 == i)
34 : :
35 : : #define NUM_INT32_FAIL(s) \
36 : : NUM_SETUP(s); \
37 : : CU_ASSERT(spdk_json_number_to_int32(&v, &i32) != 0)
38 : :
39 : : #define NUM_UINT64_PASS(s, i) \
40 : : NUM_SETUP(s); \
41 : : CU_ASSERT(spdk_json_number_to_uint64(&v, &u64) == 0); \
42 : : CU_ASSERT(u64 == i)
43 : :
44 : : #define NUM_UINT64_FAIL(s) \
45 : : NUM_SETUP(s); \
46 : : CU_ASSERT(spdk_json_number_to_uint64(&v, &u64) != 0)
47 : :
48 : : static void
49 : 6 : test_strequal(void)
50 : : {
51 : 5 : struct spdk_json_val v;
52 : :
53 : 6 : v.type = SPDK_JSON_VAL_STRING;
54 : 6 : v.start = "test";
55 : 6 : v.len = sizeof("test") - 1;
56 : 6 : CU_ASSERT(spdk_json_strequal(&v, "test") == true);
57 : 6 : CU_ASSERT(spdk_json_strequal(&v, "TEST") == false);
58 : 6 : CU_ASSERT(spdk_json_strequal(&v, "hello") == false);
59 : 6 : CU_ASSERT(spdk_json_strequal(&v, "t") == false);
60 : :
61 : 6 : v.type = SPDK_JSON_VAL_NAME;
62 : 6 : CU_ASSERT(spdk_json_strequal(&v, "test") == true);
63 : :
64 : 6 : v.type = SPDK_JSON_VAL_NUMBER;
65 : 6 : CU_ASSERT(spdk_json_strequal(&v, "test") == false);
66 : :
67 : 6 : v.type = SPDK_JSON_VAL_STRING;
68 : 6 : v.start = "test\0hello";
69 : 6 : v.len = sizeof("test\0hello") - 1;
70 : 6 : CU_ASSERT(spdk_json_strequal(&v, "test") == false);
71 : 6 : }
72 : :
73 : : static void
74 : 6 : test_num_to_uint16(void)
75 : : {
76 : 5 : struct spdk_json_val v;
77 : 5 : char buf[100];
78 : 6 : uint16_t u16 = 0;
79 : :
80 [ - + ]: 6 : NUM_SETUP("1234");
81 : 6 : CU_ASSERT(spdk_json_number_to_uint16(&v, &u16) == 0);
82 : 6 : CU_ASSERT(u16 == 1234);
83 : :
84 [ - + ]: 6 : NUM_UINT16_PASS("0", 0);
85 [ - + ]: 6 : NUM_UINT16_PASS("1234", 1234);
86 [ - + ]: 6 : NUM_UINT16_PASS("1234.00000", 1234);
87 [ - + ]: 6 : NUM_UINT16_PASS("1.2e1", 12);
88 [ - + ]: 6 : NUM_UINT16_PASS("12340e-1", 1234);
89 : :
90 [ - + ]: 6 : NUM_UINT16_FAIL("1.2");
91 [ - + ]: 6 : NUM_UINT16_FAIL("-1234");
92 [ - + ]: 6 : NUM_UINT16_FAIL("1.2E0");
93 [ - + ]: 6 : NUM_UINT16_FAIL("1.234e1");
94 [ - + ]: 6 : NUM_UINT16_FAIL("12341e-1");
95 : 6 : }
96 : :
97 : : static void
98 : 6 : test_num_to_int32(void)
99 : : {
100 : 5 : struct spdk_json_val v;
101 : 5 : char buf[100];
102 : 6 : int32_t i32 = 0;
103 : :
104 [ - + ]: 6 : NUM_SETUP("1234");
105 : 6 : CU_ASSERT(spdk_json_number_to_int32(&v, &i32) == 0);
106 : 6 : CU_ASSERT(i32 == 1234);
107 : :
108 : :
109 [ - + ]: 6 : NUM_INT32_PASS("0", 0);
110 [ - + ]: 6 : NUM_INT32_PASS("1234", 1234);
111 [ - + ]: 6 : NUM_INT32_PASS("-1234", -1234);
112 [ - + ]: 6 : NUM_INT32_PASS("1234.00000", 1234);
113 [ - + ]: 6 : NUM_INT32_PASS("1.2e1", 12);
114 [ - + ]: 6 : NUM_INT32_PASS("12340e-1", 1234);
115 [ - + ]: 6 : NUM_INT32_PASS("-0", 0);
116 : :
117 [ - + ]: 6 : NUM_INT32_FAIL("1.2");
118 [ - + ]: 6 : NUM_INT32_FAIL("1.2E0");
119 [ - + ]: 6 : NUM_INT32_FAIL("1.234e1");
120 [ - + ]: 6 : NUM_INT32_FAIL("12341e-1");
121 : 6 : }
122 : :
123 : : static void
124 : 6 : test_num_to_uint64(void)
125 : : {
126 : 5 : struct spdk_json_val v;
127 : 5 : char buf[100];
128 : 6 : uint64_t u64 = 0;
129 : :
130 [ - + ]: 6 : NUM_SETUP("1234");
131 : 6 : CU_ASSERT(spdk_json_number_to_uint64(&v, &u64) == 0);
132 : 6 : CU_ASSERT(u64 == 1234);
133 : :
134 : :
135 [ - + ]: 6 : NUM_UINT64_PASS("0", 0);
136 [ - + ]: 6 : NUM_UINT64_PASS("1234", 1234);
137 [ - + ]: 6 : NUM_UINT64_PASS("1234.00000", 1234);
138 [ - + ]: 6 : NUM_UINT64_PASS("1.2e1", 12);
139 [ - + ]: 6 : NUM_UINT64_PASS("12340e-1", 1234);
140 [ - + ]: 6 : NUM_UINT64_PASS("123456780e-1", 12345678);
141 : :
142 [ - + ]: 6 : NUM_UINT64_FAIL("1.2");
143 [ - + ]: 6 : NUM_UINT64_FAIL("-1234");
144 [ - + ]: 6 : NUM_UINT64_FAIL("1.2E0");
145 [ - + ]: 6 : NUM_UINT64_FAIL("1.234e1");
146 [ - + ]: 6 : NUM_UINT64_FAIL("12341e-1");
147 [ - + ]: 6 : NUM_UINT64_FAIL("123456781e-1");
148 : 6 : }
149 : :
150 : : static void
151 : 6 : test_decode_object(void)
152 : : {
153 : : struct my_object {
154 : : char *my_name;
155 : : uint32_t my_int;
156 : : bool my_bool;
157 : : };
158 : 6 : struct spdk_json_val object[] = {
159 : : {"", 6, SPDK_JSON_VAL_OBJECT_BEGIN},
160 : : {"first", 5, SPDK_JSON_VAL_NAME},
161 : : {"HELLO", 5, SPDK_JSON_VAL_STRING},
162 : : {"second", 6, SPDK_JSON_VAL_NAME},
163 : : {"234", 3, SPDK_JSON_VAL_NUMBER},
164 : : {"third", 5, SPDK_JSON_VAL_NAME},
165 : : {"", 1, SPDK_JSON_VAL_TRUE},
166 : : {"", 0, SPDK_JSON_VAL_OBJECT_END},
167 : : };
168 : :
169 : 6 : struct spdk_json_object_decoder decoders[] = {
170 : : {"first", offsetof(struct my_object, my_name), spdk_json_decode_string, false},
171 : : {"second", offsetof(struct my_object, my_int), spdk_json_decode_uint32, false},
172 : : {"third", offsetof(struct my_object, my_bool), spdk_json_decode_bool, false},
173 : : {"fourth", offsetof(struct my_object, my_bool), spdk_json_decode_bool, true},
174 : : };
175 : 6 : struct my_object output = {
176 : : .my_name = NULL,
177 : : .my_int = 0,
178 : : .my_bool = false,
179 : : };
180 : 6 : uint32_t answer = 234;
181 : 6 : char *answer_str = "HELLO";
182 : 6 : bool answer_bool = true;
183 : :
184 : : /* Passing Test: object containing simple types */
185 : 6 : CU_ASSERT(spdk_json_decode_object(object, decoders, 4, &output) == 0);
186 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(output.my_name != NULL);
187 [ - + - + ]: 6 : CU_ASSERT(memcmp(output.my_name, answer_str, 6) == 0);
188 : 6 : CU_ASSERT(output.my_int == answer);
189 [ - + ]: 6 : CU_ASSERT(output.my_bool == answer_bool);
190 : :
191 : : /* Failing Test: member with no matching decoder */
192 : : /* i.e. I remove the matching decoder from the boolean argument */
193 : 6 : CU_ASSERT(spdk_json_decode_object(object, decoders, 2, &output) != 0);
194 : :
195 : : /* Failing Test: non-optional decoder with no corresponding member */
196 : :
197 : 6 : decoders[3].optional = false;
198 : 6 : CU_ASSERT(spdk_json_decode_object(object, decoders, 4, &output) != 0);
199 : :
200 : : /* return to base state */
201 : 6 : decoders[3].optional = true;
202 : :
203 : : /* Failing Test: duplicated names for json values */
204 : 6 : object[3].start = "first";
205 : 6 : object[3].len = 5;
206 : 6 : CU_ASSERT(spdk_json_decode_object(object, decoders, 3, &output) != 0);
207 : :
208 : : /* return to base state */
209 : 6 : object[3].start = "second";
210 : 6 : object[3].len = 6;
211 : :
212 : : /* Failing Test: invalid value for decoder */
213 : 6 : object[2].start = "HELO";
214 : 6 : CU_ASSERT(spdk_json_decode_object(object, decoders, 3, &output) != 0);
215 : :
216 : : /* return to base state */
217 : 6 : object[2].start = "HELLO";
218 : :
219 : : /* Failing Test: not an object */
220 : 6 : object[0].type = SPDK_JSON_VAL_ARRAY_BEGIN;
221 : 6 : CU_ASSERT(spdk_json_decode_object(object, decoders, 3, &output) != 0);
222 : :
223 : 6 : free(output.my_name);
224 : 6 : }
225 : :
226 : : static void
227 : 6 : test_free_object(void)
228 : : {
229 : : struct my_object {
230 : : char *my_name;
231 : : uint32_t my_int;
232 : : char *my_other_name;
233 : : char *empty_string;
234 : : };
235 : 6 : struct spdk_json_object_decoder decoders[] = {
236 : : {"first", offsetof(struct my_object, my_name), spdk_json_decode_string, false},
237 : : {"second", offsetof(struct my_object, my_int), spdk_json_decode_uint32, false},
238 : : {"third", offsetof(struct my_object, my_other_name), spdk_json_decode_string, true},
239 : : {"fourth", offsetof(struct my_object, empty_string), spdk_json_decode_string, false},
240 : : };
241 : 7 : struct my_object output = {
242 [ - + ]: 6 : .my_name = strdup("hello"),
243 : : .my_int = 3,
244 [ - + ]: 6 : .my_other_name = strdup("world"),
245 : : .empty_string = NULL
246 : : };
247 : :
248 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(output.my_name != NULL);
249 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(output.my_other_name != NULL);
250 : :
251 : 6 : spdk_json_free_object(decoders, 4, &output);
252 : 6 : CU_ASSERT(output.my_name == NULL);
253 : 6 : CU_ASSERT(output.my_other_name == NULL);
254 : 6 : CU_ASSERT(output.empty_string == NULL);
255 : 6 : }
256 : :
257 : : static void
258 : 6 : test_decode_array(void)
259 : : {
260 : 5 : struct spdk_json_val values[4];
261 : 6 : uint32_t my_int[2] = {0, 0};
262 : 6 : char *my_string[2] = {NULL, NULL};
263 : 5 : size_t out_size;
264 : :
265 : : /* passing integer test */
266 : 6 : values[0].type = SPDK_JSON_VAL_ARRAY_BEGIN;
267 : 6 : values[0].len = 2;
268 : 6 : values[1].type = SPDK_JSON_VAL_NUMBER;
269 : 6 : values[1].len = 4;
270 : 6 : values[1].start = "1234";
271 : 6 : values[2].type = SPDK_JSON_VAL_NUMBER;
272 : 6 : values[2].len = 4;
273 : 6 : values[2].start = "5678";
274 : 6 : values[3].type = SPDK_JSON_VAL_ARRAY_END;
275 : 6 : CU_ASSERT(spdk_json_decode_array(values, spdk_json_decode_uint32, my_int, 2, &out_size,
276 : : sizeof(uint32_t)) == 0);
277 : 6 : CU_ASSERT(my_int[0] == 1234);
278 : 6 : CU_ASSERT(my_int[1] == 5678);
279 : 6 : CU_ASSERT(out_size == 2);
280 : :
281 : : /* array length exceeds max */
282 : 6 : values[0].len = 3;
283 : 6 : CU_ASSERT(spdk_json_decode_array(values, spdk_json_decode_uint32, my_int, 2, &out_size,
284 : : sizeof(uint32_t)) != 0);
285 : :
286 : : /* mixed types */
287 : 6 : values[0].len = 2;
288 : 6 : values[2].type = SPDK_JSON_VAL_STRING;
289 : 6 : values[2].len = 5;
290 : 6 : values[2].start = "HELLO";
291 : 6 : CU_ASSERT(spdk_json_decode_array(values, spdk_json_decode_uint32, my_int, 2, &out_size,
292 : : sizeof(uint32_t)) != 0);
293 : :
294 : : /* no array start */
295 : 6 : values[0].type = SPDK_JSON_VAL_NUMBER;
296 : 6 : values[2].type = SPDK_JSON_VAL_NUMBER;
297 : 6 : values[2].len = 4;
298 : 6 : values[2].start = "5678";
299 : 6 : CU_ASSERT(spdk_json_decode_array(values, spdk_json_decode_uint32, my_int, 2, &out_size,
300 : : sizeof(uint32_t)) != 0);
301 : :
302 : : /* mismatched array type and parser */
303 : 6 : values[0].type = SPDK_JSON_VAL_ARRAY_BEGIN;
304 : 6 : values[1].type = SPDK_JSON_VAL_STRING;
305 : 6 : values[1].len = 5;
306 : 6 : values[1].start = "HELLO";
307 : 6 : values[2].type = SPDK_JSON_VAL_STRING;
308 : 6 : values[2].len = 5;
309 : 6 : values[2].start = "WORLD";
310 : 6 : CU_ASSERT(spdk_json_decode_array(values, spdk_json_decode_uint32, my_int, 2, &out_size,
311 : : sizeof(uint32_t)) != 0);
312 : :
313 : : /* passing String example */
314 : 6 : CU_ASSERT(spdk_json_decode_array(values, spdk_json_decode_string, my_string, 2, &out_size,
315 : : sizeof(char *)) == 0);
316 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(my_string[0] != NULL);
317 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(my_string[1] != NULL);
318 [ - + ]: 6 : CU_ASSERT(memcmp(my_string[0], "HELLO", 6) == 0);
319 [ - + ]: 6 : CU_ASSERT(memcmp(my_string[1], "WORLD", 6) == 0);
320 : 6 : CU_ASSERT(out_size == 2);
321 : :
322 : 6 : free(my_string[0]);
323 : 6 : free(my_string[1]);
324 : 6 : }
325 : :
326 : : static void
327 : 6 : test_decode_bool(void)
328 : : {
329 : 5 : struct spdk_json_val v;
330 : 5 : bool b;
331 : :
332 : : /* valid bool (true) */
333 : 6 : v.type = SPDK_JSON_VAL_TRUE;
334 : 6 : b = false;
335 : 6 : CU_ASSERT(spdk_json_decode_bool(&v, &b) == 0);
336 [ - + ]: 6 : CU_ASSERT(b == true);
337 : :
338 : : /* valid bool (false) */
339 : 6 : v.type = SPDK_JSON_VAL_FALSE;
340 : 6 : b = true;
341 : 6 : CU_ASSERT(spdk_json_decode_bool(&v, &b) == 0);
342 [ - + ]: 6 : CU_ASSERT(b == false);
343 : :
344 : : /* incorrect type */
345 : 6 : v.type = SPDK_JSON_VAL_NULL;
346 : 6 : CU_ASSERT(spdk_json_decode_bool(&v, &b) != 0);
347 : 6 : }
348 : :
349 : : static void
350 : 6 : test_decode_int32(void)
351 : : {
352 : 5 : struct spdk_json_val v;
353 : 5 : int32_t i;
354 : :
355 : : /* correct type and valid value */
356 : 6 : v.type = SPDK_JSON_VAL_NUMBER;
357 : 6 : v.start = "33";
358 : 6 : v.len = 2;
359 : 6 : i = 0;
360 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) == 0);
361 : 6 : CU_ASSERT(i == 33);
362 : :
363 : : /* correct type and invalid value (float) */
364 : 6 : v.start = "32.45";
365 : 6 : v.len = 5;
366 : 6 : i = 0;
367 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) != 0);
368 : :
369 : : /* incorrect type */
370 : 6 : v.type = SPDK_JSON_VAL_STRING;
371 : 6 : v.start = "String";
372 : 6 : v.len = 6;
373 : 6 : i = 0;
374 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) != 0);
375 : :
376 : : /* incorrect type */
377 : 6 : v.type = SPDK_JSON_VAL_TRUE;
378 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) != 0);
379 : :
380 : : /* edge case (integer max) */
381 : 6 : v.type = SPDK_JSON_VAL_NUMBER;
382 : 6 : v.start = "2147483647";
383 : 6 : v.len = 10;
384 : 6 : i = 0;
385 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) == 0);
386 : 6 : CU_ASSERT(i == 2147483647);
387 : :
388 : : /* invalid value (overflow) */
389 : 6 : v.start = "2147483648";
390 : 6 : i = 0;
391 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) != 0);
392 : :
393 : : /* edge case (integer min) */
394 : 6 : v.type = SPDK_JSON_VAL_NUMBER;
395 : 6 : v.start = "-2147483648";
396 : 6 : v.len = 11;
397 : 6 : i = 0;
398 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) == 0);
399 : 6 : CU_ASSERT(i == -2147483648);
400 : :
401 : : /* invalid value (overflow) */
402 : 6 : v.start = "-2147483649";
403 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) != 0);
404 : :
405 : : /* valid exponent */
406 : 6 : v.start = "4e3";
407 : 6 : v.len = 3;
408 : 6 : i = 0;
409 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) == 0);
410 : 6 : CU_ASSERT(i == 4000);
411 : :
412 : : /* invalid negative exponent */
413 : 6 : v.start = "-400e-4";
414 : 6 : v.len = 7;
415 : 6 : i = 0;
416 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) != 0);
417 : :
418 : : /* invalid negative exponent */
419 : 6 : v.start = "400e-4";
420 : 6 : v.len = 6;
421 : 6 : i = 0;
422 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) != 0);
423 : :
424 : : /* valid negative exponent */
425 : 6 : v.start = "-400e-2";
426 : 6 : v.len = 7;
427 : 6 : i = 0;
428 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) == 0);
429 : 6 : CU_ASSERT(i == -4);
430 : :
431 : : /* invalid exponent (overflow) */
432 : 6 : v.start = "-2e32";
433 : 6 : v.len = 5;
434 : 6 : i = 0;
435 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) != 0);
436 : :
437 : : /* valid exponent with decimal */
438 : 6 : v.start = "2.13e2";
439 : 6 : v.len = 6;
440 : 6 : i = 0;
441 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) == 0);
442 : 6 : CU_ASSERT(i == 213);
443 : :
444 : : /* invalid exponent with decimal */
445 : 6 : v.start = "2.134e2";
446 : 6 : v.len = 7;
447 : 6 : i = 0;
448 : 6 : CU_ASSERT(spdk_json_decode_int32(&v, &i) != 0);
449 : 6 : }
450 : :
451 : : static void
452 : 6 : test_decode_uint16(void)
453 : : {
454 : 5 : struct spdk_json_val v;
455 : 5 : uint32_t i;
456 : :
457 : : /* incorrect type */
458 : 6 : v.type = SPDK_JSON_VAL_STRING;
459 : 6 : v.start = "Strin";
460 : 6 : v.len = 5;
461 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) != 0);
462 : :
463 : : /* invalid value (float) */
464 : 6 : v.type = SPDK_JSON_VAL_NUMBER;
465 : 6 : v.start = "123.4";
466 : 6 : v.len = 5;
467 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) != 0);
468 : :
469 : : /* edge case (0) */
470 : 6 : v.start = "0";
471 : 6 : v.len = 1;
472 : 6 : i = 456;
473 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) == 0);
474 : 6 : CU_ASSERT(i == 0);
475 : :
476 : : /* invalid value (negative) */
477 : 6 : v.start = "-1";
478 : 6 : v.len = 2;
479 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) != 0);
480 : :
481 : : /* edge case (maximum) */
482 : 6 : v.start = "65535";
483 : 6 : v.len = 5;
484 : 6 : i = 0;
485 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) == 0);
486 : 6 : CU_ASSERT(i == 65535);
487 : :
488 : : /* invalid value (overflow) */
489 : 6 : v.start = "65536";
490 : 6 : v.len = 5;
491 : 6 : i = 0;
492 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) != 0);
493 : :
494 : : /* valid exponent */
495 : 6 : v.start = "66E2";
496 : 6 : v.len = 4;
497 : 6 : i = 0;
498 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) == 0);
499 : 6 : CU_ASSERT(i == 6600);
500 : :
501 : : /* invalid exponent (overflow) */
502 : 6 : v.start = "66E3";
503 : 6 : v.len = 4;
504 : 6 : i = 0;
505 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) != 0);
506 : :
507 : : /* invalid exponent (decimal) */
508 : 6 : v.start = "65.535E2";
509 : 6 : v.len = 7;
510 : 6 : i = 0;
511 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) != 0);
512 : :
513 : : /* valid exponent with decimal */
514 : 6 : v.start = "65.53E2";
515 : 6 : v.len = 7;
516 : 6 : i = 0;
517 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) == 0);
518 : 6 : CU_ASSERT(i == 6553);
519 : :
520 : : /* invalid negative exponent */
521 : 6 : v.start = "40e-2";
522 : 6 : v.len = 5;
523 : 6 : i = 0;
524 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) != 0);
525 : :
526 : : /* invalid negative exponent */
527 : 6 : v.start = "-40e-1";
528 : 6 : v.len = 6;
529 : 6 : i = 0;
530 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) != 0);
531 : :
532 : : /* valid negative exponent */
533 : 6 : v.start = "40e-1";
534 : 6 : v.len = 5;
535 : 6 : i = 0;
536 : 6 : CU_ASSERT(spdk_json_decode_uint16(&v, &i) == 0);
537 : 6 : CU_ASSERT(i == 4);
538 : 6 : }
539 : :
540 : : static void
541 : 6 : test_decode_uint32(void)
542 : : {
543 : 5 : struct spdk_json_val v;
544 : 5 : uint32_t i;
545 : :
546 : : /* incorrect type */
547 : 6 : v.type = SPDK_JSON_VAL_STRING;
548 : 6 : v.start = "String";
549 : 6 : v.len = 6;
550 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) != 0);
551 : :
552 : : /* invalid value (float) */
553 : 6 : v.type = SPDK_JSON_VAL_NUMBER;
554 : 6 : v.start = "123.45";
555 : 6 : v.len = 6;
556 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) != 0);
557 : :
558 : : /* edge case (0) */
559 : 6 : v.start = "0";
560 : 6 : v.len = 1;
561 : 6 : i = 456;
562 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) == 0);
563 : 6 : CU_ASSERT(i == 0);
564 : :
565 : : /* invalid value (negative) */
566 : 6 : v.start = "-1";
567 : 6 : v.len = 2;
568 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) != 0);
569 : :
570 : : /* edge case (maximum) */
571 : 6 : v.start = "4294967295";
572 : 6 : v.len = 10;
573 : 6 : i = 0;
574 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) == 0);
575 : 6 : CU_ASSERT(i == 4294967295);
576 : :
577 : : /* invalid value (overflow) */
578 : 6 : v.start = "4294967296";
579 : 6 : v.len = 10;
580 : 6 : i = 0;
581 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) != 0);
582 : :
583 : : /* valid exponent */
584 : 6 : v.start = "42E2";
585 : 6 : v.len = 4;
586 : 6 : i = 0;
587 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) == 0);
588 : 6 : CU_ASSERT(i == 4200);
589 : :
590 : : /* invalid exponent (overflow) */
591 : 6 : v.start = "42e32";
592 : 6 : v.len = 5;
593 : 6 : i = 0;
594 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) != 0);
595 : :
596 : : /* invalid exponent (decimal) */
597 : 6 : v.start = "42.323E2";
598 : 6 : v.len = 8;
599 : 6 : i = 0;
600 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) != 0);
601 : :
602 : : /* valid exponent with decimal */
603 : 6 : v.start = "42.32E2";
604 : 6 : v.len = 7;
605 : 6 : i = 0;
606 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) == 0);
607 : 6 : CU_ASSERT(i == 4232);
608 : :
609 : : /* invalid negative exponent */
610 : 6 : v.start = "400e-4";
611 : 6 : v.len = 6;
612 : 6 : i = 0;
613 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) != 0);
614 : :
615 : : /* invalid negative exponent */
616 : 6 : v.start = "-400e-2";
617 : 6 : v.len = 7;
618 : 6 : i = 0;
619 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) != 0);
620 : :
621 : : /* valid negative exponent */
622 : 6 : v.start = "400e-2";
623 : 6 : v.len = 6;
624 : 6 : i = 0;
625 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) == 0);
626 : 6 : CU_ASSERT(i == 4);
627 : :
628 : : /* valid negative exponent */
629 : 6 : v.start = "10e-1";
630 : 6 : v.len = 5;
631 : 6 : i = 0;
632 : 6 : CU_ASSERT(spdk_json_decode_uint32(&v, &i) == 0);
633 : 6 : CU_ASSERT(i == 1);
634 : 6 : }
635 : :
636 : : static void
637 : 6 : test_decode_uint64(void)
638 : : {
639 : 5 : struct spdk_json_val v;
640 : 5 : uint64_t i;
641 : :
642 : : /* incorrect type */
643 : 6 : v.type = SPDK_JSON_VAL_STRING;
644 : 6 : v.start = "String";
645 : 6 : v.len = 6;
646 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) != 0);
647 : :
648 : : /* invalid value (float) */
649 : 6 : v.type = SPDK_JSON_VAL_NUMBER;
650 : 6 : v.start = "123.45";
651 : 6 : v.len = 6;
652 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) != 0);
653 : :
654 : : /* edge case (0) */
655 : 6 : v.start = "0";
656 : 6 : v.len = 1;
657 : 6 : i = 456;
658 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) == 0);
659 : 6 : CU_ASSERT(i == 0);
660 : :
661 : : /* invalid value (negative) */
662 : 6 : v.start = "-1";
663 : 6 : v.len = 2;
664 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) != 0);
665 : :
666 : : /* edge case (maximum) */
667 : 6 : v.start = "18446744073709551615";
668 : 6 : v.len = 20;
669 : 6 : i = 0;
670 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) == 0);
671 : 6 : CU_ASSERT(i == 18446744073709551615U);
672 : :
673 : : /* invalid value (overflow) */
674 : 6 : v.start = "18446744073709551616";
675 : 6 : v.len = 20;
676 : 6 : i = 0;
677 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) != 0);
678 : :
679 : : /* valid exponent */
680 : 6 : v.start = "42E2";
681 : 6 : v.len = 4;
682 : 6 : i = 0;
683 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) == 0);
684 : 6 : CU_ASSERT(i == 4200);
685 : :
686 : : /* invalid exponent (overflow) */
687 : 6 : v.start = "42e64";
688 : 6 : v.len = 5;
689 : 6 : i = 0;
690 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) != 0);
691 : :
692 : : /* invalid exponent (decimal) */
693 : 6 : v.start = "42.323E2";
694 : 6 : v.len = 8;
695 : 6 : i = 0;
696 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) != 0);
697 : :
698 : : /* valid exponent with decimal */
699 : 6 : v.start = "42.32E2";
700 : 6 : v.len = 7;
701 : 6 : i = 0;
702 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) == 0);
703 : 6 : CU_ASSERT(i == 4232);
704 : :
705 : : /* invalid negative exponent */
706 : 6 : v.start = "400e-4";
707 : 6 : v.len = 6;
708 : 6 : i = 0;
709 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) != 0);
710 : :
711 : : /* invalid negative exponent */
712 : 6 : v.start = "-400e-2";
713 : 6 : v.len = 7;
714 : 6 : i = 0;
715 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) != 0);
716 : :
717 : : /* valid negative exponent */
718 : 6 : v.start = "400e-2";
719 : 6 : v.len = 6;
720 : 6 : i = 0;
721 : 6 : CU_ASSERT(spdk_json_decode_uint64(&v, &i) == 0);
722 : 6 : CU_ASSERT(i == 4);
723 : 6 : }
724 : :
725 : : static void
726 : 6 : test_decode_string(void)
727 : : {
728 : 5 : struct spdk_json_val v;
729 : 6 : char *value = NULL;
730 : :
731 : : /* Passing Test: Standard */
732 : 6 : v.type = SPDK_JSON_VAL_STRING;
733 : 6 : v.start = "HELLO";
734 : 6 : v.len = 5;
735 : 6 : CU_ASSERT(spdk_json_decode_string(&v, &value) == 0);
736 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(value != NULL);
737 [ - + - + ]: 6 : CU_ASSERT(memcmp(value, v.start, 6) == 0);
738 : :
739 : : /* Edge Test: Empty String */
740 : 6 : v.start = "";
741 : 6 : v.len = 0;
742 : 6 : CU_ASSERT(spdk_json_decode_string(&v, &value) == 0);
743 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(value != NULL);
744 : 6 : CU_ASSERT(memcmp(value, v.start, 1) == 0);
745 : :
746 : : /*
747 : : * Failing Test: Null Terminator In String
748 : : * It is valid for a json string to contain \u0000 and the parser will accept it.
749 : : * However, a null terminated C string cannot contain '\0' and should be rejected
750 : : * if that character is found before the end of the string.
751 : : */
752 : 6 : v.start = "HELO";
753 : 6 : v.len = 5;
754 : 6 : CU_ASSERT(spdk_json_decode_string(&v, &value) != 0);
755 : :
756 : : /* Failing Test: Wrong Type */
757 : 6 : v.start = "45673";
758 : 6 : v.type = SPDK_JSON_VAL_NUMBER;
759 : 6 : CU_ASSERT(spdk_json_decode_string(&v, &value) != 0);
760 : :
761 : : /* Passing Test: Special Characters */
762 : 6 : v.type = SPDK_JSON_VAL_STRING;
763 : 6 : v.start = "HE\bLL\tO\\WORLD";
764 : 6 : v.len = 13;
765 : 6 : CU_ASSERT(spdk_json_decode_string(&v, &value) == 0);
766 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(value != NULL);
767 [ - + - + ]: 6 : CU_ASSERT(memcmp(value, v.start, 14) == 0);
768 : :
769 : 6 : free(value);
770 : 6 : }
771 : :
772 : : static void
773 : 6 : test_decode_uuid(void)
774 : : {
775 : 5 : struct spdk_json_val v;
776 : 6 : struct spdk_uuid expected, uuid = {};
777 : 6 : const char *uuidstr = "e524acae-8c26-43e4-882a-461b8690583b";
778 : 6 : const char *invalid = "e524acae-8c26";
779 : : int rc;
780 : :
781 : 6 : rc = spdk_uuid_parse(&expected, uuidstr);
782 : 6 : CU_ASSERT_EQUAL(rc, 0);
783 : :
784 : : /* Check a valid UUID */
785 : 6 : v.type = SPDK_JSON_VAL_STRING;
786 : 6 : v.start = (void *)uuidstr;
787 [ - + ]: 6 : v.len = strlen(uuidstr);
788 : 6 : rc = spdk_json_decode_uuid(&v, &uuid);
789 : 6 : CU_ASSERT_EQUAL(rc, 0);
790 : 6 : CU_ASSERT_EQUAL(spdk_uuid_compare(&uuid, &expected), 0);
791 : :
792 : : /* Check empty string as UUID */
793 : 6 : v.type = SPDK_JSON_VAL_STRING;
794 : 6 : v.start = "";
795 : 6 : v.len = 0;
796 : 6 : rc = spdk_json_decode_uuid(&v, &uuid);
797 : 6 : CU_ASSERT_EQUAL(rc, -1);
798 : :
799 : : /* Check non-empty string that's not a UUID */
800 : 6 : v.type = SPDK_JSON_VAL_STRING;
801 : 6 : v.start = (void *)invalid;
802 [ - + ]: 6 : v.len = strlen(invalid);
803 : 6 : rc = spdk_json_decode_uuid(&v, &uuid);
804 : 6 : CU_ASSERT_EQUAL(rc, -1);
805 : :
806 : : /* Check decoding UUID on a non-string value */
807 : 6 : v.type = SPDK_JSON_VAL_TRUE;
808 : 6 : v.start = NULL;
809 : 6 : v.len = 0;
810 : 6 : rc = spdk_json_decode_uuid(&v, &uuid);
811 : 6 : CU_ASSERT_EQUAL(rc, -1);
812 : 6 : }
813 : :
814 : : char ut_json_text[] =
815 : : "{"
816 : : " \"string\": \"Some string data\","
817 : : " \"object\": { "
818 : : " \"another_string\": \"Yet another string data\","
819 : : " \"array name with space\": [1, [], {} ]"
820 : : " },"
821 : : " \"array\": [ \"Text\", 2, {} ]"
822 : : "}"
823 : : ;
824 : :
825 : : static void
826 : 6 : test_find(void)
827 : : {
828 : 5 : struct spdk_json_val *values, *key, *val, *key2, *val2;
829 : : ssize_t values_cnt;
830 : : ssize_t rc;
831 : :
832 : 6 : values_cnt = spdk_json_parse(ut_json_text, strlen(ut_json_text), NULL, 0, NULL, 0);
833 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(values_cnt > 0);
834 : :
835 : 6 : values = calloc(values_cnt, sizeof(struct spdk_json_val));
836 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(values != NULL);
837 : :
838 : 6 : rc = spdk_json_parse(ut_json_text, strlen(ut_json_text), values, values_cnt, NULL, 0);
839 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(values_cnt == rc);
840 : :
841 : 6 : key = val = NULL;
842 : 6 : rc = spdk_json_find(values, "string", &key, &val, SPDK_JSON_VAL_STRING);
843 : 6 : CU_ASSERT(rc == 0);
844 : :
845 [ + - + - ]: 6 : CU_ASSERT(key != NULL && spdk_json_strequal(key, "string") == true);
846 [ + - + - ]: 6 : CU_ASSERT(val != NULL && spdk_json_strequal(val, "Some string data") == true);
847 : :
848 : 6 : key = val = NULL;
849 : 6 : rc = spdk_json_find(values, "object", &key, &val, SPDK_JSON_VAL_OBJECT_BEGIN);
850 : 6 : CU_ASSERT(rc == 0);
851 : :
852 [ + - + - ]: 6 : CU_ASSERT(key != NULL && spdk_json_strequal(key, "object") == true);
853 : :
854 : : /* Find key in "object" by passing SPDK_JSON_VAL_ANY to match any type */
855 : 6 : key2 = val2 = NULL;
856 : 6 : rc = spdk_json_find(val, "array name with space", &key2, &val2, SPDK_JSON_VAL_ANY);
857 : 6 : CU_ASSERT(rc == 0);
858 [ + - + - ]: 6 : CU_ASSERT(key2 != NULL && spdk_json_strequal(key2, "array name with space") == true);
859 [ + - + - ]: 6 : CU_ASSERT(val2 != NULL && val2->type == SPDK_JSON_VAL_ARRAY_BEGIN);
860 : :
861 : : /* Find the "array" key in "object" by passing SPDK_JSON_VAL_ARRAY_BEGIN to match only array */
862 : 6 : key2 = val2 = NULL;
863 : 6 : rc = spdk_json_find(val, "array name with space", &key2, &val2, SPDK_JSON_VAL_ARRAY_BEGIN);
864 : 6 : CU_ASSERT(rc == 0);
865 [ + - + - ]: 6 : CU_ASSERT(key2 != NULL && spdk_json_strequal(key2, "array name with space") == true);
866 [ + - + - ]: 6 : CU_ASSERT(val2 != NULL && val2->type == SPDK_JSON_VAL_ARRAY_BEGIN);
867 : :
868 : : /* Negative test - key doesn't exist */
869 : 6 : key2 = val2 = NULL;
870 : 6 : rc = spdk_json_find(val, "this_key_does_not_exist", &key2, &val2, SPDK_JSON_VAL_ANY);
871 : 6 : CU_ASSERT(rc == -ENOENT);
872 : :
873 : : /* Negative test - key type doesn't match */
874 : 6 : key2 = val2 = NULL;
875 : 6 : rc = spdk_json_find(val, "another_string", &key2, &val2, SPDK_JSON_VAL_ARRAY_BEGIN);
876 : 6 : CU_ASSERT(rc == -EDOM);
877 : :
878 : 6 : free(values);
879 : 6 : }
880 : :
881 : : static void
882 : 6 : test_find_array(void)
883 : : {
884 : 6 : char array_json_text[] = "[ \"Text\", 2, {} ]";
885 : 5 : struct spdk_json_val *values, *key;
886 : : ssize_t values_cnt;
887 : : ssize_t rc;
888 : :
889 : 6 : values_cnt = spdk_json_parse(array_json_text, strlen(array_json_text), NULL, 0, NULL, 0);
890 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(values_cnt > 0);
891 : :
892 : 6 : values = calloc(values_cnt, sizeof(struct spdk_json_val));
893 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(values != NULL);
894 : :
895 : 6 : rc = spdk_json_parse(array_json_text, strlen(array_json_text), values, values_cnt, NULL, 0);
896 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(values_cnt == rc);
897 : :
898 : : /* spdk_json_find cannot be used on arrays. The element "Text" does exist in the array,
899 : : * but spdk_json_find can only be used for finding keys in an object. So this
900 : : * test should fail.
901 : : */
902 : 6 : key = NULL;
903 : 6 : rc = spdk_json_find(values, "Text", &key, NULL, SPDK_JSON_VAL_STRING);
904 : 6 : CU_ASSERT(rc == -EPROTOTYPE);
905 : :
906 : 6 : free(values);
907 : 6 : }
908 : :
909 : : static void
910 : 6 : test_iterating(void)
911 : : {
912 : : struct spdk_json_val *values;
913 : : struct spdk_json_val *string_key;
914 : : struct spdk_json_val *object_key, *object_val;
915 : : struct spdk_json_val *array_key, *array_val;
916 : : struct spdk_json_val *another_string_key;
917 : : struct spdk_json_val *array_name_with_space_key, *array_name_with_space_val;
918 : : struct spdk_json_val *it;
919 : : ssize_t values_cnt;
920 : : ssize_t rc;
921 : :
922 : 6 : values_cnt = spdk_json_parse(ut_json_text, strlen(ut_json_text), NULL, 0, NULL, 0);
923 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(values_cnt > 0);
924 : :
925 : 6 : values = calloc(values_cnt, sizeof(struct spdk_json_val));
926 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(values != NULL);
927 : :
928 : 6 : rc = spdk_json_parse(ut_json_text, strlen(ut_json_text), values, values_cnt, NULL, 0);
929 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(values_cnt == rc);
930 : :
931 : : /* Iterate over object keys. JSON spec doesn't guarantee order of keys in object but
932 : : * SPDK implementation implicitly does.
933 : : */
934 : 6 : string_key = spdk_json_object_first(values);
935 : 6 : CU_ASSERT(spdk_json_strequal(string_key, "string") == true);
936 : :
937 : 6 : object_key = spdk_json_next(string_key);
938 : 6 : object_val = json_value(object_key);
939 : 6 : CU_ASSERT(spdk_json_strequal(object_key, "object") == true);
940 : :
941 : 6 : array_key = spdk_json_next(object_key);
942 : 6 : array_val = json_value(array_key);
943 : 6 : CU_ASSERT(spdk_json_strequal(array_key, "array") == true);
944 : :
945 : : /* NULL '}' */
946 : 6 : CU_ASSERT(spdk_json_next(array_key) == NULL);
947 : :
948 : : /* Iterate over subobjects */
949 : 6 : another_string_key = spdk_json_object_first(object_val);
950 : 6 : CU_ASSERT(spdk_json_strequal(another_string_key, "another_string") == true);
951 : :
952 : 6 : array_name_with_space_key = spdk_json_next(another_string_key);
953 : 6 : array_name_with_space_val = json_value(array_name_with_space_key);
954 : 6 : CU_ASSERT(spdk_json_strequal(array_name_with_space_key, "array name with space") == true);
955 : :
956 : 6 : CU_ASSERT(spdk_json_next(array_name_with_space_key) == NULL);
957 : :
958 : : /* Iterate over array in subobject */
959 : 6 : it = spdk_json_array_first(array_name_with_space_val);
960 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(it != NULL);
961 : 6 : CU_ASSERT(it->type == SPDK_JSON_VAL_NUMBER);
962 : :
963 : 6 : it = spdk_json_next(it);
964 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(it != NULL);
965 : 6 : CU_ASSERT(it->type == SPDK_JSON_VAL_ARRAY_BEGIN);
966 : :
967 : 6 : it = spdk_json_next(it);
968 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(it != NULL);
969 : 6 : CU_ASSERT(it->type == SPDK_JSON_VAL_OBJECT_BEGIN);
970 : :
971 : 6 : it = spdk_json_next(it);
972 : 6 : CU_ASSERT(it == NULL);
973 : :
974 : : /* Iterate over array in root object */
975 : 6 : it = spdk_json_array_first(array_val);
976 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(it != NULL);
977 : 6 : CU_ASSERT(it->type == SPDK_JSON_VAL_STRING);
978 : :
979 : 6 : it = spdk_json_next(it);
980 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(it != NULL);
981 : 6 : CU_ASSERT(it->type == SPDK_JSON_VAL_NUMBER);
982 : :
983 : 6 : it = spdk_json_next(it);
984 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(it != NULL);
985 : 6 : CU_ASSERT(it->type == SPDK_JSON_VAL_OBJECT_BEGIN);
986 : :
987 : : /* Array end */
988 : 6 : it = spdk_json_next(it);
989 : 6 : CU_ASSERT(it == NULL);
990 : :
991 : 6 : free(values);
992 : 6 : }
993 : :
994 : : int
995 : 6 : main(int argc, char **argv)
996 : : {
997 : 6 : CU_pSuite suite = NULL;
998 : : unsigned int num_failures;
999 : :
1000 : 6 : CU_initialize_registry();
1001 : :
1002 : 6 : suite = CU_add_suite("json", NULL, NULL);
1003 : :
1004 : 6 : CU_ADD_TEST(suite, test_strequal);
1005 : 6 : CU_ADD_TEST(suite, test_num_to_uint16);
1006 : 6 : CU_ADD_TEST(suite, test_num_to_int32);
1007 : 6 : CU_ADD_TEST(suite, test_num_to_uint64);
1008 : 6 : CU_ADD_TEST(suite, test_decode_object);
1009 : 6 : CU_ADD_TEST(suite, test_decode_array);
1010 : 6 : CU_ADD_TEST(suite, test_decode_bool);
1011 : 6 : CU_ADD_TEST(suite, test_decode_uint16);
1012 : 6 : CU_ADD_TEST(suite, test_decode_int32);
1013 : 6 : CU_ADD_TEST(suite, test_decode_uint32);
1014 : 6 : CU_ADD_TEST(suite, test_decode_uint64);
1015 : 6 : CU_ADD_TEST(suite, test_decode_string);
1016 : 6 : CU_ADD_TEST(suite, test_decode_uuid);
1017 : 6 : CU_ADD_TEST(suite, test_find);
1018 : 6 : CU_ADD_TEST(suite, test_find_array);
1019 : 6 : CU_ADD_TEST(suite, test_iterating);
1020 : 6 : CU_ADD_TEST(suite, test_free_object);
1021 : :
1022 : :
1023 : 6 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
1024 : :
1025 : 6 : CU_cleanup_registry();
1026 : :
1027 : 6 : return num_failures;
1028 : : }
|