| OLD | NEW |
|---|
| (Empty) |
| 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 = 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::wstring(L"A\0\x1234", 3), UTF8ToWide(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.reset(JSONReader::DeprecatedRead("[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::DeprecatedRead("[true, false, null, ]", | |
| 254 JSON_ALLOW_TRAILING_COMMAS)); | |
| 255 EXPECT_TRUE(root->Equals(root2.get())); | |
| 256 | |
| 257 // Empty array | |
| 258 root.reset(JSONReader::DeprecatedRead("[]")); | |
| 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( | |
| 266 JSONReader::DeprecatedRead("[[true], [], [false, [], [null]], null]")); | |
| 267 ASSERT_TRUE(root.get()); | |
| 268 EXPECT_TRUE(root->IsType(Value::TYPE_LIST)); | |
| 269 list = static_cast<ListValue*>(root.get()); | |
| 270 EXPECT_EQ(4U, list->GetSize()); | |
| 271 | |
| 272 // Lots of trailing commas. | |
| 273 root2.reset(JSONReader::DeprecatedRead( | |
| 274 "[[true], [], [false, [], [null, ] , ], null,]", | |
| 275 JSON_ALLOW_TRAILING_COMMAS)); | |
| 276 EXPECT_TRUE(root->Equals(root2.get())); | |
| 277 | |
| 278 // Invalid, missing close brace. | |
| 279 root.reset( | |
| 280 JSONReader::DeprecatedRead("[[true], [], [false, [], [null]], null")); | |
| 281 EXPECT_FALSE(root.get()); | |
| 282 | |
| 283 // Invalid, too many commas | |
| 284 root.reset(JSONReader::DeprecatedRead("[true,, null]")); | |
| 285 EXPECT_FALSE(root.get()); | |
| 286 root.reset( | |
| 287 JSONReader::DeprecatedRead("[true,, null]", JSON_ALLOW_TRAILING_COMMAS)); | |
| 288 EXPECT_FALSE(root.get()); | |
| 289 | |
| 290 // Invalid, no commas | |
| 291 root.reset(JSONReader::DeprecatedRead("[true null]")); | |
| 292 EXPECT_FALSE(root.get()); | |
| 293 | |
| 294 // Invalid, trailing comma | |
| 295 root.reset(JSONReader::DeprecatedRead("[true,]")); | |
| 296 EXPECT_FALSE(root.get()); | |
| 297 | |
| 298 // Valid if we set |allow_trailing_comma| to true. | |
| 299 root.reset(JSONReader::DeprecatedRead("[true,]", JSON_ALLOW_TRAILING_COMMAS)); | |
| 300 ASSERT_TRUE(root.get()); | |
| 301 EXPECT_TRUE(root->IsType(Value::TYPE_LIST)); | |
| 302 list = static_cast<ListValue*>(root.get()); | |
| 303 EXPECT_EQ(1U, list->GetSize()); | |
| 304 Value* tmp_value = NULL; | |
| 305 ASSERT_TRUE(list->Get(0, &tmp_value)); | |
| 306 EXPECT_TRUE(tmp_value->IsType(Value::TYPE_BOOLEAN)); | |
| 307 bool bool_value = false; | |
| 308 EXPECT_TRUE(tmp_value->GetAsBoolean(&bool_value)); | |
| 309 EXPECT_TRUE(bool_value); | |
| 310 | |
| 311 // Don't allow empty elements, even if |allow_trailing_comma| is | |
| 312 // true. | |
| 313 root.reset(JSONReader::DeprecatedRead("[,]", JSON_ALLOW_TRAILING_COMMAS)); | |
| 314 EXPECT_FALSE(root.get()); | |
| 315 root.reset( | |
| 316 JSONReader::DeprecatedRead("[true,,]", JSON_ALLOW_TRAILING_COMMAS)); | |
| 317 EXPECT_FALSE(root.get()); | |
| 318 root.reset( | |
| 319 JSONReader::DeprecatedRead("[,true,]", JSON_ALLOW_TRAILING_COMMAS)); | |
| 320 EXPECT_FALSE(root.get()); | |
| 321 root.reset( | |
| 322 JSONReader::DeprecatedRead("[true,,false]", JSON_ALLOW_TRAILING_COMMAS)); | |
| 323 EXPECT_FALSE(root.get()); | |
| 324 | |
| 325 // Test objects | |
| 326 root.reset(JSONReader::DeprecatedRead("{}")); | |
| 327 ASSERT_TRUE(root.get()); | |
| 328 EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); | |
| 329 | |
| 330 root.reset(JSONReader::DeprecatedRead( | |
| 331 "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\" }")); | |
| 332 ASSERT_TRUE(root.get()); | |
| 333 EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); | |
| 334 DictionaryValue* dict_val = static_cast<DictionaryValue*>(root.get()); | |
| 335 double_val = 0.0; | |
| 336 EXPECT_TRUE(dict_val->GetDouble("number", &double_val)); | |
| 337 EXPECT_DOUBLE_EQ(9.87654321, double_val); | |
| 338 Value* null_val = NULL; | |
| 339 ASSERT_TRUE(dict_val->Get("null", &null_val)); | |
| 340 EXPECT_TRUE(null_val->IsType(Value::TYPE_NULL)); | |
| 341 str_val.clear(); | |
| 342 EXPECT_TRUE(dict_val->GetString("S", &str_val)); | |
| 343 EXPECT_EQ("str", str_val); | |
| 344 | |
| 345 root2.reset(JSONReader::DeprecatedRead( | |
| 346 "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", }", | |
| 347 JSON_ALLOW_TRAILING_COMMAS)); | |
| 348 ASSERT_TRUE(root2.get()); | |
| 349 EXPECT_TRUE(root->Equals(root2.get())); | |
| 350 | |
| 351 // Test newline equivalence. | |
| 352 root2.reset(JSONReader::DeprecatedRead( | |
| 353 "{\n" | |
| 354 " \"number\":9.87654321,\n" | |
| 355 " \"null\":null,\n" | |
| 356 " \"\\x53\":\"str\",\n" | |
| 357 "}\n", | |
| 358 JSON_ALLOW_TRAILING_COMMAS)); | |
| 359 ASSERT_TRUE(root2.get()); | |
| 360 EXPECT_TRUE(root->Equals(root2.get())); | |
| 361 | |
| 362 root2.reset(JSONReader::DeprecatedRead( | |
| 363 "{\r\n" | |
| 364 " \"number\":9.87654321,\r\n" | |
| 365 " \"null\":null,\r\n" | |
| 366 " \"\\x53\":\"str\",\r\n" | |
| 367 "}\r\n", | |
| 368 JSON_ALLOW_TRAILING_COMMAS)); | |
| 369 ASSERT_TRUE(root2.get()); | |
| 370 EXPECT_TRUE(root->Equals(root2.get())); | |
| 371 | |
| 372 // Test nesting | |
| 373 root.reset(JSONReader::DeprecatedRead( | |
| 374 "{\"inner\":{\"array\":[true]},\"false\":false,\"d\":{}}")); | |
| 375 ASSERT_TRUE(root.get()); | |
| 376 EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); | |
| 377 dict_val = static_cast<DictionaryValue*>(root.get()); | |
| 378 DictionaryValue* inner_dict = NULL; | |
| 379 ASSERT_TRUE(dict_val->GetDictionary("inner", &inner_dict)); | |
| 380 ListValue* inner_array = NULL; | |
| 381 ASSERT_TRUE(inner_dict->GetList("array", &inner_array)); | |
| 382 EXPECT_EQ(1U, inner_array->GetSize()); | |
| 383 bool_value = true; | |
| 384 EXPECT_TRUE(dict_val->GetBoolean("false", &bool_value)); | |
| 385 EXPECT_FALSE(bool_value); | |
| 386 inner_dict = NULL; | |
| 387 EXPECT_TRUE(dict_val->GetDictionary("d", &inner_dict)); | |
| 388 | |
| 389 root2.reset(JSONReader::DeprecatedRead( | |
| 390 "{\"inner\": {\"array\":[true] , },\"false\":false,\"d\":{},}", | |
| 391 JSON_ALLOW_TRAILING_COMMAS)); | |
| 392 EXPECT_TRUE(root->Equals(root2.get())); | |
| 393 | |
| 394 // Test keys with periods | |
| 395 root.reset(JSONReader::DeprecatedRead( | |
| 396 "{\"a.b\":3,\"c\":2,\"d.e.f\":{\"g.h.i.j\":1}}")); | |
| 397 ASSERT_TRUE(root.get()); | |
| 398 EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); | |
| 399 dict_val = static_cast<DictionaryValue*>(root.get()); | |
| 400 int integer_value = 0; | |
| 401 EXPECT_TRUE(dict_val->GetIntegerWithoutPathExpansion("a.b", &integer_value)); | |
| 402 EXPECT_EQ(3, integer_value); | |
| 403 EXPECT_TRUE(dict_val->GetIntegerWithoutPathExpansion("c", &integer_value)); | |
| 404 EXPECT_EQ(2, integer_value); | |
| 405 inner_dict = NULL; | |
| 406 ASSERT_TRUE(dict_val->GetDictionaryWithoutPathExpansion("d.e.f", | |
| 407 &inner_dict)); | |
| 408 EXPECT_EQ(1U, inner_dict->size()); | |
| 409 EXPECT_TRUE(inner_dict->GetIntegerWithoutPathExpansion("g.h.i.j", | |
| 410 &integer_value)); | |
| 411 EXPECT_EQ(1, integer_value); | |
| 412 | |
| 413 root.reset(JSONReader::DeprecatedRead("{\"a\":{\"b\":2},\"a.b\":1}")); | |
| 414 ASSERT_TRUE(root.get()); | |
| 415 EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); | |
| 416 dict_val = static_cast<DictionaryValue*>(root.get()); | |
| 417 EXPECT_TRUE(dict_val->GetInteger("a.b", &integer_value)); | |
| 418 EXPECT_EQ(2, integer_value); | |
| 419 EXPECT_TRUE(dict_val->GetIntegerWithoutPathExpansion("a.b", &integer_value)); | |
| 420 EXPECT_EQ(1, integer_value); | |
| 421 | |
| 422 // Invalid, no closing brace | |
| 423 root.reset(JSONReader::DeprecatedRead("{\"a\": true")); | |
| 424 EXPECT_FALSE(root.get()); | |
| 425 | |
| 426 // Invalid, keys must be quoted | |
| 427 root.reset(JSONReader::DeprecatedRead("{foo:true}")); | |
| 428 EXPECT_FALSE(root.get()); | |
| 429 | |
| 430 // Invalid, trailing comma | |
| 431 root.reset(JSONReader::DeprecatedRead("{\"a\":true,}")); | |
| 432 EXPECT_FALSE(root.get()); | |
| 433 | |
| 434 // Invalid, too many commas | |
| 435 root.reset(JSONReader::DeprecatedRead("{\"a\":true,,\"b\":false}")); | |
| 436 EXPECT_FALSE(root.get()); | |
| 437 root.reset(JSONReader::DeprecatedRead("{\"a\":true,,\"b\":false}", | |
| 438 JSON_ALLOW_TRAILING_COMMAS)); | |
| 439 EXPECT_FALSE(root.get()); | |
| 440 | |
| 441 // Invalid, no separator | |
| 442 root.reset(JSONReader::DeprecatedRead("{\"a\" \"b\"}")); | |
| 443 EXPECT_FALSE(root.get()); | |
| 444 | |
| 445 // Invalid, lone comma. | |
| 446 root.reset(JSONReader::DeprecatedRead("{,}")); | |
| 447 EXPECT_FALSE(root.get()); | |
| 448 root.reset(JSONReader::DeprecatedRead("{,}", JSON_ALLOW_TRAILING_COMMAS)); | |
| 449 EXPECT_FALSE(root.get()); | |
| 450 root.reset( | |
| 451 JSONReader::DeprecatedRead("{\"a\":true,,}", JSON_ALLOW_TRAILING_COMMAS)); | |
| 452 EXPECT_FALSE(root.get()); | |
| 453 root.reset( | |
| 454 JSONReader::DeprecatedRead("{,\"a\":true}", JSON_ALLOW_TRAILING_COMMAS)); | |
| 455 EXPECT_FALSE(root.get()); | |
| 456 root.reset(JSONReader::DeprecatedRead("{\"a\":true,,\"b\":false}", | |
| 457 JSON_ALLOW_TRAILING_COMMAS)); | |
| 458 EXPECT_FALSE(root.get()); | |
| 459 | |
| 460 // Test stack overflow | |
| 461 std::string evil(1000000, '['); | |
| 462 evil.append(std::string(1000000, ']')); | |
| 463 root.reset(JSONReader::DeprecatedRead(evil)); | |
| 464 EXPECT_FALSE(root.get()); | |
| 465 | |
| 466 // A few thousand adjacent lists is fine. | |
| 467 std::string not_evil("["); | |
| 468 not_evil.reserve(15010); | |
| 469 for (int i = 0; i < 5000; ++i) { | |
| 470 not_evil.append("[],"); | |
| 471 } | |
| 472 not_evil.append("[]]"); | |
| 473 root.reset(JSONReader::DeprecatedRead(not_evil)); | |
| 474 ASSERT_TRUE(root.get()); | |
| 475 EXPECT_TRUE(root->IsType(Value::TYPE_LIST)); | |
| 476 list = static_cast<ListValue*>(root.get()); | |
| 477 EXPECT_EQ(5001U, list->GetSize()); | |
| 478 | |
| 479 // Test utf8 encoded input | |
| 480 root = JSONReader().ReadToValue("\"\xe7\xbd\x91\xe9\xa1\xb5\""); | |
| 481 ASSERT_TRUE(root.get()); | |
| 482 EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); | |
| 483 str_val.clear(); | |
| 484 EXPECT_TRUE(root->GetAsString(&str_val)); | |
| 485 EXPECT_EQ(L"\x7f51\x9875", UTF8ToWide(str_val)); | |
| 486 | |
| 487 root = JSONReader().ReadToValue( | |
| 488 "{\"path\": \"/tmp/\xc3\xa0\xc3\xa8\xc3\xb2.png\"}"); | |
| 489 ASSERT_TRUE(root.get()); | |
| 490 EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); | |
| 491 EXPECT_TRUE(root->GetAsDictionary(&dict_val)); | |
| 492 EXPECT_TRUE(dict_val->GetString("path", &str_val)); | |
| 493 EXPECT_EQ("/tmp/\xC3\xA0\xC3\xA8\xC3\xB2.png", str_val); | |
| 494 | |
| 495 // Test invalid utf8 encoded input | |
| 496 root = JSONReader().ReadToValue("\"345\xb0\xa1\xb0\xa2\""); | |
| 497 EXPECT_FALSE(root.get()); | |
| 498 root = JSONReader().ReadToValue("\"123\xc0\x81\""); | |
| 499 EXPECT_FALSE(root.get()); | |
| 500 root = JSONReader().ReadToValue("\"abc\xc0\xae\""); | |
| 501 EXPECT_FALSE(root.get()); | |
| 502 | |
| 503 // Test utf16 encoded strings. | |
| 504 root = JSONReader().ReadToValue("\"\\u20ac3,14\""); | |
| 505 ASSERT_TRUE(root.get()); | |
| 506 EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); | |
| 507 str_val.clear(); | |
| 508 EXPECT_TRUE(root->GetAsString(&str_val)); | |
| 509 EXPECT_EQ("\xe2\x82\xac""3,14", str_val); | |
| 510 | |
| 511 root = JSONReader().ReadToValue("\"\\ud83d\\udca9\\ud83d\\udc6c\""); | |
| 512 ASSERT_TRUE(root.get()); | |
| 513 EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); | |
| 514 str_val.clear(); | |
| 515 EXPECT_TRUE(root->GetAsString(&str_val)); | |
| 516 EXPECT_EQ("\xf0\x9f\x92\xa9\xf0\x9f\x91\xac", str_val); | |
| 517 | |
| 518 // Test invalid utf16 strings. | |
| 519 const char* const cases[] = { | |
| 520 "\"\\u123\"", // Invalid scalar. | |
| 521 "\"\\ud83d\"", // Invalid scalar. | |
| 522 "\"\\u$%@!\"", // Invalid scalar. | |
| 523 "\"\\uzz89\"", // Invalid scalar. | |
| 524 "\"\\ud83d\\udca\"", // Invalid lower surrogate. | |
| 525 "\"\\ud83d\\ud83d\"", // Invalid lower surrogate. | |
| 526 "\"\\ud83foo\"", // No lower surrogate. | |
| 527 "\"\\ud83\\foo\"" // No lower surrogate. | |
| 528 }; | |
| 529 for (size_t i = 0; i < arraysize(cases); ++i) { | |
| 530 root = JSONReader().ReadToValue(cases[i]); | |
| 531 EXPECT_FALSE(root.get()) << cases[i]; | |
| 532 } | |
| 533 | |
| 534 // Test literal root objects. | |
| 535 root.reset(JSONReader::DeprecatedRead("null")); | |
| 536 EXPECT_TRUE(root->IsType(Value::TYPE_NULL)); | |
| 537 | |
| 538 root.reset(JSONReader::DeprecatedRead("true")); | |
| 539 ASSERT_TRUE(root.get()); | |
| 540 EXPECT_TRUE(root->GetAsBoolean(&bool_value)); | |
| 541 EXPECT_TRUE(bool_value); | |
| 542 | |
| 543 root.reset(JSONReader::DeprecatedRead("10")); | |
| 544 ASSERT_TRUE(root.get()); | |
| 545 EXPECT_TRUE(root->GetAsInteger(&integer_value)); | |
| 546 EXPECT_EQ(10, integer_value); | |
| 547 | |
| 548 root.reset(JSONReader::DeprecatedRead("\"root\"")); | |
| 549 ASSERT_TRUE(root.get()); | |
| 550 EXPECT_TRUE(root->GetAsString(&str_val)); | |
| 551 EXPECT_EQ("root", str_val); | |
| 552 } | |
| 553 | |
| 554 TEST(JSONReaderTest, ReadFromFile) { | |
| 555 FilePath path; | |
| 556 ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &path)); | |
| 557 path = path.AppendASCII("json"); | |
| 558 ASSERT_TRUE(base::PathExists(path)); | |
| 559 | |
| 560 std::string input; | |
| 561 ASSERT_TRUE(ReadFileToString( | |
| 562 path.Append(FILE_PATH_LITERAL("bom_feff.json")), &input)); | |
| 563 | |
| 564 JSONReader reader; | |
| 565 scoped_ptr<Value> root(reader.ReadToValue(input)); | |
| 566 ASSERT_TRUE(root.get()) << reader.GetErrorMessage(); | |
| 567 EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); | |
| 568 } | |
| 569 | |
| 570 // Tests that the root of a JSON object can be deleted safely while its | |
| 571 // children outlive it. | |
| 572 TEST(JSONReaderTest, StringOptimizations) { | |
| 573 scoped_ptr<Value> dict_literal_0; | |
| 574 scoped_ptr<Value> dict_literal_1; | |
| 575 scoped_ptr<Value> dict_string_0; | |
| 576 scoped_ptr<Value> dict_string_1; | |
| 577 scoped_ptr<Value> list_value_0; | |
| 578 scoped_ptr<Value> list_value_1; | |
| 579 | |
| 580 { | |
| 581 scoped_ptr<Value> root = JSONReader::Read( | |
| 582 "{" | |
| 583 " \"test\": {" | |
| 584 " \"foo\": true," | |
| 585 " \"bar\": 3.14," | |
| 586 " \"baz\": \"bat\"," | |
| 587 " \"moo\": \"cow\"" | |
| 588 " }," | |
| 589 " \"list\": [" | |
| 590 " \"a\"," | |
| 591 " \"b\"" | |
| 592 " ]" | |
| 593 "}", | |
| 594 JSON_DETACHABLE_CHILDREN); | |
| 595 ASSERT_TRUE(root.get()); | |
| 596 | |
| 597 DictionaryValue* root_dict = NULL; | |
| 598 ASSERT_TRUE(root->GetAsDictionary(&root_dict)); | |
| 599 | |
| 600 DictionaryValue* dict = NULL; | |
| 601 ListValue* list = NULL; | |
| 602 | |
| 603 ASSERT_TRUE(root_dict->GetDictionary("test", &dict)); | |
| 604 ASSERT_TRUE(root_dict->GetList("list", &list)); | |
| 605 | |
| 606 EXPECT_TRUE(dict->Remove("foo", &dict_literal_0)); | |
| 607 EXPECT_TRUE(dict->Remove("bar", &dict_literal_1)); | |
| 608 EXPECT_TRUE(dict->Remove("baz", &dict_string_0)); | |
| 609 EXPECT_TRUE(dict->Remove("moo", &dict_string_1)); | |
| 610 | |
| 611 ASSERT_EQ(2u, list->GetSize()); | |
| 612 EXPECT_TRUE(list->Remove(0, &list_value_0)); | |
| 613 EXPECT_TRUE(list->Remove(0, &list_value_1)); | |
| 614 } | |
| 615 | |
| 616 bool b = false; | |
| 617 double d = 0; | |
| 618 std::string s; | |
| 619 | |
| 620 EXPECT_TRUE(dict_literal_0->GetAsBoolean(&b)); | |
| 621 EXPECT_TRUE(b); | |
| 622 | |
| 623 EXPECT_TRUE(dict_literal_1->GetAsDouble(&d)); | |
| 624 EXPECT_EQ(3.14, d); | |
| 625 | |
| 626 EXPECT_TRUE(dict_string_0->GetAsString(&s)); | |
| 627 EXPECT_EQ("bat", s); | |
| 628 | |
| 629 EXPECT_TRUE(dict_string_1->GetAsString(&s)); | |
| 630 EXPECT_EQ("cow", s); | |
| 631 | |
| 632 EXPECT_TRUE(list_value_0->GetAsString(&s)); | |
| 633 EXPECT_EQ("a", s); | |
| 634 EXPECT_TRUE(list_value_1->GetAsString(&s)); | |
| 635 EXPECT_EQ("b", s); | |
| 636 } | |
| 637 | |
| 638 // A smattering of invalid JSON designed to test specific portions of the | |
| 639 // parser implementation against buffer overflow. Best run with DCHECKs so | |
| 640 // that the one in NextChar fires. | |
| 641 TEST(JSONReaderTest, InvalidSanity) { | |
| 642 const char* const invalid_json[] = { | |
| 643 "/* test *", | |
| 644 "{\"foo\"", | |
| 645 "{\"foo\":", | |
| 646 " [", | |
| 647 "\"\\u123g\"", | |
| 648 "{\n\"eh:\n}", | |
| 649 }; | |
| 650 | |
| 651 for (size_t i = 0; i < arraysize(invalid_json); ++i) { | |
| 652 JSONReader reader; | |
| 653 LOG(INFO) << "Sanity test " << i << ": <" << invalid_json[i] << ">"; | |
| 654 EXPECT_FALSE(reader.ReadToValue(invalid_json[i])); | |
| 655 EXPECT_NE(JSONReader::JSON_NO_ERROR, reader.error_code()); | |
| 656 EXPECT_NE("", reader.GetErrorMessage()); | |
| 657 } | |
| 658 } | |
| 659 | |
| 660 TEST(JSONReaderTest, IllegalTrailingNull) { | |
| 661 const char json[] = { '"', 'n', 'u', 'l', 'l', '"', '\0' }; | |
| 662 std::string json_string(json, sizeof(json)); | |
| 663 JSONReader reader; | |
| 664 EXPECT_FALSE(reader.ReadToValue(json_string)); | |
| 665 EXPECT_EQ(JSONReader::JSON_UNEXPECTED_DATA_AFTER_ROOT, reader.error_code()); | |
| 666 } | |
| 667 | |
| 668 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
