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 "base/base_paths.h" 8 #include "base/files/file_util.h" 9 #include "base/logging.h" 10 #include "base/memory/scoped_ptr.h" 11 #include "base/path_service.h" 12 #include "base/strings/string_piece.h" 13 #include "base/strings/utf_string_conversions.h" 14 #include "base/values.h" 15 #include "build/build_config.h" 16 #include "testing/gtest/include/gtest/gtest.h" 17 18 namespace base { 19 20 TEST(JSONReaderTest, Reading) { 21 // some whitespace checking 22 scoped_ptr<Value> root; 23 root.reset(JSONReader().ReadToValue(" null ")); 24 ASSERT_TRUE(root.get()); 25 EXPECT_TRUE(root->IsType(Value::TYPE_NULL)); 26 27 // Invalid JSON string 28 root.reset(JSONReader().ReadToValue("nu")); 29 EXPECT_FALSE(root.get()); 30 31 // Simple bool 32 root.reset(JSONReader().ReadToValue("true ")); 33 ASSERT_TRUE(root.get()); 34 EXPECT_TRUE(root->IsType(Value::TYPE_BOOLEAN)); 35 36 // Embedded comment 37 root.reset(JSONReader().ReadToValue("/* comment */null")); 38 ASSERT_TRUE(root.get()); 39 EXPECT_TRUE(root->IsType(Value::TYPE_NULL)); 40 root.reset(JSONReader().ReadToValue("40 /* comment */")); 41 ASSERT_TRUE(root.get()); 42 EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER)); 43 root.reset(JSONReader().ReadToValue("true // comment")); 44 ASSERT_TRUE(root.get()); 45 EXPECT_TRUE(root->IsType(Value::TYPE_BOOLEAN)); 46 root.reset(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.reset(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.reset(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.reset(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.reset(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.reset(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.reset(JSONReader().ReadToValue("043")); 88 EXPECT_FALSE(root.get()); 89 root.reset(JSONReader().ReadToValue("0x43")); 90 EXPECT_FALSE(root.get()); 91 root.reset(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.reset(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.reset(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.reset(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.reset(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.reset(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.reset(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.reset(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.reset(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.reset(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.reset(JSONReader().ReadToValue("1.")); 164 EXPECT_FALSE(root.get()); 165 root.reset(JSONReader().ReadToValue(".1")); 166 EXPECT_FALSE(root.get()); 167 root.reset(JSONReader().ReadToValue("1.e10")); 168 EXPECT_FALSE(root.get()); 169 170 // Exponent must have a digit following the 'e'. 171 root.reset(JSONReader().ReadToValue("1e")); 172 EXPECT_FALSE(root.get()); 173 root.reset(JSONReader().ReadToValue("1E")); 174 EXPECT_FALSE(root.get()); 175 root.reset(JSONReader().ReadToValue("1e1.")); 176 EXPECT_FALSE(root.get()); 177 root.reset(JSONReader().ReadToValue("1e1.0")); 178 EXPECT_FALSE(root.get()); 179 180 // INF/-INF/NaN are not valid 181 root.reset(JSONReader().ReadToValue("1e1000")); 182 EXPECT_FALSE(root.get()); 183 root.reset(JSONReader().ReadToValue("-1e1000")); 184 EXPECT_FALSE(root.get()); 185 root.reset(JSONReader().ReadToValue("NaN")); 186 EXPECT_FALSE(root.get()); 187 root.reset(JSONReader().ReadToValue("nan")); 188 EXPECT_FALSE(root.get()); 189 root.reset(JSONReader().ReadToValue("inf")); 190 EXPECT_FALSE(root.get()); 191 192 // Invalid number formats 193 root.reset(JSONReader().ReadToValue("4.3.1")); 194 EXPECT_FALSE(root.get()); 195 root.reset(JSONReader().ReadToValue("4e3.1")); 196 EXPECT_FALSE(root.get()); 197 198 // Test string parser 199 root.reset(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.reset(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.reset(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.reset(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::wstring(L"A\0\x1234", 3), UTF8ToWide(str_val)); 229 230 // Test invalid strings 231 root.reset(JSONReader().ReadToValue("\"no closing quote")); 232 EXPECT_FALSE(root.get()); 233 root.reset(JSONReader().ReadToValue("\"\\z invalid escape char\"")); 234 EXPECT_FALSE(root.get()); 235 root.reset(JSONReader().ReadToValue("\"\\xAQ invalid hex code\"")); 236 EXPECT_FALSE(root.get()); 237 root.reset(JSONReader().ReadToValue("not enough hex chars\\x1\"")); 238 EXPECT_FALSE(root.get()); 239 root.reset(JSONReader().ReadToValue("\"not enough escape chars\\u123\"")); 240 EXPECT_FALSE(root.get()); 241 root.reset(JSONReader().ReadToValue("\"extra backslash at end of input\\\"")); 242 EXPECT_FALSE(root.get()); 243 244 // Basic array 245 root.reset(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 root2.reset(JSONReader::Read("[true, false, null, ]", 254 JSON_ALLOW_TRAILING_COMMAS)); 255 EXPECT_TRUE(root->Equals(root2.get())); 256 257 // Empty array 258 root.reset(JSONReader::Read("[]")); 259 ASSERT_TRUE(root.get()); 260 EXPECT_TRUE(root->IsType(Value::TYPE_LIST)); 261 list = static_cast<ListValue*>(root.get()); 262 EXPECT_EQ(0U, list->GetSize()); 263 264 // Nested arrays 265 root.reset(JSONReader::Read("[[true], [], [false, [], [null]], null]")); 266 ASSERT_TRUE(root.get()); 267 EXPECT_TRUE(root->IsType(Value::TYPE_LIST)); 268 list = static_cast<ListValue*>(root.get()); 269 EXPECT_EQ(4U, list->GetSize()); 270 271 // Lots of trailing commas. 272 root2.reset(JSONReader::Read("[[true], [], [false, [], [null, ] , ], null,]", 273 JSON_ALLOW_TRAILING_COMMAS)); 274 EXPECT_TRUE(root->Equals(root2.get())); 275 276 // Invalid, missing close brace. 277 root.reset(JSONReader::Read("[[true], [], [false, [], [null]], null")); 278 EXPECT_FALSE(root.get()); 279 280 // Invalid, too many commas 281 root.reset(JSONReader::Read("[true,, null]")); 282 EXPECT_FALSE(root.get()); 283 root.reset(JSONReader::Read("[true,, null]", JSON_ALLOW_TRAILING_COMMAS)); 284 EXPECT_FALSE(root.get()); 285 286 // Invalid, no commas 287 root.reset(JSONReader::Read("[true null]")); 288 EXPECT_FALSE(root.get()); 289 290 // Invalid, trailing comma 291 root.reset(JSONReader::Read("[true,]")); 292 EXPECT_FALSE(root.get()); 293 294 // Valid if we set |allow_trailing_comma| to true. 295 root.reset(JSONReader::Read("[true,]", JSON_ALLOW_TRAILING_COMMAS)); 296 ASSERT_TRUE(root.get()); 297 EXPECT_TRUE(root->IsType(Value::TYPE_LIST)); 298 list = static_cast<ListValue*>(root.get()); 299 EXPECT_EQ(1U, list->GetSize()); 300 Value* tmp_value = NULL; 301 ASSERT_TRUE(list->Get(0, &tmp_value)); 302 EXPECT_TRUE(tmp_value->IsType(Value::TYPE_BOOLEAN)); 303 bool bool_value = false; 304 EXPECT_TRUE(tmp_value->GetAsBoolean(&bool_value)); 305 EXPECT_TRUE(bool_value); 306 307 // Don't allow empty elements, even if |allow_trailing_comma| is 308 // true. 309 root.reset(JSONReader::Read("[,]", JSON_ALLOW_TRAILING_COMMAS)); 310 EXPECT_FALSE(root.get()); 311 root.reset(JSONReader::Read("[true,,]", JSON_ALLOW_TRAILING_COMMAS)); 312 EXPECT_FALSE(root.get()); 313 root.reset(JSONReader::Read("[,true,]", JSON_ALLOW_TRAILING_COMMAS)); 314 EXPECT_FALSE(root.get()); 315 root.reset(JSONReader::Read("[true,,false]", JSON_ALLOW_TRAILING_COMMAS)); 316 EXPECT_FALSE(root.get()); 317 318 // Test objects 319 root.reset(JSONReader::Read("{}")); 320 ASSERT_TRUE(root.get()); 321 EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); 322 323 root.reset(JSONReader::Read( 324 "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\" }")); 325 ASSERT_TRUE(root.get()); 326 EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); 327 DictionaryValue* dict_val = static_cast<DictionaryValue*>(root.get()); 328 double_val = 0.0; 329 EXPECT_TRUE(dict_val->GetDouble("number", &double_val)); 330 EXPECT_DOUBLE_EQ(9.87654321, double_val); 331 Value* null_val = NULL; 332 ASSERT_TRUE(dict_val->Get("null", &null_val)); 333 EXPECT_TRUE(null_val->IsType(Value::TYPE_NULL)); 334 str_val.clear(); 335 EXPECT_TRUE(dict_val->GetString("S", &str_val)); 336 EXPECT_EQ("str", str_val); 337 338 root2.reset(JSONReader::Read( 339 "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", }", 340 JSON_ALLOW_TRAILING_COMMAS)); 341 ASSERT_TRUE(root2.get()); 342 EXPECT_TRUE(root->Equals(root2.get())); 343 344 // Test newline equivalence. 345 root2.reset(JSONReader::Read( 346 "{\n" 347 " \"number\":9.87654321,\n" 348 " \"null\":null,\n" 349 " \"\\x53\":\"str\",\n" 350 "}\n", JSON_ALLOW_TRAILING_COMMAS)); 351 ASSERT_TRUE(root2.get()); 352 EXPECT_TRUE(root->Equals(root2.get())); 353 354 root2.reset(JSONReader::Read( 355 "{\r\n" 356 " \"number\":9.87654321,\r\n" 357 " \"null\":null,\r\n" 358 " \"\\x53\":\"str\",\r\n" 359 "}\r\n", JSON_ALLOW_TRAILING_COMMAS)); 360 ASSERT_TRUE(root2.get()); 361 EXPECT_TRUE(root->Equals(root2.get())); 362 363 // Test nesting 364 root.reset(JSONReader::Read( 365 "{\"inner\":{\"array\":[true]},\"false\":false,\"d\":{}}")); 366 ASSERT_TRUE(root.get()); 367 EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); 368 dict_val = static_cast<DictionaryValue*>(root.get()); 369 DictionaryValue* inner_dict = NULL; 370 ASSERT_TRUE(dict_val->GetDictionary("inner", &inner_dict)); 371 ListValue* inner_array = NULL; 372 ASSERT_TRUE(inner_dict->GetList("array", &inner_array)); 373 EXPECT_EQ(1U, inner_array->GetSize()); 374 bool_value = true; 375 EXPECT_TRUE(dict_val->GetBoolean("false", &bool_value)); 376 EXPECT_FALSE(bool_value); 377 inner_dict = NULL; 378 EXPECT_TRUE(dict_val->GetDictionary("d", &inner_dict)); 379 380 root2.reset(JSONReader::Read( 381 "{\"inner\": {\"array\":[true] , },\"false\":false,\"d\":{},}", 382 JSON_ALLOW_TRAILING_COMMAS)); 383 EXPECT_TRUE(root->Equals(root2.get())); 384 385 // Test keys with periods 386 root.reset(JSONReader::Read( 387 "{\"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.reset(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.reset(JSONReader::Read("{\"a\": true")); 415 EXPECT_FALSE(root.get()); 416 417 // Invalid, keys must be quoted 418 root.reset(JSONReader::Read("{foo:true}")); 419 EXPECT_FALSE(root.get()); 420 421 // Invalid, trailing comma 422 root.reset(JSONReader::Read("{\"a\":true,}")); 423 EXPECT_FALSE(root.get()); 424 425 // Invalid, too many commas 426 root.reset(JSONReader::Read("{\"a\":true,,\"b\":false}")); 427 EXPECT_FALSE(root.get()); 428 root.reset(JSONReader::Read("{\"a\":true,,\"b\":false}", 429 JSON_ALLOW_TRAILING_COMMAS)); 430 EXPECT_FALSE(root.get()); 431 432 // Invalid, no separator 433 root.reset(JSONReader::Read("{\"a\" \"b\"}")); 434 EXPECT_FALSE(root.get()); 435 436 // Invalid, lone comma. 437 root.reset(JSONReader::Read("{,}")); 438 EXPECT_FALSE(root.get()); 439 root.reset(JSONReader::Read("{,}", JSON_ALLOW_TRAILING_COMMAS)); 440 EXPECT_FALSE(root.get()); 441 root.reset(JSONReader::Read("{\"a\":true,,}", JSON_ALLOW_TRAILING_COMMAS)); 442 EXPECT_FALSE(root.get()); 443 root.reset(JSONReader::Read("{,\"a\":true}", JSON_ALLOW_TRAILING_COMMAS)); 444 EXPECT_FALSE(root.get()); 445 root.reset(JSONReader::Read("{\"a\":true,,\"b\":false}", 446 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.reset(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.reset(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.reset(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(L"\x7f51\x9875", UTF8ToWide(str_val)); 475 476 root.reset(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.reset(JSONReader().ReadToValue("\"345\xb0\xa1\xb0\xa2\"")); 486 EXPECT_FALSE(root.get()); 487 root.reset(JSONReader().ReadToValue("\"123\xc0\x81\"")); 488 EXPECT_FALSE(root.get()); 489 root.reset(JSONReader().ReadToValue("\"abc\xc0\xae\"")); 490 EXPECT_FALSE(root.get()); 491 492 // Test utf16 encoded strings. 493 root.reset(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.reset(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* 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.reset(JSONReader().ReadToValue(cases[i])); 520 EXPECT_FALSE(root.get()) << cases[i]; 521 } 522 523 // Test literal root objects. 524 root.reset(JSONReader::Read("null")); 525 EXPECT_TRUE(root->IsType(Value::TYPE_NULL)); 526 527 root.reset(JSONReader::Read("true")); 528 ASSERT_TRUE(root.get()); 529 EXPECT_TRUE(root->GetAsBoolean(&bool_value)); 530 EXPECT_TRUE(bool_value); 531 532 root.reset(JSONReader::Read("10")); 533 ASSERT_TRUE(root.get()); 534 EXPECT_TRUE(root->GetAsInteger(&integer_value)); 535 EXPECT_EQ(10, integer_value); 536 537 root.reset(JSONReader::Read("\"root\"")); 538 ASSERT_TRUE(root.get()); 539 EXPECT_TRUE(root->GetAsString(&str_val)); 540 EXPECT_EQ("root", str_val); 541 } 542 543 TEST(JSONReaderTest, ReadFromFile) { 544 FilePath path; 545 ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &path)); 546 path = path.AppendASCII("json"); 547 ASSERT_TRUE(base::PathExists(path)); 548 549 std::string input; 550 ASSERT_TRUE(ReadFileToString( 551 path.Append(FILE_PATH_LITERAL("bom_feff.json")), &input)); 552 553 JSONReader reader; 554 scoped_ptr<Value> root(reader.ReadToValue(input)); 555 ASSERT_TRUE(root.get()) << reader.GetErrorMessage(); 556 EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); 557 } 558 559 // Tests that the root of a JSON object can be deleted safely while its 560 // children outlive it. 561 TEST(JSONReaderTest, StringOptimizations) { 562 scoped_ptr<Value> dict_literal_0; 563 scoped_ptr<Value> dict_literal_1; 564 scoped_ptr<Value> dict_string_0; 565 scoped_ptr<Value> dict_string_1; 566 scoped_ptr<Value> list_value_0; 567 scoped_ptr<Value> list_value_1; 568 569 { 570 scoped_ptr<Value> root(JSONReader::Read( 571 "{" 572 " \"test\": {" 573 " \"foo\": true," 574 " \"bar\": 3.14," 575 " \"baz\": \"bat\"," 576 " \"moo\": \"cow\"" 577 " }," 578 " \"list\": [" 579 " \"a\"," 580 " \"b\"" 581 " ]" 582 "}", JSON_DETACHABLE_CHILDREN)); 583 ASSERT_TRUE(root.get()); 584 585 DictionaryValue* root_dict = NULL; 586 ASSERT_TRUE(root->GetAsDictionary(&root_dict)); 587 588 DictionaryValue* dict = NULL; 589 ListValue* list = NULL; 590 591 ASSERT_TRUE(root_dict->GetDictionary("test", &dict)); 592 ASSERT_TRUE(root_dict->GetList("list", &list)); 593 594 EXPECT_TRUE(dict->Remove("foo", &dict_literal_0)); 595 EXPECT_TRUE(dict->Remove("bar", &dict_literal_1)); 596 EXPECT_TRUE(dict->Remove("baz", &dict_string_0)); 597 EXPECT_TRUE(dict->Remove("moo", &dict_string_1)); 598 599 ASSERT_EQ(2u, list->GetSize()); 600 EXPECT_TRUE(list->Remove(0, &list_value_0)); 601 EXPECT_TRUE(list->Remove(0, &list_value_1)); 602 } 603 604 bool b = false; 605 double d = 0; 606 std::string s; 607 608 EXPECT_TRUE(dict_literal_0->GetAsBoolean(&b)); 609 EXPECT_TRUE(b); 610 611 EXPECT_TRUE(dict_literal_1->GetAsDouble(&d)); 612 EXPECT_EQ(3.14, d); 613 614 EXPECT_TRUE(dict_string_0->GetAsString(&s)); 615 EXPECT_EQ("bat", s); 616 617 EXPECT_TRUE(dict_string_1->GetAsString(&s)); 618 EXPECT_EQ("cow", s); 619 620 EXPECT_TRUE(list_value_0->GetAsString(&s)); 621 EXPECT_EQ("a", s); 622 EXPECT_TRUE(list_value_1->GetAsString(&s)); 623 EXPECT_EQ("b", s); 624 } 625 626 // A smattering of invalid JSON designed to test specific portions of the 627 // parser implementation against buffer overflow. Best run with DCHECKs so 628 // that the one in NextChar fires. 629 TEST(JSONReaderTest, InvalidSanity) { 630 const char* invalid_json[] = { 631 "/* test *", 632 "{\"foo\"", 633 "{\"foo\":", 634 " [", 635 "\"\\u123g\"", 636 "{\n\"eh:\n}", 637 }; 638 639 for (size_t i = 0; i < arraysize(invalid_json); ++i) { 640 JSONReader reader; 641 LOG(INFO) << "Sanity test " << i << ": <" << invalid_json[i] << ">"; 642 EXPECT_FALSE(reader.ReadToValue(invalid_json[i])); 643 EXPECT_NE(JSONReader::JSON_NO_ERROR, reader.error_code()); 644 EXPECT_NE("", reader.GetErrorMessage()); 645 } 646 } 647 648 TEST(JSONReaderTest, IllegalTrailingNull) { 649 const char json[] = { '"', 'n', 'u', 'l', 'l', '"', '\0' }; 650 std::string json_string(json, sizeof(json)); 651 JSONReader reader; 652 EXPECT_FALSE(reader.ReadToValue(json_string)); 653 EXPECT_EQ(JSONReader::JSON_UNEXPECTED_DATA_AFTER_ROOT, reader.error_code()); 654 } 655 656 } // namespace base 657
