1 /*
2 * Copyright 2018 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "Test.h"
9
10 #include "SkArenaAlloc.h"
11 #include "SkJSON.h"
12 #include "SkString.h"
13 #include "SkStream.h"
14
15 using namespace skjson;
16
DEF_TEST(JSON_Parse,reporter)17 DEF_TEST(JSON_Parse, reporter) {
18 static constexpr struct {
19 const char* in;
20 const char* out;
21 } g_tests[] = {
22 { "" , nullptr },
23 { "[" , nullptr },
24 { "]" , nullptr },
25 { "[[]" , nullptr },
26 { "[]]" , nullptr },
27 { "[]f" , nullptr },
28 { "{" , nullptr },
29 { "}" , nullptr },
30 { "{{}" , nullptr },
31 { "{}}" , nullptr },
32 { "{}f" , nullptr },
33 { "{]" , nullptr },
34 { "[}" , nullptr },
35 { "{\"}" , nullptr },
36 { "[\"]" , nullptr },
37 { "1" , nullptr },
38 { "true" , nullptr },
39 { "false", nullptr },
40 { "null" , nullptr },
41
42 { "[nulll]" , nullptr },
43 { "[false2]", nullptr },
44 { "[true:]" , nullptr },
45
46 { "[1 2]" , nullptr },
47 { "[1,,2]" , nullptr },
48 { "[1,2,]" , nullptr },
49 { "[,1,2]" , nullptr },
50
51 { "[ \"foo" , nullptr },
52 { "[ \"fo\0o\" ]" , nullptr },
53
54 { "{\"\":{}" , nullptr },
55 { "{ null }" , nullptr },
56 { "{ \"k\" : }" , nullptr },
57 { "{ : null }" , nullptr },
58 { "{ \"k\" : : null }" , nullptr },
59 { "{ \"k\" : null , }" , nullptr },
60 { "{ \"k\" : null \"k\" : 1 }", nullptr },
61
62 {R"zzz(["\)zzz" , nullptr},
63 {R"zzz(["\])zzz" , nullptr},
64 {R"zzz(["\"])zzz" , nullptr},
65 {R"zzz(["\z"])zzz" , nullptr},
66 {R"zzz(["\u"])zzz" , nullptr},
67 {R"zzz(["\u0"])zzz" , nullptr},
68 {R"zzz(["\u00"])zzz" , nullptr},
69 {R"zzz(["\u000"])zzz", nullptr},
70
71 { "[]" , "[]" },
72 { " \n\r\t [ \n\r\t ] \n\r\t " , "[]" },
73 { "[[]]" , "[[]]" },
74 { "[ null ]" , "[null]" },
75 { "[ true ]" , "[true]" },
76 { "[ false ]" , "[false]" },
77 { "[ 0 ]" , "[0]" },
78 { "[ 1 ]" , "[1]" },
79 { "[ 1.248 ]" , "[1.248]" },
80 { "[ \"\" ]" , "[\"\"]" },
81 { "[ \"foo{bar}baz\" ]" , "[\"foo{bar}baz\"]" },
82 { "[ \" f o o \" ]" , "[\" f o o \"]" },
83 { "[ \"123456\" ]" , "[\"123456\"]" },
84 { "[ \"1234567\" ]" , "[\"1234567\"]" },
85 { "[ \"12345678\" ]" , "[\"12345678\"]" },
86 { "[ \"123456789\" ]" , "[\"123456789\"]" },
87 { "[ null , true, false,0,12.8 ]", "[null,true,false,0,12.8]" },
88
89 { "{}" , "{}" },
90 { " \n\r\t { \n\r\t } \n\r\t " , "{}" },
91 { "{ \"k\" : null }" , "{\"k\":null}" },
92 { "{ \"foo{\" : \"bar}baz\" }" , "{\"foo{\":\"bar}baz\"}" },
93 { "{ \"k1\" : null, \"k2 \":0 }", "{\"k1\":null,\"k2 \":0}" },
94 { "{ \"k1\" : null, \"k1\":0 }" , "{\"k1\":null,\"k1\":0}" },
95
96 { "{ \"k1\" : null, \n\
97 \"k2\" : 0, \n\
98 \"k3\" : [ \n\
99 true, \r\n\
100 { \"kk1\" : \"foo\" , \n\
101 \"kk2\" : \"bar\" , \n\
102 \"kk3\" : 1.28 , \n\
103 \"kk4\" : [ 42 ] \n\
104 } , \n\
105 \"boo\" , \n\
106 null \n\
107 ] \n\
108 }",
109 "{\"k1\":null,\"k2\":0,\"k3\":[true,"
110 "{\"kk1\":\"foo\",\"kk2\":\"bar\",\"kk3\":1.28,\"kk4\":[42]},\"boo\",null]}" },
111
112 {R"zzz(["\""])zzz" , "[\"\"\"]"},
113 {R"zzz(["\\"])zzz" , "[\"\\\"]"},
114 {R"zzz(["\/"])zzz" , "[\"/\"]" },
115 {R"zzz(["\b"])zzz" , "[\"\b\"]"},
116 {R"zzz(["\f"])zzz" , "[\"\f\"]"},
117 {R"zzz(["\n"])zzz" , "[\"\n\"]"},
118 {R"zzz(["\r"])zzz" , "[\"\r\"]"},
119 {R"zzz(["\t"])zzz" , "[\"\t\"]"},
120 {R"zzz(["\u1234"])zzz", "[\"\u1234\"]"},
121
122 {R"zzz(["foo\"bar"])zzz" , "[\"foo\"bar\"]"},
123 {R"zzz(["foo\\bar"])zzz" , "[\"foo\\bar\"]"},
124 {R"zzz(["foo\/bar"])zzz" , "[\"foo/bar\"]" },
125 {R"zzz(["foo\bbar"])zzz" , "[\"foo\bbar\"]"},
126 {R"zzz(["foo\fbar"])zzz" , "[\"foo\fbar\"]"},
127 {R"zzz(["foo\nbar"])zzz" , "[\"foo\nbar\"]"},
128 {R"zzz(["foo\rbar"])zzz" , "[\"foo\rbar\"]"},
129 {R"zzz(["foo\tbar"])zzz" , "[\"foo\tbar\"]"},
130 {R"zzz(["foo\u1234bar"])zzz", "[\"foo\u1234bar\"]"},
131 };
132
133 for (const auto& tst : g_tests) {
134 DOM dom(tst.in, strlen(tst.in));
135 const auto success = !dom.root().is<NullValue>();
136 REPORTER_ASSERT(reporter, success == (tst.out != nullptr));
137 if (!success) continue;
138
139 SkDynamicMemoryWStream str;
140 dom.write(&str);
141 str.write8('\0');
142
143 auto data = str.detachAsData();
144 REPORTER_ASSERT(reporter, !strcmp(tst.out, static_cast<const char*>(data->data())));
145 }
146
147 }
148
149 template <typename T, typename VT>
check_primitive(skiatest::Reporter * reporter,const Value & v,T pv,bool is_type)150 static void check_primitive(skiatest::Reporter* reporter, const Value& v, T pv,
151 bool is_type) {
152
153 REPORTER_ASSERT(reporter, v.is<VT>() == is_type);
154 const VT* cast_t = v;
155 REPORTER_ASSERT(reporter, (cast_t != nullptr) == is_type);
156
157 if (is_type) {
158 REPORTER_ASSERT(reporter, &v.as<VT>() == cast_t);
159 REPORTER_ASSERT(reporter, *v.as<VT>() == pv);
160 }
161 }
162
163 template <typename T>
check_vector(skiatest::Reporter * reporter,const Value & v,size_t expected_size,bool is_vector)164 static void check_vector(skiatest::Reporter* reporter, const Value& v, size_t expected_size,
165 bool is_vector) {
166 REPORTER_ASSERT(reporter, v.is<T>() == is_vector);
167 const T* cast_t = v;
168 REPORTER_ASSERT(reporter, (cast_t != nullptr) == is_vector);
169
170 if (is_vector) {
171 const auto& vec = v.as<T>();
172 REPORTER_ASSERT(reporter, &vec == cast_t);
173 REPORTER_ASSERT(reporter, vec.size() == expected_size);
174 REPORTER_ASSERT(reporter, vec.begin() != nullptr);
175 REPORTER_ASSERT(reporter, vec.end() == vec.begin() + expected_size);
176 }
177 }
178
check_string(skiatest::Reporter * reporter,const Value & v,const char * s)179 static void check_string(skiatest::Reporter* reporter, const Value& v, const char* s) {
180 check_vector<StringValue>(reporter, v, s ? strlen(s) : 0, !!s);
181 if (s) {
182 REPORTER_ASSERT(reporter, !strcmp(v.as<StringValue>().begin(), s));
183 }
184 }
185
DEF_TEST(JSON_DOM_visit,reporter)186 DEF_TEST(JSON_DOM_visit, reporter) {
187 static constexpr char json[] = "{ \n\
188 \"k1\": null, \n\
189 \"k2\": false, \n\
190 \"k3\": true, \n\
191 \"k4\": 42, \n\
192 \"k5\": .75, \n\
193 \"k6\": \"foo\", \n\
194 \"k7\": [ 1, true, \"bar\" ], \n\
195 \"k8\": { \"kk1\": 2, \"kk2\": false, \"kk1\": \"baz\" } \n\
196 }";
197
198 DOM dom(json, strlen(json));
199
200 const auto& jroot = dom.root().as<ObjectValue>();
201 REPORTER_ASSERT(reporter, jroot.is<ObjectValue>());
202
203 {
204 const auto& v = jroot["k1"];
205 REPORTER_ASSERT(reporter, v.is<NullValue>());
206
207 check_primitive<bool, BoolValue>(reporter, v, false, false);
208 check_primitive<float, NumberValue>(reporter, v, 0, false);
209
210 check_string(reporter, v, nullptr);
211 check_vector<ArrayValue >(reporter, v, 0, false);
212 check_vector<ObjectValue>(reporter, v, 0, false);
213 }
214
215 {
216 const auto& v = jroot["k2"];
217 REPORTER_ASSERT(reporter, !v.is<NullValue>());
218
219 check_primitive<bool, BoolValue>(reporter, v, false, true);
220 check_primitive<float, NumberValue>(reporter, v, 0, false);
221
222 check_string(reporter, v, nullptr);
223 check_vector<ArrayValue >(reporter, v, 0, false);
224 check_vector<ObjectValue>(reporter, v, 0, false);
225 }
226
227 {
228 const auto& v = jroot["k3"];
229 REPORTER_ASSERT(reporter, !v.is<NullValue>());
230
231 check_primitive<bool, BoolValue>(reporter, v, true, true);
232 check_primitive<float, NumberValue>(reporter, v, 0, false);
233
234 check_string(reporter, v, nullptr);
235 check_vector<ArrayValue >(reporter, v, 0, false);
236 check_vector<ObjectValue>(reporter, v, 0, false);
237 }
238
239 {
240 const auto& v = jroot["k4"];
241 REPORTER_ASSERT(reporter, !v.is<NullValue>());
242
243 check_primitive<bool, BoolValue>(reporter, v, false, false);
244 check_primitive<float, NumberValue>(reporter, v, 42, true);
245
246 check_string(reporter, v, nullptr);
247 check_vector<ArrayValue >(reporter, v, 0, false);
248 check_vector<ObjectValue>(reporter, v, 0, false);
249 }
250
251 {
252 const auto& v = jroot["k5"];
253 REPORTER_ASSERT(reporter, !v.is<NullValue>());
254
255 check_primitive<bool, BoolValue>(reporter, v, false, false);
256 check_primitive<float, NumberValue>(reporter, v, .75f, true);
257
258 check_string(reporter, v, nullptr);
259 check_vector<ArrayValue >(reporter, v, 0, false);
260 check_vector<ObjectValue>(reporter, v, 0, false);
261 }
262
263 {
264 const auto& v = jroot["k6"];
265 REPORTER_ASSERT(reporter, !v.is<NullValue>());
266
267 check_primitive<bool, BoolValue>(reporter, v, false, false);
268 check_primitive<float, NumberValue>(reporter, v, 0, false);
269
270 check_string(reporter, v, "foo");
271 check_vector<ArrayValue >(reporter, v, 0, false);
272 check_vector<ObjectValue>(reporter, v, 0, false);
273 }
274
275 {
276 const auto& v = jroot["k7"];
277 REPORTER_ASSERT(reporter, !v.is<NullValue>());
278
279 check_primitive<bool, BoolValue>(reporter, v, false, false);
280 check_primitive<float, NumberValue>(reporter, v, 0, false);
281
282 check_string(reporter, v, nullptr);
283 check_vector<ObjectValue>(reporter, v, 0, false);
284
285 check_vector<ArrayValue >(reporter, v, 3, true);
286 check_primitive<float, NumberValue>(reporter, v.as<ArrayValue>()[0], 1, true);
287 check_primitive<bool, BoolValue>(reporter, v.as<ArrayValue>()[1], true, true);
288 check_vector<StringValue>(reporter, v.as<ArrayValue>()[2], 3, true);
289 }
290
291 {
292 const auto& v = jroot["k8"];
293 REPORTER_ASSERT(reporter, !v.is<NullValue>());
294
295 check_primitive<bool, BoolValue>(reporter, v, false, false);
296 check_primitive<float, NumberValue>(reporter, v, 0, false);
297
298 check_string(reporter, v, nullptr);
299 check_vector<ArrayValue >(reporter, v, 0, false);
300
301 check_vector<ObjectValue>(reporter, v, 3, true);
302
303 const auto& m0 = v.as<ObjectValue>().begin()[0];
304 check_string(reporter, m0.fKey, "kk1");
305 check_primitive<float, NumberValue>(reporter, m0.fValue, 2, true);
306
307 const auto& m1 = v.as<ObjectValue>().begin()[1];
308 check_string(reporter, m1.fKey, "kk2");
309 check_primitive<bool, BoolValue>(reporter, m1.fValue, false, true);
310
311 const auto& m2 = v.as<ObjectValue>().begin()[2];
312 check_string(reporter, m2.fKey, "kk1");
313 check_string(reporter, m2.fValue, "baz");
314
315 REPORTER_ASSERT(reporter, v.as<ObjectValue>()[""].is<NullValue>());
316 REPORTER_ASSERT(reporter, v.as<ObjectValue>()["nosuchkey"].is<NullValue>());
317 check_string(reporter, v.as<ObjectValue>()["kk1"], "baz");
318 check_primitive<bool, BoolValue>(reporter, v.as<ObjectValue>()["kk2"], false, true);
319 }
320 }
321
322 template <typename T>
check_value(skiatest::Reporter * reporter,const Value & v,const char * expected_string)323 void check_value(skiatest::Reporter* reporter, const Value& v, const char* expected_string) {
324 REPORTER_ASSERT(reporter, v.is<T>());
325
326 const T* cast_t = v;
327 REPORTER_ASSERT(reporter, cast_t == &v.as<T>());
328
329 const auto vstr = v.toString();
330 REPORTER_ASSERT(reporter, 0 == strcmp(expected_string, vstr.c_str()));
331 }
332
DEF_TEST(JSON_DOM_build,reporter)333 DEF_TEST(JSON_DOM_build, reporter) {
334 SkArenaAlloc alloc(4096);
335
336 const auto v0 = NullValue();
337 check_value<NullValue>(reporter, v0, "null");
338
339 const auto v1 = BoolValue(true);
340 check_value<BoolValue>(reporter, v1, "true");
341
342 const auto v2 = BoolValue(false);
343 check_value<BoolValue>(reporter, v2, "false");
344
345 const auto v3 = NumberValue(0);
346 check_value<NumberValue>(reporter, v3, "0");
347
348 const auto v4 = NumberValue(42);
349 check_value<NumberValue>(reporter, v4, "42");
350
351 const auto v5 = NumberValue(42.75f);
352 check_value<NumberValue>(reporter, v5, "42.75");
353
354 const auto v6 = StringValue(nullptr, 0, alloc);
355 check_value<StringValue>(reporter, v6, "\"\"");
356
357 const auto v7 = StringValue(" foo ", 5, alloc);
358 check_value<StringValue>(reporter, v7, "\" foo \"");
359
360 const auto v8 = StringValue(" foo bar baz ", 13, alloc);
361 check_value<StringValue>(reporter, v8, "\" foo bar baz \"");
362
363 const auto v9 = ArrayValue(nullptr, 0, alloc);
364 check_value<ArrayValue>(reporter, v9, "[]");
365
366 const Value values0[] = { v0, v3, v9 };
367 const auto v10 = ArrayValue(values0, SK_ARRAY_COUNT(values0), alloc);
368 check_value<ArrayValue>(reporter, v10, "[null,0,[]]");
369
370 const auto v11 = ObjectValue(nullptr, 0, alloc);
371 check_value<ObjectValue>(reporter, v11, "{}");
372
373 const Member members0[] = {
374 { StringValue("key_0", 5, alloc), v1 },
375 { StringValue("key_1", 5, alloc), v4 },
376 { StringValue("key_2", 5, alloc), v11 },
377 };
378 const auto v12 = ObjectValue(members0, SK_ARRAY_COUNT(members0), alloc);
379 check_value<ObjectValue>(reporter, v12, "{"
380 "\"key_0\":true,"
381 "\"key_1\":42,"
382 "\"key_2\":{}"
383 "}");
384
385 const Value values1[] = { v2, v6, v12 };
386 const auto v13 = ArrayValue(values1, SK_ARRAY_COUNT(values1), alloc);
387 check_value<ArrayValue>(reporter, v13, "["
388 "false,"
389 "\"\","
390 "{"
391 "\"key_0\":true,"
392 "\"key_1\":42,"
393 "\"key_2\":{}"
394 "}"
395 "]");
396
397 const Member members1[] = {
398 { StringValue("key_00", 6, alloc), v5 },
399 { StringValue("key_01", 6, alloc), v7 },
400 { StringValue("key_02", 6, alloc), v13 },
401 };
402 const auto v14 = ObjectValue(members1, SK_ARRAY_COUNT(members1), alloc);
403 check_value<ObjectValue>(reporter, v14, "{"
404 "\"key_00\":42.75,"
405 "\"key_01\":\" foo \","
406 "\"key_02\":["
407 "false,"
408 "\"\","
409 "{"
410 "\"key_0\":true,"
411 "\"key_1\":42,"
412 "\"key_2\":{}"
413 "}"
414 "]"
415 "}");
416 }
417
DEF_TEST(JSON_ParseNumber,reporter)418 DEF_TEST(JSON_ParseNumber, reporter) {
419 static constexpr struct {
420 const char* string;
421 SkScalar value,
422 tolerance;
423 } gTests[] = {
424 { "0", 0, 0 },
425 { "1", 1, 0 },
426
427 { "00000000", 0, 0 },
428 { "00000001", 1, 0 },
429
430 { "0.001", 0.001f, 0 },
431 { "1.001", 1.001f, 0 },
432
433 { "0.000001" , 0.000001f, 0 },
434 { "1.000001" , 1.000001f, 0 },
435 { "1000.000001", 1000.000001f, 0 },
436
437 { "0.0000000001" , 0.0000000001f, 0 },
438 { "1.0000000001" , 1.0000000001f, 0 },
439 { "1000.0000000001", 1000.0000000001f, 0 },
440
441 { "20.001111814444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444473",
442 20.001f, 0.001f },
443 };
444
445 for (const auto& test : gTests) {
446 const auto json = SkStringPrintf("{ \"key\": %s }", test.string);
447 const DOM dom(json.c_str(), json.size());
448 const ObjectValue* jroot = dom.root();
449
450 REPORTER_ASSERT(reporter, jroot);
451
452 const NumberValue* jnumber = (*jroot)["key"];
453 REPORTER_ASSERT(reporter, jnumber);
454 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(**jnumber, test.value, test.tolerance));
455 }
456 }
457