Debian Codegraph @

modules/lsp-runtime-lib/src/test/utest/fmt/json/parser.cpp

raw
1 /*
2 * Copyright (C) 2020 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2020 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 16 окт. 2019 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/test-fw/utest.h>
23 #include <lsp-plug.in/test-fw/helpers.h>
24 #include <lsp-plug.in/fmt/json/Parser.h>
25 #include <lsp-plug.in/stdlib/math.h>
26
27 namespace lsp
28 {
29 static const char *json_event_name(json::event_type_t type)
30 {
31 #define DECODE(x) case json::x: return #x;
32 switch (type)
33 {
34 DECODE(JE_OBJECT_START)
35 DECODE(JE_OBJECT_END)
36 DECODE(JE_ARRAY_START)
37 DECODE(JE_ARRAY_END)
38 DECODE(JE_PROPERTY)
39 DECODE(JE_STRING)
40 DECODE(JE_INTEGER)
41 DECODE(JE_DOUBLE)
42 DECODE(JE_BOOL)
43 DECODE(JE_NULL)
44 default: break;
45 }
46
47 #undef DECODE
48 return "JE_UNKNOWN";
49 }
50 }
51
52 UTEST_BEGIN("runtime.fmt.json", parser)
53
54 void check_event(json::Parser &p, json::event_type_t type)
55 {
56 json::event_t ev;
57 printf(" Checking event: 0x%02x (%s)\n", type, json_event_name(type));
58 UTEST_ASSERT(p.read_next(&ev) == STATUS_OK);
59 UTEST_ASSERT_MSG(ev.type == type, "Unexpected event type: 0x%02x (%s)", ev.type, json_event_name(ev.type));
60 }
61
62 void check_event(json::Parser &p, int value)
63 {
64 json::event_t ev;
65 printf(" Checking event: 0x%02x (%s) -> %d\n", json::JE_INTEGER, json_event_name(json::JE_INTEGER), int(value));
66 UTEST_ASSERT(p.read_next(&ev) == STATUS_OK);
67 UTEST_ASSERT_MSG(ev.type == json::JE_INTEGER, "Unexpected event type: 0x%02x (%s)",
68 ev.type, json_event_name(ev.type));
69 UTEST_ASSERT_MSG(ev.iValue == value,"Unexpected event value: 0x%02x (%s) -> %d",
70 ev.type, json_event_name(ev.type), int(ev.iValue));
71 }
72
73 void check_event(json::Parser &p, double value)
74 {
75 json::event_t ev;
76 printf(" Checking event: 0x%02x (%s) -> %f\n", json::JE_DOUBLE, json_event_name(json::JE_DOUBLE), double(value));
77 UTEST_ASSERT(p.read_next(&ev) == STATUS_OK);
78 UTEST_ASSERT_MSG(ev.type == json::JE_DOUBLE, "Unexpected event type: 0x%02x (%s)",
79 ev.type, json_event_name(ev.type));
80 UTEST_ASSERT_MSG(float_equals_relative(ev.fValue, value), "Unexpected event value: 0x%02x (%s) -> %f",
81 ev.type, json_event_name(ev.type), double(ev.fValue));
82 }
83
84 void check_event(json::Parser &p, bool value)
85 {
86 json::event_t ev;
87 printf(" Checking event: 0x%02x (%s) -> %s\n", json::JE_BOOL, json_event_name(json::JE_BOOL), (value) ? "true" : "false");
88 UTEST_ASSERT(p.read_next(&ev) == STATUS_OK);
89 UTEST_ASSERT_MSG(ev.type == json::JE_BOOL, "Unexpected event type: 0x%02x (%s)",
90 ev.type, json_event_name(ev.type));
91 UTEST_ASSERT_MSG(ev.bValue == value, "Unexpected event value: 0x%02x (%s) -> %s",
92 ev.type, json_event_name(ev.type), (ev.fValue) ? "true" : "false");
93 }
94
95 void check_event(json::Parser &p, json::event_type_t type, const char *text)
96 {
97 json::event_t ev;
98 LSPString tmp;
99 UTEST_ASSERT(tmp.set_utf8(text));
100 printf(" Checking event: 0x%02x (%s) -> %s\n", type, json_event_name(type), tmp.get_utf8());
101 UTEST_ASSERT(p.read_next(&ev) == STATUS_OK);
102 UTEST_ASSERT_MSG(ev.type == type, "Unexpected event type: 0x%02x (%s)",
103 ev.type, json_event_name(ev.type));
104 UTEST_ASSERT_MSG(tmp.equals(&ev.sValue), "Unexpected event value: 0x%02x (%s) -> %s",
105 ev.type, json_event_name(ev.type), ev.sValue.get_utf8());
106 }
107
108 void test_read_valid_events_json()
109 {
110 using namespace lsp::json;
111
112 static const char *data =
113 "{"
114 "\"version\": 1.0,"
115 "\"array\": ["
116 "\"string\","
117 "true,"
118 "false,"
119 "["
120 "1234,"
121 "\"value\","
122 "{}"
123 "]"
124 "],"
125 "\"object\": {"
126 "\"bvalue\": true,"
127 "\"ivalue\": 1024,"
128 "\"fvalue\": 440.0,"
129 "\"null\": null"
130 "}"
131 "}";
132
133 Parser p;
134 UTEST_ASSERT(p.wrap(data, JSON_LEGACY, "UTF-8") == STATUS_OK);
135 check_event(p, JE_OBJECT_START);
136 check_event(p, JE_PROPERTY, "version"); check_event(p, 1.0);
137 check_event(p, JE_PROPERTY, "array"); check_event(p, JE_ARRAY_START);
138 check_event(p, JE_STRING, "string");
139 check_event(p, true);
140 check_event(p, false);
141 check_event(p, JE_ARRAY_START);
142 check_event(p, 1234);
143 check_event(p, JE_STRING, "value");
144 check_event(p, JE_OBJECT_START);
145 check_event(p, JE_OBJECT_END);
146 check_event(p, JE_ARRAY_END);
147 check_event(p, JE_ARRAY_END);
148 check_event(p, JE_PROPERTY, "object"); check_event(p, JE_OBJECT_START);
149 check_event(p, JE_PROPERTY, "bvalue"); check_event(p, true);
150 check_event(p, JE_PROPERTY, "ivalue"); check_event(p, 1024);
151 check_event(p, JE_PROPERTY, "fvalue"); check_event(p, 440.0);
152 check_event(p, JE_PROPERTY, "null"); check_event(p, JE_NULL);
153 check_event(p, JE_OBJECT_END);
154 check_event(p, JE_OBJECT_END);
155
156 event_t ev;
157 UTEST_ASSERT(p.read_next(&ev) == STATUS_EOF);
158 }
159
160 void test_read_valid_events_json5()
161 {
162 using namespace lsp::json;
163
164 static const char *data =
165 "/*some comment here */{"
166 "\"version\": 5.0, // test of JSON5\n"
167 "array: ["
168 "\"string\","
169 "true,"
170 "false,"
171 "12.34,"
172 "["
173 "0x1234,"
174 "\"value\","
175 "{},"
176 "]"
177 "],\n"
178 "// object test\n"
179 "\"object\": {"
180 "bvalue: true,"
181 "ivalue: 1024,"
182 "fvalue: 440.0,"
183 "svalue: \"string value\","
184 "\"null\": null,"
185 "},"
186 "\"extra\": ["
187 "0x10,"
188 "1.6,"
189 "false,"
190 "\"read_string\","
191 "null,"
192 "null,"
193 "null,"
194 "null,"
195 "]"
196 "}\n"
197 "// Comment after end";
198
199 bool bv;
200 ssize_t iv;
201 double fv;
202 LSPString sv;
203
204 Parser p;
205 UTEST_ASSERT(p.wrap(data, JSON_VERSION5, "UTF-8") == STATUS_OK);
206 check_event(p, JE_OBJECT_START);
207 check_event(p, JE_PROPERTY, "version"); check_event(p, 5.0);
208 check_event(p, JE_PROPERTY, "array"); check_event(p, JE_ARRAY_START);
209 check_event(p, JE_STRING, "string");
210 check_event(p, true);
211 UTEST_ASSERT(p.get_bool(NULL) == STATUS_OK);
212 check_event(p, false);
213 check_event(p, 12.34);
214 UTEST_ASSERT(p.get_double(NULL) == STATUS_OK);
215 check_event(p, JE_ARRAY_START);
216 check_event(p, 0x1234);
217 UTEST_ASSERT(p.get_int(NULL) == STATUS_OK);
218 check_event(p, JE_STRING, "value");
219 UTEST_ASSERT(p.get_string(NULL) == STATUS_OK);
220 check_event(p, JE_OBJECT_START);
221 check_event(p, JE_OBJECT_END);
222 check_event(p, JE_ARRAY_END);
223 check_event(p, JE_ARRAY_END);
224 check_event(p, JE_PROPERTY, "object"); check_event(p, JE_OBJECT_START);
225 check_event(p, JE_PROPERTY, "bvalue"); check_event(p, true);
226 check_event(p, JE_PROPERTY, "ivalue"); check_event(p, 1024);
227 check_event(p, JE_PROPERTY, "fvalue"); check_event(p, 440.0);
228 check_event(p, JE_PROPERTY, "svalue"); check_event(p, JE_STRING, "string value");
229 check_event(p, JE_PROPERTY, "null"); check_event(p, JE_NULL);
230 UTEST_ASSERT(p.get_string(NULL) == STATUS_NULL);
231 UTEST_ASSERT(p.get_int(NULL) == STATUS_NULL);
232 UTEST_ASSERT(p.get_double(NULL) == STATUS_NULL);
233 UTEST_ASSERT(p.get_bool(NULL) == STATUS_NULL);
234 check_event(p, JE_OBJECT_END);
235 check_event(p, JE_PROPERTY, "extra"); check_event(p, JE_ARRAY_START);
236 UTEST_ASSERT(p.read_int(&iv) == STATUS_OK);
237 UTEST_ASSERT(iv == 0x10);
238 UTEST_ASSERT(p.read_double(&fv) == STATUS_OK);
239 UTEST_ASSERT(float_equals_relative(fv, 1.6));
240 UTEST_ASSERT(p.read_bool(&bv) == STATUS_OK);
241 UTEST_ASSERT(bv == false);
242 UTEST_ASSERT(p.read_string(&sv) == STATUS_OK);
243 UTEST_ASSERT(sv.equals_ascii("read_string"));
244
245 UTEST_ASSERT(p.read_int(&iv) == STATUS_NULL);
246 UTEST_ASSERT(p.read_double(&fv) == STATUS_NULL);
247 UTEST_ASSERT(p.read_bool(&bv) == STATUS_NULL);
248 UTEST_ASSERT(p.read_string(&sv) == STATUS_NULL);
249 check_event(p, JE_ARRAY_END);
250 check_event(p, JE_OBJECT_END);
251
252 event_t ev;
253 UTEST_ASSERT(p.read_next(&ev) == STATUS_EOF);
254 }
255
256 status_t read_fully(const char *text, json::json_version_t version)
257 {
258 using namespace lsp::json;
259
260 Parser p;
261 event_t ev;
262 status_t res;
263
264 UTEST_ASSERT(p.wrap(text, version, "UTF-8") == STATUS_OK);
265
266 while ((res = p.read_next(&ev)) == STATUS_OK) {
267 printf(" Read event: 0x%02x (%s)\n", ev.type, json_event_name(ev.type));
268 } // Nothing
269
270 if (res == STATUS_EOF)
271 res = p.close();
272 else
273 p.close();
274
275 return res;
276 }
277
278 void test_read_invalid_json()
279 {
280 static const char *list[] = {
281 "{",
282 "}",
283 "{a",
284 "{\"a\"",
285 "{\"a\"\"b\"",
286 "{\"a\":",
287 "{\"a\":b",
288 "{\"a\":\"b\"",
289 "{\"a\":\"b\"]",
290 "{\"a\":\"b\",",
291 "{\"a\":\"b\",}",
292 "{\"a\":\"b\" \"c\":\"d\"}",
293 "{a:\"b\"}",
294 "{\"a\",\"b\"}",
295
296 "[",
297 "]",
298 "[a",
299 "[\"a\"",
300 "[\"a\" \"b\"",
301 "[\"a\",",
302 "[\"a\",}",
303 "[\"a\",]",
304 "[\"a\", \"b\" \"c\"]",
305 "[\"a\":\"b\"]",
306
307 "0x123",
308 "NULL",
309 "a",
310 "\"a\", \"b\"",
311 "\"a\":\"b\"",
312 "{},[]",
313 "{}[]",
314 "[]{}",
315 "1, 2",
316
317 NULL
318 };
319
320 for (const char **ptr = list; *ptr != NULL; ++ptr)
321 {
322 printf(" Testing: %s\n", *ptr);
323 UTEST_ASSERT(read_fully(*ptr, json::JSON_LEGACY) != STATUS_OK);
324 }
325 }
326
327 void test_read_invalid_json5()
328 {
329 static const char *list[] = {
330 "{",
331 "}",
332 "{a",
333 "{\"a\"",
334 "{\"a\"\"b\"",
335 "{\"a\":",
336 "{\"a\":b",
337 "{\"a\":\"b\"",
338 "{\"a\":\"b\"]",
339 "{\"a\":\"b\",",
340 "{\"a\":\"b\" \"c\":\"d\"}",
341 "{\"a\",\"b\"}",
342
343 "[",
344 "]",
345 "[a",
346 "[\"a\"",
347 "[\"a\" \"b\"",
348 "[\"a\",",
349 "[\"a\",}",
350 "[\"a\", \"b\" \"c\"]",
351 "[\"a\":\"b\"]",
352
353 "NULL",
354 "a",
355 "0x123,",
356 "1,",
357 "\"a\", \"b\"",
358 "\"a\":\"b\"",
359 "{},[]",
360 "{}[]",
361 "[]{}",
362 "1, 2",
363
364 NULL
365 };
366
367 for (const char **ptr = list; *ptr != NULL; ++ptr)
368 {
369 printf(" Testing: %s\n", *ptr);
370 UTEST_ASSERT(read_fully(*ptr, json::JSON_VERSION5) != STATUS_OK);
371 }
372 }
373
374 void test_read_valid_json()
375 {
376 static const char *list[] = {
377 "1",
378 "1.0",
379 "null",
380 "\"a\"",
381 "[]",
382 "{}",
383
384 "[1]",
385 "[1.0]",
386 "[null]",
387 "[\"a\"]",
388 "[[]]",
389 "[{}]",
390 "[\"a\", 1]",
391 "[\"a\", 1.0]",
392 "[\"a\", null]",
393 "[\"a\", \"b\"]",
394 "[\"a\", []]",
395 "[\"a\", {}]",
396
397 "{\"a\":1}",
398 "{\"a\":1.0}",
399 "{\"a\":null}",
400 "{\"a\":\"b\"}",
401 "{\"a\":[]}",
402 "{\"a\":{}}",
403 "{\"a\":\"b\",\"c\":1}",
404 "{\"a\":\"b\",\"c\":1.0}",
405 "{\"a\":\"b\",\"c\":null}",
406 "{\"a\":\"b\",\"c\":\"d\"}",
407 "{\"a\":\"b\",\"c\":[]}",
408 "{\"a\":\"b\",\"c\":{}}",
409
410 "[{\"\":\"\"}]",
411 NULL
412 };
413
414 for (const char **ptr = list; *ptr != NULL; ++ptr)
415 {
416 printf(" Testing: %s\n", *ptr);
417 UTEST_ASSERT(read_fully(*ptr, json::JSON_LEGACY) == STATUS_OK);
418 }
419 }
420
421 void test_read_valid_json5()
422 {
423 static const char *list[] = {
424 "//a",
425 "/*a*/",
426
427 "1",
428 "0x10",
429 "1.0",
430 "null",
431 "\"a\"",
432 "[]",
433 "{}",
434
435 "/*a*/1",
436 "/*a*/0x10",
437 "/*a*/1.0",
438 "/*a*/null",
439 "/*a*/\"a\"",
440 "/*a*/[]",
441 "/*a*/{}",
442
443 "1//a",
444 "0x10//a",
445 "1.0//a",
446 "null//a",
447 "\"a\"//a",
448 "[]//a",
449 "{}//a",
450 "[/*a*/]",
451 "{/*a*/}",
452
453 "[1]",
454 "[0x10]",
455 "[1.0]",
456 "[null]",
457 "[\"a\"]",
458 "[[]]",
459 "[{}]",
460 "[1,]",
461 "[0x10,]",
462 "[1.0,]",
463 "[null,]",
464 "[\"a\",]",
465 "[[],]",
466 "[{},]",
467 "[\"a\", 1]",
468 "[\"a\", 0x10]",
469 "[\"a\", 1.0]",
470 "[\"a\", null]",
471 "[\"a\", \"b\"]",
472 "[\"a\", []]",
473 "[\"a\", {}]",
474
475 "{\"a\":1}",
476 "{\"a\":0x10}",
477 "{\"a\":1.0}",
478 "{\"a\":null}",
479 "{\"a\":\"b\"}",
480 "{\"a\":[]}",
481 "{\"a\":{}}",
482
483 "{\"a\":1,}",
484 "{\"a\":0x10,}",
485 "{\"a\":1.0,}",
486 "{\"a\":null,}",
487 "{\"a\":\"b\",}",
488 "{\"a\":[],}",
489 "{\"a\":{},}",
490
491 "{a:1}",
492 "{a:0x10}",
493 "{a:1.0}",
494 "{a:null}",
495 "{a:\"b\"}",
496 "{a:[]}",
497 "{a:{}}",
498
499 "{a:1,}",
500 "{a:0x10,}",
501 "{a:1.0,}",
502 "{a:null,}",
503 "{a:\"b\",}",
504 "{a:[],}",
505 "{a:{},}",
506
507 "{\"a\":\"b\",\"c\":1}",
508 "{\"a\":\"b\",\"c\":0x10}",
509 "{\"a\":\"b\",\"c\":1.0}",
510 "{\"a\":\"b\",\"c\":null}",
511 "{\"a\":\"b\",\"c\":\"d\"}",
512 "{\"a\":\"b\",\"c\":[]}",
513 "{\"a\":\"b\",\"c\":{}}",
514
515 NULL
516 };
517
518 for (const char **ptr = list; *ptr != NULL; ++ptr)
519 {
520 printf(" Testing: %s\n", *ptr);
521 UTEST_ASSERT(read_fully(*ptr, json::JSON_VERSION5) == STATUS_OK);
522 }
523 }
524
525 void test_skip_json()
526 {
527 using namespace lsp::json;
528
529 static const char *data =
530 "{"
531 "\"version\": 1.0,"
532 "\"array\": ["
533 "\"string\","
534 "true,"
535 "false,"
536 "["
537 "1234,"
538 "\"value\","
539 "{}"
540 "]"
541 "],"
542 "\"object\": {"
543 "\"bvalue\": true,"
544 "\"ivalue\": 1024,"
545 "\"fvalue\": 440.0,"
546 "\"null\": null"
547 "}"
548 "}";
549
550 Parser p;
551 UTEST_ASSERT(p.wrap(data, JSON_LEGACY, "UTF-8") == STATUS_OK);
552 check_event(p, JE_OBJECT_START);
553 UTEST_ASSERT(p.skip_next() == STATUS_OK); // "version": 1.0
554 check_event(p, JE_PROPERTY, "array"); check_event(p, JE_ARRAY_START);
555 UTEST_ASSERT(p.skip_next() == STATUS_OK); // "string"
556 check_event(p, true);
557 check_event(p, false);
558 UTEST_ASSERT(p.skip_next() == STATUS_OK); // [ ... ]
559 check_event(p, JE_ARRAY_END);
560 check_event(p, JE_PROPERTY, "object");
561 UTEST_ASSERT(p.skip_current() == STATUS_OK); // { ... }
562 check_event(p, JE_OBJECT_END);
563
564 event_t ev;
565 UTEST_ASSERT(p.read_next(&ev) == STATUS_EOF);
566 }
567
568 UTEST_MAIN
569 {
570 printf("Testing invalid json read...\n");
571 test_read_invalid_json();
572 printf("Testing invalid json5 read...\n");
573 test_read_invalid_json5();
574
575 printf("Testing valid json read...\n");
576 test_read_valid_json();
577 printf("Testing valid json5 read...\n");
578 test_read_valid_json5();
579
580 printf("Testing valid json events read...\n");
581 test_read_valid_events_json();
582 printf("Testing valid json5 events read...\n");
583 test_read_valid_events_json5();
584
585 printf("Testing skip method for json...\n");
586 test_skip_json();
587 }
588
589 UTEST_END