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 19namespace base { 20 21TEST(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. 545TEST(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. 614TEST(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 633TEST(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