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