1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/json/json_reader.h"
6
7 #include <stddef.h>
8
9 #include <memory>
10
11 #if !defined(__ANDROID__) && !defined(__ANDROID_HOST__)
12 #include "base/base_paths.h"
13 #include "base/path_service.h"
14 #endif
15
16 #include "base/files/file_util.h"
17 #include "base/logging.h"
18 #include "base/macros.h"
19 #include "base/strings/string_piece.h"
20 #include "base/strings/utf_string_conversions.h"
21 #include "base/values.h"
22 #include "build/build_config.h"
23 #include "testing/gtest/include/gtest/gtest.h"
24
25 namespace base {
26
TEST(JSONReaderTest,Reading)27 TEST(JSONReaderTest, Reading) {
28 {
29 // some whitespace checking
30 std::unique_ptr<Value> root = JSONReader().ReadToValue(" null ");
31 ASSERT_TRUE(root);
32 EXPECT_TRUE(root->IsType(Value::Type::NONE));
33 }
34
35 {
36 // Invalid JSON string
37 EXPECT_FALSE(JSONReader().ReadToValue("nu"));
38 }
39
40 {
41 // Simple bool
42 std::unique_ptr<Value> root = JSONReader().ReadToValue("true ");
43 ASSERT_TRUE(root);
44 EXPECT_TRUE(root->IsType(Value::Type::BOOLEAN));
45 }
46
47 {
48 // Embedded comment
49 std::unique_ptr<Value> root = JSONReader().ReadToValue("/* comment */null");
50 ASSERT_TRUE(root);
51 EXPECT_TRUE(root->IsType(Value::Type::NONE));
52 root = JSONReader().ReadToValue("40 /* comment */");
53 ASSERT_TRUE(root);
54 EXPECT_TRUE(root->IsType(Value::Type::INTEGER));
55 root = JSONReader().ReadToValue("true // comment");
56 ASSERT_TRUE(root);
57 EXPECT_TRUE(root->IsType(Value::Type::BOOLEAN));
58 root = JSONReader().ReadToValue("/* comment */\"sample string\"");
59 ASSERT_TRUE(root);
60 EXPECT_TRUE(root->IsType(Value::Type::STRING));
61 std::string value;
62 EXPECT_TRUE(root->GetAsString(&value));
63 EXPECT_EQ("sample string", value);
64 std::unique_ptr<ListValue> list = ListValue::From(
65 JSONReader().ReadToValue("[1, /* comment, 2 ] */ \n 3]"));
66 ASSERT_TRUE(list);
67 EXPECT_EQ(2u, list->GetSize());
68 int int_val = 0;
69 EXPECT_TRUE(list->GetInteger(0, &int_val));
70 EXPECT_EQ(1, int_val);
71 EXPECT_TRUE(list->GetInteger(1, &int_val));
72 EXPECT_EQ(3, int_val);
73 list = ListValue::From(JSONReader().ReadToValue("[1, /*a*/2, 3]"));
74 ASSERT_TRUE(list);
75 EXPECT_EQ(3u, list->GetSize());
76 root = JSONReader().ReadToValue("/* comment **/42");
77 ASSERT_TRUE(root);
78 EXPECT_TRUE(root->IsType(Value::Type::INTEGER));
79 EXPECT_TRUE(root->GetAsInteger(&int_val));
80 EXPECT_EQ(42, int_val);
81 root = JSONReader().ReadToValue(
82 "/* comment **/\n"
83 "// */ 43\n"
84 "44");
85 ASSERT_TRUE(root);
86 EXPECT_TRUE(root->IsType(Value::Type::INTEGER));
87 EXPECT_TRUE(root->GetAsInteger(&int_val));
88 EXPECT_EQ(44, int_val);
89 }
90
91 {
92 // Test number formats
93 std::unique_ptr<Value> root = JSONReader().ReadToValue("43");
94 ASSERT_TRUE(root);
95 EXPECT_TRUE(root->IsType(Value::Type::INTEGER));
96 int int_val = 0;
97 EXPECT_TRUE(root->GetAsInteger(&int_val));
98 EXPECT_EQ(43, int_val);
99 }
100
101 {
102 // According to RFC4627, oct, hex, and leading zeros are invalid JSON.
103 EXPECT_FALSE(JSONReader().ReadToValue("043"));
104 EXPECT_FALSE(JSONReader().ReadToValue("0x43"));
105 EXPECT_FALSE(JSONReader().ReadToValue("00"));
106 }
107
108 {
109 // Test 0 (which needs to be special cased because of the leading zero
110 // clause).
111 std::unique_ptr<Value> root = JSONReader().ReadToValue("0");
112 ASSERT_TRUE(root);
113 EXPECT_TRUE(root->IsType(Value::Type::INTEGER));
114 int int_val = 1;
115 EXPECT_TRUE(root->GetAsInteger(&int_val));
116 EXPECT_EQ(0, int_val);
117 }
118
119 {
120 // Numbers that overflow ints should succeed, being internally promoted to
121 // storage as doubles
122 std::unique_ptr<Value> root = JSONReader().ReadToValue("2147483648");
123 ASSERT_TRUE(root);
124 double double_val;
125 EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
126 double_val = 0.0;
127 EXPECT_TRUE(root->GetAsDouble(&double_val));
128 EXPECT_DOUBLE_EQ(2147483648.0, double_val);
129 root = JSONReader().ReadToValue("-2147483649");
130 ASSERT_TRUE(root);
131 EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
132 double_val = 0.0;
133 EXPECT_TRUE(root->GetAsDouble(&double_val));
134 EXPECT_DOUBLE_EQ(-2147483649.0, double_val);
135 }
136
137 {
138 // Parse a double
139 std::unique_ptr<Value> root = JSONReader().ReadToValue("43.1");
140 ASSERT_TRUE(root);
141 EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
142 double double_val = 0.0;
143 EXPECT_TRUE(root->GetAsDouble(&double_val));
144 EXPECT_DOUBLE_EQ(43.1, double_val);
145
146 root = JSONReader().ReadToValue("4.3e-1");
147 ASSERT_TRUE(root);
148 EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
149 double_val = 0.0;
150 EXPECT_TRUE(root->GetAsDouble(&double_val));
151 EXPECT_DOUBLE_EQ(.43, double_val);
152
153 root = JSONReader().ReadToValue("2.1e0");
154 ASSERT_TRUE(root);
155 EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
156 double_val = 0.0;
157 EXPECT_TRUE(root->GetAsDouble(&double_val));
158 EXPECT_DOUBLE_EQ(2.1, double_val);
159
160 root = JSONReader().ReadToValue("2.1e+0001");
161 ASSERT_TRUE(root);
162 EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
163 double_val = 0.0;
164 EXPECT_TRUE(root->GetAsDouble(&double_val));
165 EXPECT_DOUBLE_EQ(21.0, double_val);
166
167 root = JSONReader().ReadToValue("0.01");
168 ASSERT_TRUE(root);
169 EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
170 double_val = 0.0;
171 EXPECT_TRUE(root->GetAsDouble(&double_val));
172 EXPECT_DOUBLE_EQ(0.01, double_val);
173
174 root = JSONReader().ReadToValue("1.00");
175 ASSERT_TRUE(root);
176 EXPECT_TRUE(root->IsType(Value::Type::DOUBLE));
177 double_val = 0.0;
178 EXPECT_TRUE(root->GetAsDouble(&double_val));
179 EXPECT_DOUBLE_EQ(1.0, double_val);
180 }
181
182 {
183 // Fractional parts must have a digit before and after the decimal point.
184 EXPECT_FALSE(JSONReader().ReadToValue("1."));
185 EXPECT_FALSE(JSONReader().ReadToValue(".1"));
186 EXPECT_FALSE(JSONReader().ReadToValue("1.e10"));
187 }
188
189 {
190 // Exponent must have a digit following the 'e'.
191 EXPECT_FALSE(JSONReader().ReadToValue("1e"));
192 EXPECT_FALSE(JSONReader().ReadToValue("1E"));
193 EXPECT_FALSE(JSONReader().ReadToValue("1e1."));
194 EXPECT_FALSE(JSONReader().ReadToValue("1e1.0"));
195 }
196
197 {
198 // INF/-INF/NaN are not valid
199 EXPECT_FALSE(JSONReader().ReadToValue("1e1000"));
200 EXPECT_FALSE(JSONReader().ReadToValue("-1e1000"));
201 EXPECT_FALSE(JSONReader().ReadToValue("NaN"));
202 EXPECT_FALSE(JSONReader().ReadToValue("nan"));
203 EXPECT_FALSE(JSONReader().ReadToValue("inf"));
204 }
205
206 {
207 // Invalid number formats
208 EXPECT_FALSE(JSONReader().ReadToValue("4.3.1"));
209 EXPECT_FALSE(JSONReader().ReadToValue("4e3.1"));
210 }
211
212 {
213 // Test string parser
214 std::unique_ptr<Value> root = JSONReader().ReadToValue("\"hello world\"");
215 ASSERT_TRUE(root);
216 EXPECT_TRUE(root->IsType(Value::Type::STRING));
217 std::string str_val;
218 EXPECT_TRUE(root->GetAsString(&str_val));
219 EXPECT_EQ("hello world", str_val);
220 }
221
222 {
223 // Empty string
224 std::unique_ptr<Value> root = JSONReader().ReadToValue("\"\"");
225 ASSERT_TRUE(root);
226 EXPECT_TRUE(root->IsType(Value::Type::STRING));
227 std::string str_val;
228 EXPECT_TRUE(root->GetAsString(&str_val));
229 EXPECT_EQ("", str_val);
230 }
231
232 {
233 // Test basic string escapes
234 std::unique_ptr<Value> root =
235 JSONReader().ReadToValue("\" \\\"\\\\\\/\\b\\f\\n\\r\\t\\v\"");
236 ASSERT_TRUE(root);
237 EXPECT_TRUE(root->IsType(Value::Type::STRING));
238 std::string str_val;
239 EXPECT_TRUE(root->GetAsString(&str_val));
240 EXPECT_EQ(" \"\\/\b\f\n\r\t\v", str_val);
241 }
242
243 {
244 // Test hex and unicode escapes including the null character.
245 std::unique_ptr<Value> root =
246 JSONReader().ReadToValue("\"\\x41\\x00\\u1234\"");
247 ASSERT_TRUE(root);
248 EXPECT_TRUE(root->IsType(Value::Type::STRING));
249 std::string str_val;
250 EXPECT_TRUE(root->GetAsString(&str_val));
251 EXPECT_EQ(std::wstring(L"A\0\x1234", 3), UTF8ToWide(str_val));
252 }
253
254 {
255 // Test invalid strings
256 EXPECT_FALSE(JSONReader().ReadToValue("\"no closing quote"));
257 EXPECT_FALSE(JSONReader().ReadToValue("\"\\z invalid escape char\""));
258 EXPECT_FALSE(JSONReader().ReadToValue("\"\\xAQ invalid hex code\""));
259 EXPECT_FALSE(JSONReader().ReadToValue("not enough hex chars\\x1\""));
260 EXPECT_FALSE(JSONReader().ReadToValue("\"not enough escape chars\\u123\""));
261 EXPECT_FALSE(
262 JSONReader().ReadToValue("\"extra backslash at end of input\\\""));
263 }
264
265 {
266 // Basic array
267 std::unique_ptr<ListValue> list =
268 ListValue::From(JSONReader::Read("[true, false, null]"));
269 ASSERT_TRUE(list);
270 EXPECT_EQ(3U, list->GetSize());
271
272 // Test with trailing comma. Should be parsed the same as above.
273 std::unique_ptr<Value> root2 =
274 JSONReader::Read("[true, false, null, ]", JSON_ALLOW_TRAILING_COMMAS);
275 EXPECT_TRUE(list->Equals(root2.get()));
276 }
277
278 {
279 // Empty array
280 std::unique_ptr<ListValue> list = ListValue::From(JSONReader::Read("[]"));
281 ASSERT_TRUE(list);
282 EXPECT_EQ(0U, list->GetSize());
283 }
284
285 {
286 // Nested arrays
287 std::unique_ptr<ListValue> list = ListValue::From(
288 JSONReader::Read("[[true], [], [false, [], [null]], null]"));
289 ASSERT_TRUE(list);
290 EXPECT_EQ(4U, list->GetSize());
291
292 // Lots of trailing commas.
293 std::unique_ptr<Value> root2 =
294 JSONReader::Read("[[true], [], [false, [], [null, ] , ], null,]",
295 JSON_ALLOW_TRAILING_COMMAS);
296 EXPECT_TRUE(list->Equals(root2.get()));
297 }
298
299 {
300 // Invalid, missing close brace.
301 EXPECT_FALSE(JSONReader::Read("[[true], [], [false, [], [null]], null"));
302
303 // Invalid, too many commas
304 EXPECT_FALSE(JSONReader::Read("[true,, null]"));
305 EXPECT_FALSE(JSONReader::Read("[true,, null]", JSON_ALLOW_TRAILING_COMMAS));
306
307 // Invalid, no commas
308 EXPECT_FALSE(JSONReader::Read("[true null]"));
309
310 // Invalid, trailing comma
311 EXPECT_FALSE(JSONReader::Read("[true,]"));
312 }
313
314 {
315 // Valid if we set |allow_trailing_comma| to true.
316 std::unique_ptr<ListValue> list = ListValue::From(
317 JSONReader::Read("[true,]", JSON_ALLOW_TRAILING_COMMAS));
318 ASSERT_TRUE(list);
319 EXPECT_EQ(1U, list->GetSize());
320 Value* tmp_value = nullptr;
321 ASSERT_TRUE(list->Get(0, &tmp_value));
322 EXPECT_TRUE(tmp_value->IsType(Value::Type::BOOLEAN));
323 bool bool_value = false;
324 EXPECT_TRUE(tmp_value->GetAsBoolean(&bool_value));
325 EXPECT_TRUE(bool_value);
326 }
327
328 {
329 // Don't allow empty elements, even if |allow_trailing_comma| is
330 // true.
331 EXPECT_FALSE(JSONReader::Read("[,]", JSON_ALLOW_TRAILING_COMMAS));
332 EXPECT_FALSE(JSONReader::Read("[true,,]", JSON_ALLOW_TRAILING_COMMAS));
333 EXPECT_FALSE(JSONReader::Read("[,true,]", JSON_ALLOW_TRAILING_COMMAS));
334 EXPECT_FALSE(JSONReader::Read("[true,,false]", JSON_ALLOW_TRAILING_COMMAS));
335 }
336
337 {
338 // Test objects
339 std::unique_ptr<DictionaryValue> dict_val =
340 DictionaryValue::From(JSONReader::Read("{}"));
341 ASSERT_TRUE(dict_val);
342
343 dict_val = DictionaryValue::From(JSONReader::Read(
344 "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\" }"));
345 ASSERT_TRUE(dict_val);
346 double double_val = 0.0;
347 EXPECT_TRUE(dict_val->GetDouble("number", &double_val));
348 EXPECT_DOUBLE_EQ(9.87654321, double_val);
349 Value* null_val = nullptr;
350 ASSERT_TRUE(dict_val->Get("null", &null_val));
351 EXPECT_TRUE(null_val->IsType(Value::Type::NONE));
352 std::string str_val;
353 EXPECT_TRUE(dict_val->GetString("S", &str_val));
354 EXPECT_EQ("str", str_val);
355
356 std::unique_ptr<Value> root2 = JSONReader::Read(
357 "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", }",
358 JSON_ALLOW_TRAILING_COMMAS);
359 ASSERT_TRUE(root2);
360 EXPECT_TRUE(dict_val->Equals(root2.get()));
361
362 // Test newline equivalence.
363 root2 = JSONReader::Read(
364 "{\n"
365 " \"number\":9.87654321,\n"
366 " \"null\":null,\n"
367 " \"\\x53\":\"str\",\n"
368 "}\n",
369 JSON_ALLOW_TRAILING_COMMAS);
370 ASSERT_TRUE(root2);
371 EXPECT_TRUE(dict_val->Equals(root2.get()));
372
373 root2 = JSONReader::Read(
374 "{\r\n"
375 " \"number\":9.87654321,\r\n"
376 " \"null\":null,\r\n"
377 " \"\\x53\":\"str\",\r\n"
378 "}\r\n",
379 JSON_ALLOW_TRAILING_COMMAS);
380 ASSERT_TRUE(root2);
381 EXPECT_TRUE(dict_val->Equals(root2.get()));
382 }
383
384 {
385 // Test nesting
386 std::unique_ptr<DictionaryValue> dict_val =
387 DictionaryValue::From(JSONReader::Read(
388 "{\"inner\":{\"array\":[true]},\"false\":false,\"d\":{}}"));
389 ASSERT_TRUE(dict_val);
390 DictionaryValue* inner_dict = nullptr;
391 ASSERT_TRUE(dict_val->GetDictionary("inner", &inner_dict));
392 ListValue* inner_array = nullptr;
393 ASSERT_TRUE(inner_dict->GetList("array", &inner_array));
394 EXPECT_EQ(1U, inner_array->GetSize());
395 bool bool_value = true;
396 EXPECT_TRUE(dict_val->GetBoolean("false", &bool_value));
397 EXPECT_FALSE(bool_value);
398 inner_dict = nullptr;
399 EXPECT_TRUE(dict_val->GetDictionary("d", &inner_dict));
400
401 std::unique_ptr<Value> root2 = JSONReader::Read(
402 "{\"inner\": {\"array\":[true] , },\"false\":false,\"d\":{},}",
403 JSON_ALLOW_TRAILING_COMMAS);
404 EXPECT_TRUE(dict_val->Equals(root2.get()));
405 }
406
407 {
408 // Test keys with periods
409 std::unique_ptr<DictionaryValue> dict_val = DictionaryValue::From(
410 JSONReader::Read("{\"a.b\":3,\"c\":2,\"d.e.f\":{\"g.h.i.j\":1}}"));
411 ASSERT_TRUE(dict_val);
412 int integer_value = 0;
413 EXPECT_TRUE(
414 dict_val->GetIntegerWithoutPathExpansion("a.b", &integer_value));
415 EXPECT_EQ(3, integer_value);
416 EXPECT_TRUE(dict_val->GetIntegerWithoutPathExpansion("c", &integer_value));
417 EXPECT_EQ(2, integer_value);
418 DictionaryValue* inner_dict = nullptr;
419 ASSERT_TRUE(
420 dict_val->GetDictionaryWithoutPathExpansion("d.e.f", &inner_dict));
421 EXPECT_EQ(1U, inner_dict->size());
422 EXPECT_TRUE(
423 inner_dict->GetIntegerWithoutPathExpansion("g.h.i.j", &integer_value));
424 EXPECT_EQ(1, integer_value);
425
426 dict_val =
427 DictionaryValue::From(JSONReader::Read("{\"a\":{\"b\":2},\"a.b\":1}"));
428 ASSERT_TRUE(dict_val);
429 EXPECT_TRUE(dict_val->GetInteger("a.b", &integer_value));
430 EXPECT_EQ(2, integer_value);
431 EXPECT_TRUE(
432 dict_val->GetIntegerWithoutPathExpansion("a.b", &integer_value));
433 EXPECT_EQ(1, integer_value);
434 }
435
436 {
437 // Invalid, no closing brace
438 EXPECT_FALSE(JSONReader::Read("{\"a\": true"));
439
440 // Invalid, keys must be quoted
441 EXPECT_FALSE(JSONReader::Read("{foo:true}"));
442
443 // Invalid, trailing comma
444 EXPECT_FALSE(JSONReader::Read("{\"a\":true,}"));
445
446 // Invalid, too many commas
447 EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}"));
448 EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}",
449 JSON_ALLOW_TRAILING_COMMAS));
450
451 // Invalid, no separator
452 EXPECT_FALSE(JSONReader::Read("{\"a\" \"b\"}"));
453
454 // Invalid, lone comma.
455 EXPECT_FALSE(JSONReader::Read("{,}"));
456 EXPECT_FALSE(JSONReader::Read("{,}", JSON_ALLOW_TRAILING_COMMAS));
457 EXPECT_FALSE(
458 JSONReader::Read("{\"a\":true,,}", JSON_ALLOW_TRAILING_COMMAS));
459 EXPECT_FALSE(JSONReader::Read("{,\"a\":true}", JSON_ALLOW_TRAILING_COMMAS));
460 EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}",
461 JSON_ALLOW_TRAILING_COMMAS));
462 }
463
464 {
465 // Test stack overflow
466 std::string evil(1000000, '[');
467 evil.append(std::string(1000000, ']'));
468 EXPECT_FALSE(JSONReader::Read(evil));
469 }
470
471 {
472 // A few thousand adjacent lists is fine.
473 std::string not_evil("[");
474 not_evil.reserve(15010);
475 for (int i = 0; i < 5000; ++i)
476 not_evil.append("[],");
477 not_evil.append("[]]");
478 std::unique_ptr<ListValue> list =
479 ListValue::From(JSONReader::Read(not_evil));
480 ASSERT_TRUE(list);
481 EXPECT_EQ(5001U, list->GetSize());
482 }
483
484 {
485 // Test utf8 encoded input
486 std::unique_ptr<Value> root =
487 JSONReader().ReadToValue("\"\xe7\xbd\x91\xe9\xa1\xb5\"");
488 ASSERT_TRUE(root);
489 EXPECT_TRUE(root->IsType(Value::Type::STRING));
490 std::string str_val;
491 EXPECT_TRUE(root->GetAsString(&str_val));
492 EXPECT_EQ(L"\x7f51\x9875", UTF8ToWide(str_val));
493
494 std::unique_ptr<DictionaryValue> dict_val =
495 DictionaryValue::From(JSONReader().ReadToValue(
496 "{\"path\": \"/tmp/\xc3\xa0\xc3\xa8\xc3\xb2.png\"}"));
497 ASSERT_TRUE(dict_val);
498 EXPECT_TRUE(dict_val->GetString("path", &str_val));
499 EXPECT_EQ("/tmp/\xC3\xA0\xC3\xA8\xC3\xB2.png", str_val);
500 }
501
502 {
503 // Test invalid utf8 encoded input
504 EXPECT_FALSE(JSONReader().ReadToValue("\"345\xb0\xa1\xb0\xa2\""));
505 EXPECT_FALSE(JSONReader().ReadToValue("\"123\xc0\x81\""));
506 EXPECT_FALSE(JSONReader().ReadToValue("\"abc\xc0\xae\""));
507 }
508
509 {
510 // Test utf16 encoded strings.
511 std::unique_ptr<Value> root = JSONReader().ReadToValue("\"\\u20ac3,14\"");
512 ASSERT_TRUE(root);
513 EXPECT_TRUE(root->IsType(Value::Type::STRING));
514 std::string str_val;
515 EXPECT_TRUE(root->GetAsString(&str_val));
516 EXPECT_EQ(
517 "\xe2\x82\xac"
518 "3,14",
519 str_val);
520
521 root = JSONReader().ReadToValue("\"\\ud83d\\udca9\\ud83d\\udc6c\"");
522 ASSERT_TRUE(root);
523 EXPECT_TRUE(root->IsType(Value::Type::STRING));
524 str_val.clear();
525 EXPECT_TRUE(root->GetAsString(&str_val));
526 EXPECT_EQ("\xf0\x9f\x92\xa9\xf0\x9f\x91\xac", str_val);
527 }
528
529 {
530 // Test invalid utf16 strings.
531 const char* const cases[] = {
532 "\"\\u123\"", // Invalid scalar.
533 "\"\\ud83d\"", // Invalid scalar.
534 "\"\\u$%@!\"", // Invalid scalar.
535 "\"\\uzz89\"", // Invalid scalar.
536 "\"\\ud83d\\udca\"", // Invalid lower surrogate.
537 "\"\\ud83d\\ud83d\"", // Invalid lower surrogate.
538 "\"\\ud83foo\"", // No lower surrogate.
539 "\"\\ud83\\foo\"" // No lower surrogate.
540 };
541 std::unique_ptr<Value> root;
542 for (size_t i = 0; i < arraysize(cases); ++i) {
543 root = JSONReader().ReadToValue(cases[i]);
544 EXPECT_FALSE(root) << cases[i];
545 }
546 }
547
548 {
549 // Test literal root objects.
550 std::unique_ptr<Value> root = JSONReader::Read("null");
551 EXPECT_TRUE(root->IsType(Value::Type::NONE));
552
553 root = JSONReader::Read("true");
554 ASSERT_TRUE(root);
555 bool bool_value;
556 EXPECT_TRUE(root->GetAsBoolean(&bool_value));
557 EXPECT_TRUE(bool_value);
558
559 root = JSONReader::Read("10");
560 ASSERT_TRUE(root);
561 int integer_value;
562 EXPECT_TRUE(root->GetAsInteger(&integer_value));
563 EXPECT_EQ(10, integer_value);
564
565 root = JSONReader::Read("\"root\"");
566 ASSERT_TRUE(root);
567 std::string str_val;
568 EXPECT_TRUE(root->GetAsString(&str_val));
569 EXPECT_EQ("root", str_val);
570 }
571 }
572
573 #if !defined(__ANDROID__) && !defined(__ANDROID_HOST__)
TEST(JSONReaderTest,ReadFromFile)574 TEST(JSONReaderTest, ReadFromFile) {
575 FilePath path;
576 ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &path));
577 path = path.AppendASCII("json");
578 ASSERT_TRUE(base::PathExists(path));
579
580 std::string input;
581 ASSERT_TRUE(ReadFileToString(path.AppendASCII("bom_feff.json"), &input));
582
583 JSONReader reader;
584 std::unique_ptr<Value> root(reader.ReadToValue(input));
585 ASSERT_TRUE(root) << reader.GetErrorMessage();
586 EXPECT_TRUE(root->IsType(Value::Type::DICTIONARY));
587 }
588 #endif // !__ANDROID__ && !__ANDROID_HOST__
589
590 // Tests that the root of a JSON object can be deleted safely while its
591 // children outlive it.
TEST(JSONReaderTest,StringOptimizations)592 TEST(JSONReaderTest, StringOptimizations) {
593 std::unique_ptr<Value> dict_literal_0;
594 std::unique_ptr<Value> dict_literal_1;
595 std::unique_ptr<Value> dict_string_0;
596 std::unique_ptr<Value> dict_string_1;
597 std::unique_ptr<Value> list_value_0;
598 std::unique_ptr<Value> list_value_1;
599
600 {
601 std::unique_ptr<Value> root = JSONReader::Read(
602 "{"
603 " \"test\": {"
604 " \"foo\": true,"
605 " \"bar\": 3.14,"
606 " \"baz\": \"bat\","
607 " \"moo\": \"cow\""
608 " },"
609 " \"list\": ["
610 " \"a\","
611 " \"b\""
612 " ]"
613 "}",
614 JSON_DETACHABLE_CHILDREN);
615 ASSERT_TRUE(root);
616
617 DictionaryValue* root_dict = nullptr;
618 ASSERT_TRUE(root->GetAsDictionary(&root_dict));
619
620 DictionaryValue* dict = nullptr;
621 ListValue* list = nullptr;
622
623 ASSERT_TRUE(root_dict->GetDictionary("test", &dict));
624 ASSERT_TRUE(root_dict->GetList("list", &list));
625
626 ASSERT_TRUE(dict->Remove("foo", &dict_literal_0));
627 ASSERT_TRUE(dict->Remove("bar", &dict_literal_1));
628 ASSERT_TRUE(dict->Remove("baz", &dict_string_0));
629 ASSERT_TRUE(dict->Remove("moo", &dict_string_1));
630
631 ASSERT_EQ(2u, list->GetSize());
632 ASSERT_TRUE(list->Remove(0, &list_value_0));
633 ASSERT_TRUE(list->Remove(0, &list_value_1));
634 }
635
636 bool b = false;
637 double d = 0;
638 std::string s;
639
640 EXPECT_TRUE(dict_literal_0->GetAsBoolean(&b));
641 EXPECT_TRUE(b);
642
643 EXPECT_TRUE(dict_literal_1->GetAsDouble(&d));
644 EXPECT_EQ(3.14, d);
645
646 EXPECT_TRUE(dict_string_0->GetAsString(&s));
647 EXPECT_EQ("bat", s);
648
649 EXPECT_TRUE(dict_string_1->GetAsString(&s));
650 EXPECT_EQ("cow", s);
651
652 EXPECT_TRUE(list_value_0->GetAsString(&s));
653 EXPECT_EQ("a", s);
654 EXPECT_TRUE(list_value_1->GetAsString(&s));
655 EXPECT_EQ("b", s);
656 }
657
658 // A smattering of invalid JSON designed to test specific portions of the
659 // parser implementation against buffer overflow. Best run with DCHECKs so
660 // that the one in NextChar fires.
TEST(JSONReaderTest,InvalidSanity)661 TEST(JSONReaderTest, InvalidSanity) {
662 const char* const kInvalidJson[] = {
663 "/* test *", "{\"foo\"", "{\"foo\":", " [", "\"\\u123g\"", "{\n\"eh:\n}",
664 };
665
666 for (size_t i = 0; i < arraysize(kInvalidJson); ++i) {
667 JSONReader reader;
668 LOG(INFO) << "Sanity test " << i << ": <" << kInvalidJson[i] << ">";
669 EXPECT_FALSE(reader.ReadToValue(kInvalidJson[i]));
670 EXPECT_NE(JSONReader::JSON_NO_ERROR, reader.error_code());
671 EXPECT_NE("", reader.GetErrorMessage());
672 }
673 }
674
TEST(JSONReaderTest,IllegalTrailingNull)675 TEST(JSONReaderTest, IllegalTrailingNull) {
676 const char json[] = { '"', 'n', 'u', 'l', 'l', '"', '\0' };
677 std::string json_string(json, sizeof(json));
678 JSONReader reader;
679 EXPECT_FALSE(reader.ReadToValue(json_string));
680 EXPECT_EQ(JSONReader::JSON_UNEXPECTED_DATA_AFTER_ROOT, reader.error_code());
681 }
682
683 } // namespace base
684