Debian Codegraph @

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

raw
1 /*
2 * Copyright (C) 2021 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2021 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 23 февр. 2021 г.
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/dom.h>
25
26 namespace
27 {
28 static const char *serialized=
29 "{"
30 "\"array\":"
31 "["
32 "null" ","
33 "32" ","
34 "-20.0" ","
35 "true" ","
36 "\"array\""
37 "]" ","
38 "\"bool\":" "true" ","
39 "\"float\":" "440.0" ","
40 "\"int\":" "42" ","
41 "\"null\":" "null" ","
42 "\"object\":"
43 "{"
44 "\"bv\":" "false" ","
45 "\"fv\":" "123.0" ","
46 "\"iv\":" "10" ","
47 "\"nv\":" "null" ","
48 "\"sv\":" "\"string\""
49 "}" ","
50 "\"str\":" "\"test\""
51 "}";
52 }
53
54 UTEST_BEGIN("runtime.fmt.json", dom)
55
56 void create_object(json::Node &node)
57 {
58 json::Object o = json::Object::build();
59 json::Object child = json::Object::build();
60 json::Array array = json::Array::build();
61
62 // Create root object
63 UTEST_ASSERT(o.set("null", json::Node::build()) == STATUS_OK);
64 UTEST_ASSERT(o.set("int", json::Integer::build(42)) == STATUS_OK);
65 UTEST_ASSERT(o.set("float", json::Double::build(440.0)) == STATUS_OK);
66 UTEST_ASSERT(o.set("bool", json::Boolean::build(true)) == STATUS_OK);
67 UTEST_ASSERT(o.set("array", array) == STATUS_OK);
68 UTEST_ASSERT(o.set("str", json::String::build("test")) == STATUS_OK);
69 UTEST_ASSERT(o.set("object", child) == STATUS_OK);
70
71 // Init array object
72 UTEST_ASSERT(array.add(json::Node::build()) == STATUS_OK);
73 UTEST_ASSERT(array.add(json::Integer::build(32)) == STATUS_OK);
74 UTEST_ASSERT(array.add(json::Double::build(-20.0)) == STATUS_OK);
75 UTEST_ASSERT(array.add(json::Boolean::build(true)) == STATUS_OK);
76 UTEST_ASSERT(array.add(json::String::build("array")) == STATUS_OK);
77
78 // Init child object
79 UTEST_ASSERT(child.set("nv", json::Node::build()) == STATUS_OK);
80 UTEST_ASSERT(child.set("iv", json::Integer::build(10)) == STATUS_OK);
81 UTEST_ASSERT(child.set("fv", json::Double::build(123.0)) == STATUS_OK);
82 UTEST_ASSERT(child.set("bv", json::Boolean::build(false)) == STATUS_OK);
83 UTEST_ASSERT(child.set("sv", json::String::build("string")) == STATUS_OK);
84
85 // Return data to the node
86 node.assign(o);
87 }
88
89 void validate_object(json::Node &node)
90 {
91 json::Object o = node;
92
93 json::Node nv;
94 json::Integer iv;
95 json::Double dv;
96 json::Boolean bv;
97 json::String sv;
98 json::Array av;
99 json::Object ov;
100 LSPString str;
101
102 // Check the object
103 UTEST_ASSERT(node.is_object());
104 UTEST_ASSERT(o.valid());
105 UTEST_ASSERT(o.size() == 7);
106 UTEST_ASSERT(o.contains("null"));
107 UTEST_ASSERT(o.contains("int"));
108 UTEST_ASSERT(o.contains("float"));
109 UTEST_ASSERT(o.contains("bool"));
110 UTEST_ASSERT(o.contains("str"));
111 UTEST_ASSERT(o.contains("array"));
112 UTEST_ASSERT(o.contains("object"));
113
114 // Validate object fields
115 nv = o.get("null");
116 UTEST_ASSERT(nv.valid());
117 UTEST_ASSERT(nv.is_null());
118
119 iv = o.get("int");
120 UTEST_ASSERT(iv.valid());
121 UTEST_ASSERT(iv.is_int());
122 UTEST_ASSERT(iv.get() == 42);
123
124 dv = o.get("float");
125 UTEST_ASSERT(dv.valid());
126 UTEST_ASSERT(dv.is_double());
127 UTEST_ASSERT(float_equals_absolute(dv.get(), 440.0));
128
129 bv = o.get("bool");
130 UTEST_ASSERT(bv.valid());
131 UTEST_ASSERT(bv.is_bool());
132 UTEST_ASSERT(bv.get() == true);
133
134 sv = o.get("str");
135 UTEST_ASSERT(sv.valid());
136 UTEST_ASSERT(sv.is_string());
137 UTEST_ASSERT(sv.get(&str) == STATUS_OK);
138 UTEST_ASSERT(str.equals_ascii("test"));
139
140 av = o.get("array");
141 UTEST_ASSERT(av.valid());
142 UTEST_ASSERT(av.is_array());
143 UTEST_ASSERT(av.size() == 5);
144 {
145 nv = av.get(0);
146 UTEST_ASSERT(nv.valid());
147 UTEST_ASSERT(nv.is_null());
148
149 iv = av.get(1);
150 UTEST_ASSERT(iv.valid());
151 UTEST_ASSERT(iv.is_int());
152 UTEST_ASSERT(iv.get() == 32);
153
154 dv = av.get(2);
155 UTEST_ASSERT(dv.valid());
156 UTEST_ASSERT(dv.is_double());
157 UTEST_ASSERT(float_equals_absolute(dv.get(), -20.0));
158
159 bv = av.get(3);
160 UTEST_ASSERT(bv.valid());
161 UTEST_ASSERT(bv.is_bool());
162 UTEST_ASSERT(bv.get() == true);
163
164 sv = av.get(4);
165 UTEST_ASSERT(sv.valid());
166 UTEST_ASSERT(sv.is_string());
167 UTEST_ASSERT(sv.get(&str) == STATUS_OK);
168 UTEST_ASSERT(str.equals_ascii("array"));
169 }
170
171 ov = o.get("object");
172 UTEST_ASSERT(ov.valid());
173 UTEST_ASSERT(ov.is_object());
174 UTEST_ASSERT(ov.size() == 5);
175 {
176 nv = ov.get("nv");
177 UTEST_ASSERT(nv.valid());
178 UTEST_ASSERT(nv.is_null());
179
180 iv = ov.get("iv");
181 UTEST_ASSERT(iv.valid());
182 UTEST_ASSERT(iv.is_int());
183 UTEST_ASSERT(iv.get() == 10);
184
185 dv = ov.get("fv");
186 UTEST_ASSERT(dv.valid());
187 UTEST_ASSERT(dv.is_double());
188 UTEST_ASSERT(float_equals_absolute(dv.get(), 123.0));
189
190 bv = ov.get("bv");
191 UTEST_ASSERT(bv.valid());
192 UTEST_ASSERT(bv.is_bool());
193 UTEST_ASSERT(bv.get() == false);
194
195 sv = ov.get("sv");
196 UTEST_ASSERT(sv.valid());
197 UTEST_ASSERT(sv.is_string());
198 UTEST_ASSERT(sv.get(&str) == STATUS_OK);
199 UTEST_ASSERT(str.equals_ascii("string"));
200 }
201 }
202
203 void test_create_object()
204 {
205 printf("Testing JSON object creation\n");
206
207 json::Node node;
208 create_object(node);
209 validate_object(node);
210 }
211
212 void test_change_object()
213 {
214 printf("Testing JSON object modification\n");
215
216 LSPString str;
217
218 json::Object ov = json::Object::build();
219 json::Node nv;
220 json::Integer iv;
221 json::Double dv;
222 json::Boolean bv;
223 json::String sv;
224
225 UTEST_ASSERT(ov.set("k1", json::Node::build()) == STATUS_OK);
226 UTEST_ASSERT(ov.set("k2", json::Integer::build(42)) == STATUS_OK);
227 UTEST_ASSERT(ov.set("k3", json::Double::build(440.0)) == STATUS_OK);
228 UTEST_ASSERT(ov.set("k4", json::Boolean::build(true)) == STATUS_OK);
229 UTEST_ASSERT(ov.set("k5", json::String::build("test")) == STATUS_OK);
230
231 // Check values
232 nv = ov.get("k1");
233 UTEST_ASSERT(nv.valid());
234 UTEST_ASSERT(nv.is_null());
235
236 iv = ov.get("k2");
237 UTEST_ASSERT(iv.valid());
238 UTEST_ASSERT(iv.is_int());
239 UTEST_ASSERT(iv.get() == 42);
240
241 dv = ov.get("k3");
242 UTEST_ASSERT(dv.valid());
243 UTEST_ASSERT(dv.is_double());
244 UTEST_ASSERT(float_equals_absolute(dv.get(), 440.0));
245
246 bv = ov.get("k4");
247 UTEST_ASSERT(bv.valid());
248 UTEST_ASSERT(bv.is_bool());
249 UTEST_ASSERT(bv.get() == true);
250
251 sv = ov.get("k5");
252 UTEST_ASSERT(sv.valid());
253 UTEST_ASSERT(sv.is_string());
254 UTEST_ASSERT(sv.get(&str) == STATUS_OK);
255 UTEST_ASSERT(str.equals_ascii("test"));
256
257 // Update values
258 UTEST_ASSERT(ov.set("k1", json::Integer::build(32)) == STATUS_OK);
259 UTEST_ASSERT(ov.set("k2", json::Double::build(48000.0)) == STATUS_OK);
260 UTEST_ASSERT(ov.set("k3", json::Boolean::build(false)) == STATUS_OK);
261 UTEST_ASSERT(ov.set("k4", json::String::build("updated")) == STATUS_OK);
262 UTEST_ASSERT(ov.set("k5", json::Node::build()) == STATUS_OK);
263
264 // Check values
265 iv = ov.get("k1");
266 UTEST_ASSERT(iv.valid());
267 UTEST_ASSERT(iv.is_int());
268 UTEST_ASSERT(iv.get() == 32);
269
270 dv = ov.get("k2");
271 UTEST_ASSERT(dv.valid());
272 UTEST_ASSERT(dv.is_double());
273 UTEST_ASSERT(float_equals_absolute(dv.get(), 48000.0));
274
275 bv = ov.get("k3");
276 UTEST_ASSERT(bv.valid());
277 UTEST_ASSERT(bv.is_bool());
278 UTEST_ASSERT(bv.get() == false);
279
280 sv = ov.get("k4");
281 UTEST_ASSERT(sv.valid());
282 UTEST_ASSERT(sv.is_string());
283 UTEST_ASSERT(sv.get(&str) == STATUS_OK);
284 UTEST_ASSERT(str.equals_ascii("updated"));
285
286 nv = ov.get("k5");
287 UTEST_ASSERT(nv.valid());
288 UTEST_ASSERT(nv.is_null());
289
290 // Overwrite values by reference
291 dv = ov.get("k1");
292 UTEST_ASSERT(!dv.valid());
293 UTEST_ASSERT(!dv.is_double());
294 UTEST_ASSERT(dv.set(123.0) == STATUS_OK);
295
296 bv = ov.get("k2");
297 UTEST_ASSERT(!bv.valid());
298 UTEST_ASSERT(!bv.is_bool());
299 UTEST_ASSERT(bv.set(true) == STATUS_OK);
300
301 sv = ov.get("k3");
302 UTEST_ASSERT(!sv.valid());
303 UTEST_ASSERT(!sv.is_string());
304 UTEST_ASSERT(sv.set("reference") == STATUS_OK);
305
306 nv = ov.get("k4");
307 UTEST_ASSERT(!nv.is_null());
308 nv.set_null();
309
310 iv = ov.get("k5");
311 UTEST_ASSERT(!iv.valid());
312 UTEST_ASSERT(!iv.is_int());
313 UTEST_ASSERT(iv.set(100500) == STATUS_OK);
314
315 // Validate values
316 dv = ov.get("k1");
317 UTEST_ASSERT(dv.valid());
318 UTEST_ASSERT(dv.is_double());
319 UTEST_ASSERT(float_equals_absolute(dv.get(), 123.0));
320
321 bv = ov.get("k2");
322 UTEST_ASSERT(bv.valid());
323 UTEST_ASSERT(bv.is_bool());
324 UTEST_ASSERT(bv.get() == true);
325
326 sv = ov.get("k3");
327 UTEST_ASSERT(sv.valid());
328 UTEST_ASSERT(sv.is_string());
329 UTEST_ASSERT(sv.get(&str) == STATUS_OK);
330 UTEST_ASSERT(str.equals_ascii("reference"));
331
332 nv = ov.get("k4");
333 UTEST_ASSERT(nv.valid());
334 UTEST_ASSERT(nv.is_null());
335
336 iv = ov.get("k5");
337 UTEST_ASSERT(iv.valid());
338 UTEST_ASSERT(iv.is_int());
339 UTEST_ASSERT(iv.get() == 100500);
340 }
341
342 void test_string_serialize()
343 {
344 json::Node obj;
345 LSPString out;
346 json::serial_flags_t settings;
347
348 printf("Testing JSON object to string serialization\n");
349
350 json::init_serial_flags(&settings);
351 settings.fmt_double = "%.1f";
352 create_object(obj);
353
354 UTEST_ASSERT(json::dom_write(&out, &obj, &settings) == STATUS_OK);
355 printf("Expected: %s\n", serialized);
356 printf("Serialized: %s\n", out.get_native());
357 UTEST_ASSERT(out.equals_ascii(serialized));
358 }
359
360 void test_string_deserialize()
361 {
362 json::Node obj;
363
364 printf("Testing JSON string to object to deserialization\n");
365 UTEST_ASSERT(json::dom_parse(serialized, &obj, json::JSON_LEGACY) == STATUS_OK);
366 validate_object(obj);
367 }
368
369 void test_file_serialization()
370 {
371 json::Node obj1;
372 json::Node obj2;
373 LSPString out;
374 json::serial_flags_t settings;
375 io::Path path;
376
377 printf("Testing JSON object to file serialization\n");
378
379 UTEST_ASSERT(path.fmt("%s/%s.json", tempdir(), full_name()) > 0);
380
381 // Serialize file
382 json::init_serial_flags(&settings);
383 settings.fmt_double = "%.2f";
384 settings.padding = '\t';
385 settings.multiline = true;
386 settings.separator = true;
387 create_object(obj1);
388
389 UTEST_ASSERT(json::dom_save(&path, &obj1, &settings, "UTF-8") == STATUS_OK);
390 printf(" saved JSON to file: %s\n", path.as_native());
391
392 // Validate
393 validate_object(obj1);
394
395 // Deserialize file
396 UTEST_ASSERT(json::dom_load(&path, &obj2, json::JSON_LEGACY, "UTF-8") == STATUS_OK);
397 printf(" loaded JSON from file: %s\n", path.as_native());
398
399 // Validate
400 validate_object(obj2);
401 }
402
403 UTEST_MAIN
404 {
405 test_create_object();
406 test_change_object();
407 test_string_serialize();
408 test_string_deserialize();
409 test_file_serialization();
410 }
411 UTEST_END
412
413