diff options
Diffstat (limited to 'third_party/chromium/base/json/json_reader_unittest.cc')
| -rw-r--r-- | third_party/chromium/base/json/json_reader_unittest.cc | 1087 |
1 files changed, 553 insertions, 534 deletions
diff --git a/third_party/chromium/base/json/json_reader_unittest.cc b/third_party/chromium/base/json/json_reader_unittest.cc index b1ad46e..1daf26c 100644 --- a/third_party/chromium/base/json/json_reader_unittest.cc +++ b/third_party/chromium/base/json/json_reader_unittest.cc @@ -19,525 +19,549 @@ namespace base { TEST(JSONReaderTest, Reading) { - // some whitespace checking - std::unique_ptr<Value> root = JSONReader().ReadToValue(" null "); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_NULL)); - - // Invalid JSON string - root = JSONReader().ReadToValue("nu"); - EXPECT_FALSE(root.get()); - - // Simple bool - root = JSONReader().ReadToValue("true "); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_BOOLEAN)); - - // Embedded comment - root = JSONReader().ReadToValue("/* comment */null"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_NULL)); - root = JSONReader().ReadToValue("40 /* comment */"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER)); - root = JSONReader().ReadToValue("true // comment"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_BOOLEAN)); - root = JSONReader().ReadToValue("/* comment */\"sample string\""); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); - std::string value; - EXPECT_TRUE(root->GetAsString(&value)); - EXPECT_EQ("sample string", value); - root = JSONReader().ReadToValue("[1, /* comment, 2 ] */ \n 3]"); - ASSERT_TRUE(root.get()); - ListValue* list = static_cast<ListValue*>(root.get()); - EXPECT_EQ(2u, list->GetSize()); - int int_val = 0; - EXPECT_TRUE(list->GetInteger(0, &int_val)); - EXPECT_EQ(1, int_val); - EXPECT_TRUE(list->GetInteger(1, &int_val)); - EXPECT_EQ(3, int_val); - root = JSONReader().ReadToValue("[1, /*a*/2, 3]"); - ASSERT_TRUE(root.get()); - list = static_cast<ListValue*>(root.get()); - EXPECT_EQ(3u, list->GetSize()); - root = JSONReader().ReadToValue("/* comment **/42"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER)); - EXPECT_TRUE(root->GetAsInteger(&int_val)); - EXPECT_EQ(42, int_val); - root = JSONReader().ReadToValue( - "/* comment **/\n" - "// */ 43\n" - "44"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER)); - EXPECT_TRUE(root->GetAsInteger(&int_val)); - EXPECT_EQ(44, int_val); - - // Test number formats - root = JSONReader().ReadToValue("43"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER)); - EXPECT_TRUE(root->GetAsInteger(&int_val)); - EXPECT_EQ(43, int_val); - - // According to RFC4627, oct, hex, and leading zeros are invalid JSON. - root = JSONReader().ReadToValue("043"); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("0x43"); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("00"); - EXPECT_FALSE(root.get()); - - // Test 0 (which needs to be special cased because of the leading zero - // clause). - root = JSONReader().ReadToValue("0"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER)); - int_val = 1; - EXPECT_TRUE(root->GetAsInteger(&int_val)); - EXPECT_EQ(0, int_val); - - // Numbers that overflow ints should succeed, being internally promoted to - // storage as doubles - root = JSONReader().ReadToValue("2147483648"); - ASSERT_TRUE(root.get()); - double double_val; - EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); - double_val = 0.0; - EXPECT_TRUE(root->GetAsDouble(&double_val)); - EXPECT_DOUBLE_EQ(2147483648.0, double_val); - root = JSONReader().ReadToValue("-2147483649"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); - double_val = 0.0; - EXPECT_TRUE(root->GetAsDouble(&double_val)); - EXPECT_DOUBLE_EQ(-2147483649.0, double_val); - - // Parse a double - root = JSONReader().ReadToValue("43.1"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); - double_val = 0.0; - EXPECT_TRUE(root->GetAsDouble(&double_val)); - EXPECT_DOUBLE_EQ(43.1, double_val); - - root = JSONReader().ReadToValue("4.3e-1"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); - double_val = 0.0; - EXPECT_TRUE(root->GetAsDouble(&double_val)); - EXPECT_DOUBLE_EQ(.43, double_val); - - root = JSONReader().ReadToValue("2.1e0"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); - double_val = 0.0; - EXPECT_TRUE(root->GetAsDouble(&double_val)); - EXPECT_DOUBLE_EQ(2.1, double_val); - - root = JSONReader().ReadToValue("2.1e+0001"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); - double_val = 0.0; - EXPECT_TRUE(root->GetAsDouble(&double_val)); - EXPECT_DOUBLE_EQ(21.0, double_val); - - root = JSONReader().ReadToValue("0.01"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); - double_val = 0.0; - EXPECT_TRUE(root->GetAsDouble(&double_val)); - EXPECT_DOUBLE_EQ(0.01, double_val); - - root = JSONReader().ReadToValue("1.00"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); - double_val = 0.0; - EXPECT_TRUE(root->GetAsDouble(&double_val)); - EXPECT_DOUBLE_EQ(1.0, double_val); - - // Fractional parts must have a digit before and after the decimal point. - root = JSONReader().ReadToValue("1."); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue(".1"); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("1.e10"); - EXPECT_FALSE(root.get()); - - // Exponent must have a digit following the 'e'. - root = JSONReader().ReadToValue("1e"); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("1E"); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("1e1."); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("1e1.0"); - EXPECT_FALSE(root.get()); - - // INF/-INF/NaN are not valid - root = JSONReader().ReadToValue("1e1000"); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("-1e1000"); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("NaN"); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("nan"); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("inf"); - EXPECT_FALSE(root.get()); - - // Invalid number formats - root = JSONReader().ReadToValue("4.3.1"); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("4e3.1"); - EXPECT_FALSE(root.get()); - - // Test string parser - root = JSONReader().ReadToValue("\"hello world\""); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); - std::string str_val; - EXPECT_TRUE(root->GetAsString(&str_val)); - EXPECT_EQ("hello world", str_val); - - // Empty string - root = JSONReader().ReadToValue("\"\""); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); - str_val.clear(); - EXPECT_TRUE(root->GetAsString(&str_val)); - EXPECT_EQ("", str_val); - - // Test basic string escapes - root = JSONReader().ReadToValue("\" \\\"\\\\\\/\\b\\f\\n\\r\\t\\v\""); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); - str_val.clear(); - EXPECT_TRUE(root->GetAsString(&str_val)); - EXPECT_EQ(" \"\\/\b\f\n\r\t\v", str_val); - - // Test hex and unicode escapes including the null character. - root = JSONReader().ReadToValue("\"\\x41\\x00\\u1234\""); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); - str_val.clear(); - EXPECT_TRUE(root->GetAsString(&str_val)); - EXPECT_EQ((std::string{'A', '\0', '\xE1', '\x88', '\xB4'}), str_val); - - // Test invalid strings - root = JSONReader().ReadToValue("\"no closing quote"); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("\"\\z invalid escape char\""); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("\"\\xAQ invalid hex code\""); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("not enough hex chars\\x1\""); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("\"not enough escape chars\\u123\""); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("\"extra backslash at end of input\\\""); - EXPECT_FALSE(root.get()); - - // Basic array - root = JSONReader::Read("[true, false, null]"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_LIST)); - list = static_cast<ListValue*>(root.get()); - EXPECT_EQ(3U, list->GetSize()); - - // Test with trailing comma. Should be parsed the same as above. - std::unique_ptr<Value> root2 = - JSONReader::Read("[true, false, null, ]", JSON_ALLOW_TRAILING_COMMAS); - EXPECT_TRUE(root->Equals(root2.get())); - - // Empty array - root = JSONReader::Read("[]"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_LIST)); - list = static_cast<ListValue*>(root.get()); - EXPECT_EQ(0U, list->GetSize()); - - // Nested arrays - root = JSONReader::Read("[[true], [], [false, [], [null]], null]"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_LIST)); - list = static_cast<ListValue*>(root.get()); - EXPECT_EQ(4U, list->GetSize()); - - // Lots of trailing commas. - root2 = JSONReader::Read("[[true], [], [false, [], [null, ] , ], null,]", - JSON_ALLOW_TRAILING_COMMAS); - EXPECT_TRUE(root->Equals(root2.get())); - - // Invalid, missing close brace. - root = JSONReader::Read("[[true], [], [false, [], [null]], null"); - EXPECT_FALSE(root.get()); - - // Invalid, too many commas - root = JSONReader::Read("[true,, null]"); - EXPECT_FALSE(root.get()); - root = JSONReader::Read("[true,, null]", JSON_ALLOW_TRAILING_COMMAS); - EXPECT_FALSE(root.get()); - - // Invalid, no commas - root = JSONReader::Read("[true null]"); - EXPECT_FALSE(root.get()); - - // Invalid, trailing comma - root = JSONReader::Read("[true,]"); - EXPECT_FALSE(root.get()); - - // Valid if we set |allow_trailing_comma| to true. - root = JSONReader::Read("[true,]", JSON_ALLOW_TRAILING_COMMAS); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_LIST)); - list = static_cast<ListValue*>(root.get()); - EXPECT_EQ(1U, list->GetSize()); - Value* tmp_value = NULL; - ASSERT_TRUE(list->Get(0, &tmp_value)); - EXPECT_TRUE(tmp_value->IsType(Value::TYPE_BOOLEAN)); - bool bool_value = false; - EXPECT_TRUE(tmp_value->GetAsBoolean(&bool_value)); - EXPECT_TRUE(bool_value); - - // Don't allow empty elements, even if |allow_trailing_comma| is - // true. - root = JSONReader::Read("[,]", JSON_ALLOW_TRAILING_COMMAS); - EXPECT_FALSE(root.get()); - root = JSONReader::Read("[true,,]", JSON_ALLOW_TRAILING_COMMAS); - EXPECT_FALSE(root.get()); - root = JSONReader::Read("[,true,]", JSON_ALLOW_TRAILING_COMMAS); - EXPECT_FALSE(root.get()); - root = JSONReader::Read("[true,,false]", JSON_ALLOW_TRAILING_COMMAS); - EXPECT_FALSE(root.get()); - - // Test objects - root = JSONReader::Read("{}"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); - - root = JSONReader::Read( - "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\" }"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); - DictionaryValue* dict_val = static_cast<DictionaryValue*>(root.get()); - double_val = 0.0; - EXPECT_TRUE(dict_val->GetDouble("number", &double_val)); - EXPECT_DOUBLE_EQ(9.87654321, double_val); - Value* null_val = NULL; - ASSERT_TRUE(dict_val->Get("null", &null_val)); - EXPECT_TRUE(null_val->IsType(Value::TYPE_NULL)); - str_val.clear(); - EXPECT_TRUE(dict_val->GetString("S", &str_val)); - EXPECT_EQ("str", str_val); - - root2 = JSONReader::Read( - "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", }", - JSON_ALLOW_TRAILING_COMMAS); - ASSERT_TRUE(root2.get()); - EXPECT_TRUE(root->Equals(root2.get())); - - // Test newline equivalence. - root2 = JSONReader::Read( - "{\n" - " \"number\":9.87654321,\n" - " \"null\":null,\n" - " \"\\x53\":\"str\",\n" - "}\n", - JSON_ALLOW_TRAILING_COMMAS); - ASSERT_TRUE(root2.get()); - EXPECT_TRUE(root->Equals(root2.get())); - - root2 = JSONReader::Read( - "{\r\n" - " \"number\":9.87654321,\r\n" - " \"null\":null,\r\n" - " \"\\x53\":\"str\",\r\n" - "}\r\n", - JSON_ALLOW_TRAILING_COMMAS); - ASSERT_TRUE(root2.get()); - EXPECT_TRUE(root->Equals(root2.get())); - - // Test nesting - root = JSONReader::Read( - "{\"inner\":{\"array\":[true]},\"false\":false,\"d\":{}}"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); - dict_val = static_cast<DictionaryValue*>(root.get()); - DictionaryValue* inner_dict = NULL; - ASSERT_TRUE(dict_val->GetDictionary("inner", &inner_dict)); - ListValue* inner_array = NULL; - ASSERT_TRUE(inner_dict->GetList("array", &inner_array)); - EXPECT_EQ(1U, inner_array->GetSize()); - bool_value = true; - EXPECT_TRUE(dict_val->GetBoolean("false", &bool_value)); - EXPECT_FALSE(bool_value); - inner_dict = NULL; - EXPECT_TRUE(dict_val->GetDictionary("d", &inner_dict)); - - root2 = JSONReader::Read( - "{\"inner\": {\"array\":[true] , },\"false\":false,\"d\":{},}", - JSON_ALLOW_TRAILING_COMMAS); - EXPECT_TRUE(root->Equals(root2.get())); - - // Test keys with periods - root = JSONReader::Read("{\"a.b\":3,\"c\":2,\"d.e.f\":{\"g.h.i.j\":1}}"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); - dict_val = static_cast<DictionaryValue*>(root.get()); - int integer_value = 0; - EXPECT_TRUE(dict_val->GetIntegerWithoutPathExpansion("a.b", &integer_value)); - EXPECT_EQ(3, integer_value); - EXPECT_TRUE(dict_val->GetIntegerWithoutPathExpansion("c", &integer_value)); - EXPECT_EQ(2, integer_value); - inner_dict = NULL; - ASSERT_TRUE(dict_val->GetDictionaryWithoutPathExpansion("d.e.f", - &inner_dict)); - EXPECT_EQ(1U, inner_dict->size()); - EXPECT_TRUE(inner_dict->GetIntegerWithoutPathExpansion("g.h.i.j", - &integer_value)); - EXPECT_EQ(1, integer_value); - - root = JSONReader::Read("{\"a\":{\"b\":2},\"a.b\":1}"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); - dict_val = static_cast<DictionaryValue*>(root.get()); - EXPECT_TRUE(dict_val->GetInteger("a.b", &integer_value)); - EXPECT_EQ(2, integer_value); - EXPECT_TRUE(dict_val->GetIntegerWithoutPathExpansion("a.b", &integer_value)); - EXPECT_EQ(1, integer_value); - - // Invalid, no closing brace - root = JSONReader::Read("{\"a\": true"); - EXPECT_FALSE(root.get()); - - // Invalid, keys must be quoted - root = JSONReader::Read("{foo:true}"); - EXPECT_FALSE(root.get()); - - // Invalid, trailing comma - root = JSONReader::Read("{\"a\":true,}"); - EXPECT_FALSE(root.get()); - - // Invalid, too many commas - root = JSONReader::Read("{\"a\":true,,\"b\":false}"); - EXPECT_FALSE(root.get()); - root = - JSONReader::Read("{\"a\":true,,\"b\":false}", JSON_ALLOW_TRAILING_COMMAS); - EXPECT_FALSE(root.get()); - - // Invalid, no separator - root = JSONReader::Read("{\"a\" \"b\"}"); - EXPECT_FALSE(root.get()); - - // Invalid, lone comma. - root = JSONReader::Read("{,}"); - EXPECT_FALSE(root.get()); - root = JSONReader::Read("{,}", JSON_ALLOW_TRAILING_COMMAS); - EXPECT_FALSE(root.get()); - root = JSONReader::Read("{\"a\":true,,}", JSON_ALLOW_TRAILING_COMMAS); - EXPECT_FALSE(root.get()); - root = JSONReader::Read("{,\"a\":true}", JSON_ALLOW_TRAILING_COMMAS); - EXPECT_FALSE(root.get()); - root = - JSONReader::Read("{\"a\":true,,\"b\":false}", JSON_ALLOW_TRAILING_COMMAS); - EXPECT_FALSE(root.get()); - - // Test stack overflow - std::string evil(1000000, '['); - evil.append(std::string(1000000, ']')); - root = JSONReader::Read(evil); - EXPECT_FALSE(root.get()); - - // A few thousand adjacent lists is fine. - std::string not_evil("["); - not_evil.reserve(15010); - for (int i = 0; i < 5000; ++i) { - not_evil.append("[],"); - } - not_evil.append("[]]"); - root = JSONReader::Read(not_evil); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_LIST)); - list = static_cast<ListValue*>(root.get()); - EXPECT_EQ(5001U, list->GetSize()); - - // Test utf8 encoded input - root = JSONReader().ReadToValue("\"\xe7\xbd\x91\xe9\xa1\xb5\""); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); - str_val.clear(); - EXPECT_TRUE(root->GetAsString(&str_val)); - EXPECT_EQ("\xE7\xBD\x91\xE9\xA1\xB5", str_val); - - root = JSONReader().ReadToValue( - "{\"path\": \"/tmp/\xc3\xa0\xc3\xa8\xc3\xb2.png\"}"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); - EXPECT_TRUE(root->GetAsDictionary(&dict_val)); - EXPECT_TRUE(dict_val->GetString("path", &str_val)); - EXPECT_EQ("/tmp/\xC3\xA0\xC3\xA8\xC3\xB2.png", str_val); - - // Test invalid utf8 encoded input - root = JSONReader().ReadToValue("\"345\xb0\xa1\xb0\xa2\""); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("\"123\xc0\x81\""); - EXPECT_FALSE(root.get()); - root = JSONReader().ReadToValue("\"abc\xc0\xae\""); - EXPECT_FALSE(root.get()); - - // Test utf16 encoded strings. - root = JSONReader().ReadToValue("\"\\u20ac3,14\""); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); - str_val.clear(); - EXPECT_TRUE(root->GetAsString(&str_val)); - EXPECT_EQ("\xe2\x82\xac""3,14", str_val); - - root = JSONReader().ReadToValue("\"\\ud83d\\udca9\\ud83d\\udc6c\""); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); - str_val.clear(); - EXPECT_TRUE(root->GetAsString(&str_val)); - EXPECT_EQ("\xf0\x9f\x92\xa9\xf0\x9f\x91\xac", str_val); - - // Test invalid utf16 strings. - const char* const cases[] = { - "\"\\u123\"", // Invalid scalar. - "\"\\ud83d\"", // Invalid scalar. - "\"\\u$%@!\"", // Invalid scalar. - "\"\\uzz89\"", // Invalid scalar. - "\"\\ud83d\\udca\"", // Invalid lower surrogate. - "\"\\ud83d\\ud83d\"", // Invalid lower surrogate. - "\"\\ud83foo\"", // No lower surrogate. - "\"\\ud83\\foo\"" // No lower surrogate. - }; - for (size_t i = 0; i < arraysize(cases); ++i) { - root = JSONReader().ReadToValue(cases[i]); - EXPECT_FALSE(root.get()) << cases[i]; + { + // some whitespace checking + std::unique_ptr<Value> root = JSONReader().ReadToValue(" null "); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_NULL)); + } + + { + // Invalid JSON string + EXPECT_FALSE(JSONReader().ReadToValue("nu")); + } + + { + // Simple bool + std::unique_ptr<Value> root = JSONReader().ReadToValue("true "); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_BOOLEAN)); + } + + { + // Embedded comment + std::unique_ptr<Value> root = JSONReader().ReadToValue("/* comment */null"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_NULL)); + root = JSONReader().ReadToValue("40 /* comment */"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER)); + root = JSONReader().ReadToValue("true // comment"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_BOOLEAN)); + root = JSONReader().ReadToValue("/* comment */\"sample string\""); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); + std::string value; + EXPECT_TRUE(root->GetAsString(&value)); + EXPECT_EQ("sample string", value); + std::unique_ptr<ListValue> list = ListValue::From( + JSONReader().ReadToValue("[1, /* comment, 2 ] */ \n 3]")); + ASSERT_TRUE(list); + EXPECT_EQ(2u, list->GetSize()); + int int_val = 0; + EXPECT_TRUE(list->GetInteger(0, &int_val)); + EXPECT_EQ(1, int_val); + EXPECT_TRUE(list->GetInteger(1, &int_val)); + EXPECT_EQ(3, int_val); + list = ListValue::From(JSONReader().ReadToValue("[1, /*a*/2, 3]")); + ASSERT_TRUE(list); + EXPECT_EQ(3u, list->GetSize()); + root = JSONReader().ReadToValue("/* comment **/42"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER)); + EXPECT_TRUE(root->GetAsInteger(&int_val)); + EXPECT_EQ(42, int_val); + root = JSONReader().ReadToValue( + "/* comment **/\n" + "// */ 43\n" + "44"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER)); + EXPECT_TRUE(root->GetAsInteger(&int_val)); + EXPECT_EQ(44, int_val); + } + + { + // Test number formats + std::unique_ptr<Value> root = JSONReader().ReadToValue("43"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER)); + int int_val = 0; + EXPECT_TRUE(root->GetAsInteger(&int_val)); + EXPECT_EQ(43, int_val); + } + + { + // According to RFC4627, oct, hex, and leading zeros are invalid JSON. + EXPECT_FALSE(JSONReader().ReadToValue("043")); + EXPECT_FALSE(JSONReader().ReadToValue("0x43")); + EXPECT_FALSE(JSONReader().ReadToValue("00")); + } + + { + // Test 0 (which needs to be special cased because of the leading zero + // clause). + std::unique_ptr<Value> root = JSONReader().ReadToValue("0"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_INTEGER)); + int int_val = 1; + EXPECT_TRUE(root->GetAsInteger(&int_val)); + EXPECT_EQ(0, int_val); + } + + { + // Numbers that overflow ints should succeed, being internally promoted to + // storage as doubles + std::unique_ptr<Value> root = JSONReader().ReadToValue("2147483648"); + ASSERT_TRUE(root); + double double_val; + EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); + double_val = 0.0; + EXPECT_TRUE(root->GetAsDouble(&double_val)); + EXPECT_DOUBLE_EQ(2147483648.0, double_val); + root = JSONReader().ReadToValue("-2147483649"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); + double_val = 0.0; + EXPECT_TRUE(root->GetAsDouble(&double_val)); + EXPECT_DOUBLE_EQ(-2147483649.0, double_val); + } + + { + // Parse a double + std::unique_ptr<Value> root = JSONReader().ReadToValue("43.1"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); + double double_val = 0.0; + EXPECT_TRUE(root->GetAsDouble(&double_val)); + EXPECT_DOUBLE_EQ(43.1, double_val); + + root = JSONReader().ReadToValue("4.3e-1"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); + double_val = 0.0; + EXPECT_TRUE(root->GetAsDouble(&double_val)); + EXPECT_DOUBLE_EQ(.43, double_val); + + root = JSONReader().ReadToValue("2.1e0"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); + double_val = 0.0; + EXPECT_TRUE(root->GetAsDouble(&double_val)); + EXPECT_DOUBLE_EQ(2.1, double_val); + + root = JSONReader().ReadToValue("2.1e+0001"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); + double_val = 0.0; + EXPECT_TRUE(root->GetAsDouble(&double_val)); + EXPECT_DOUBLE_EQ(21.0, double_val); + + root = JSONReader().ReadToValue("0.01"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); + double_val = 0.0; + EXPECT_TRUE(root->GetAsDouble(&double_val)); + EXPECT_DOUBLE_EQ(0.01, double_val); + + root = JSONReader().ReadToValue("1.00"); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_DOUBLE)); + double_val = 0.0; + EXPECT_TRUE(root->GetAsDouble(&double_val)); + EXPECT_DOUBLE_EQ(1.0, double_val); } - // Test literal root objects. - root = JSONReader::Read("null"); - EXPECT_TRUE(root->IsType(Value::TYPE_NULL)); + { + // Fractional parts must have a digit before and after the decimal point. + EXPECT_FALSE(JSONReader().ReadToValue("1.")); + EXPECT_FALSE(JSONReader().ReadToValue(".1")); + EXPECT_FALSE(JSONReader().ReadToValue("1.e10")); + } + + { + // Exponent must have a digit following the 'e'. + EXPECT_FALSE(JSONReader().ReadToValue("1e")); + EXPECT_FALSE(JSONReader().ReadToValue("1E")); + EXPECT_FALSE(JSONReader().ReadToValue("1e1.")); + EXPECT_FALSE(JSONReader().ReadToValue("1e1.0")); + } + + { + // INF/-INF/NaN are not valid + EXPECT_FALSE(JSONReader().ReadToValue("1e1000")); + EXPECT_FALSE(JSONReader().ReadToValue("-1e1000")); + EXPECT_FALSE(JSONReader().ReadToValue("NaN")); + EXPECT_FALSE(JSONReader().ReadToValue("nan")); + EXPECT_FALSE(JSONReader().ReadToValue("inf")); + } + + { + // Invalid number formats + EXPECT_FALSE(JSONReader().ReadToValue("4.3.1")); + EXPECT_FALSE(JSONReader().ReadToValue("4e3.1")); + } + + { + // Test string parser + std::unique_ptr<Value> root = JSONReader().ReadToValue("\"hello world\""); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); + std::string str_val; + EXPECT_TRUE(root->GetAsString(&str_val)); + EXPECT_EQ("hello world", str_val); + } - root = JSONReader::Read("true"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->GetAsBoolean(&bool_value)); - EXPECT_TRUE(bool_value); + { + // Empty string + std::unique_ptr<Value> root = JSONReader().ReadToValue("\"\""); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); + std::string str_val; + EXPECT_TRUE(root->GetAsString(&str_val)); + EXPECT_EQ("", str_val); + } - root = JSONReader::Read("10"); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->GetAsInteger(&integer_value)); - EXPECT_EQ(10, integer_value); + { + // Test basic string escapes + std::unique_ptr<Value> root = + JSONReader().ReadToValue("\" \\\"\\\\\\/\\b\\f\\n\\r\\t\\v\""); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); + std::string str_val; + EXPECT_TRUE(root->GetAsString(&str_val)); + EXPECT_EQ(" \"\\/\b\f\n\r\t\v", str_val); + } - root = JSONReader::Read("\"root\""); - ASSERT_TRUE(root.get()); - EXPECT_TRUE(root->GetAsString(&str_val)); - EXPECT_EQ("root", str_val); + { + // Test hex and unicode escapes including the null character. + std::unique_ptr<Value> root = + JSONReader().ReadToValue("\"\\x41\\x00\\u1234\""); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); + std::string str_val; + EXPECT_TRUE(root->GetAsString(&str_val)); + EXPECT_EQ((std::string{'A', '\0', '\xE1', '\x88', '\xB4'}), str_val); + } + + { + // Test invalid strings + EXPECT_FALSE(JSONReader().ReadToValue("\"no closing quote")); + EXPECT_FALSE(JSONReader().ReadToValue("\"\\z invalid escape char\"")); + EXPECT_FALSE(JSONReader().ReadToValue("\"\\xAQ invalid hex code\"")); + EXPECT_FALSE(JSONReader().ReadToValue("not enough hex chars\\x1\"")); + EXPECT_FALSE(JSONReader().ReadToValue("\"not enough escape chars\\u123\"")); + EXPECT_FALSE( + JSONReader().ReadToValue("\"extra backslash at end of input\\\"")); + } + + { + // Basic array + std::unique_ptr<ListValue> list = + ListValue::From(JSONReader::Read("[true, false, null]")); + ASSERT_TRUE(list); + EXPECT_EQ(3U, list->GetSize()); + + // Test with trailing comma. Should be parsed the same as above. + std::unique_ptr<Value> root2 = + JSONReader::Read("[true, false, null, ]", JSON_ALLOW_TRAILING_COMMAS); + EXPECT_TRUE(list->Equals(root2.get())); + } + + { + // Empty array + std::unique_ptr<ListValue> list = ListValue::From(JSONReader::Read("[]")); + ASSERT_TRUE(list); + EXPECT_EQ(0U, list->GetSize()); + } + + { + // Nested arrays + std::unique_ptr<ListValue> list = ListValue::From( + JSONReader::Read("[[true], [], [false, [], [null]], null]")); + ASSERT_TRUE(list); + EXPECT_EQ(4U, list->GetSize()); + + // Lots of trailing commas. + std::unique_ptr<Value> root2 = + JSONReader::Read("[[true], [], [false, [], [null, ] , ], null,]", + JSON_ALLOW_TRAILING_COMMAS); + EXPECT_TRUE(list->Equals(root2.get())); + } + + { + // Invalid, missing close brace. + EXPECT_FALSE(JSONReader::Read("[[true], [], [false, [], [null]], null")); + + // Invalid, too many commas + EXPECT_FALSE(JSONReader::Read("[true,, null]")); + EXPECT_FALSE(JSONReader::Read("[true,, null]", JSON_ALLOW_TRAILING_COMMAS)); + + // Invalid, no commas + EXPECT_FALSE(JSONReader::Read("[true null]")); + + // Invalid, trailing comma + EXPECT_FALSE(JSONReader::Read("[true,]")); + } + + { + // Valid if we set |allow_trailing_comma| to true. + std::unique_ptr<ListValue> list = ListValue::From( + JSONReader::Read("[true,]", JSON_ALLOW_TRAILING_COMMAS)); + ASSERT_TRUE(list); + EXPECT_EQ(1U, list->GetSize()); + Value* tmp_value = nullptr; + ASSERT_TRUE(list->Get(0, &tmp_value)); + EXPECT_TRUE(tmp_value->IsType(Value::TYPE_BOOLEAN)); + bool bool_value = false; + EXPECT_TRUE(tmp_value->GetAsBoolean(&bool_value)); + EXPECT_TRUE(bool_value); + } + + { + // Don't allow empty elements, even if |allow_trailing_comma| is + // true. + EXPECT_FALSE(JSONReader::Read("[,]", JSON_ALLOW_TRAILING_COMMAS)); + EXPECT_FALSE(JSONReader::Read("[true,,]", JSON_ALLOW_TRAILING_COMMAS)); + EXPECT_FALSE(JSONReader::Read("[,true,]", JSON_ALLOW_TRAILING_COMMAS)); + EXPECT_FALSE(JSONReader::Read("[true,,false]", JSON_ALLOW_TRAILING_COMMAS)); + } + + { + // Test objects + std::unique_ptr<DictionaryValue> dict_val = + DictionaryValue::From(JSONReader::Read("{}")); + ASSERT_TRUE(dict_val); + + dict_val = DictionaryValue::From(JSONReader::Read( + "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\" }")); + ASSERT_TRUE(dict_val); + double double_val = 0.0; + EXPECT_TRUE(dict_val->GetDouble("number", &double_val)); + EXPECT_DOUBLE_EQ(9.87654321, double_val); + Value* null_val = nullptr; + ASSERT_TRUE(dict_val->Get("null", &null_val)); + EXPECT_TRUE(null_val->IsType(Value::TYPE_NULL)); + std::string str_val; + EXPECT_TRUE(dict_val->GetString("S", &str_val)); + EXPECT_EQ("str", str_val); + + std::unique_ptr<Value> root2 = JSONReader::Read( + "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", }", + JSON_ALLOW_TRAILING_COMMAS); + ASSERT_TRUE(root2); + EXPECT_TRUE(dict_val->Equals(root2.get())); + + // Test newline equivalence. + root2 = JSONReader::Read( + "{\n" + " \"number\":9.87654321,\n" + " \"null\":null,\n" + " \"\\x53\":\"str\",\n" + "}\n", + JSON_ALLOW_TRAILING_COMMAS); + ASSERT_TRUE(root2); + EXPECT_TRUE(dict_val->Equals(root2.get())); + + root2 = JSONReader::Read( + "{\r\n" + " \"number\":9.87654321,\r\n" + " \"null\":null,\r\n" + " \"\\x53\":\"str\",\r\n" + "}\r\n", + JSON_ALLOW_TRAILING_COMMAS); + ASSERT_TRUE(root2); + EXPECT_TRUE(dict_val->Equals(root2.get())); + } + + { + // Test nesting + std::unique_ptr<DictionaryValue> dict_val = + DictionaryValue::From(JSONReader::Read( + "{\"inner\":{\"array\":[true]},\"false\":false,\"d\":{}}")); + ASSERT_TRUE(dict_val); + DictionaryValue* inner_dict = nullptr; + ASSERT_TRUE(dict_val->GetDictionary("inner", &inner_dict)); + ListValue* inner_array = nullptr; + ASSERT_TRUE(inner_dict->GetList("array", &inner_array)); + EXPECT_EQ(1U, inner_array->GetSize()); + bool bool_value = true; + EXPECT_TRUE(dict_val->GetBoolean("false", &bool_value)); + EXPECT_FALSE(bool_value); + inner_dict = nullptr; + EXPECT_TRUE(dict_val->GetDictionary("d", &inner_dict)); + + std::unique_ptr<Value> root2 = JSONReader::Read( + "{\"inner\": {\"array\":[true] , },\"false\":false,\"d\":{},}", + JSON_ALLOW_TRAILING_COMMAS); + EXPECT_TRUE(dict_val->Equals(root2.get())); + } + + { + // Test keys with periods + std::unique_ptr<DictionaryValue> dict_val = DictionaryValue::From( + JSONReader::Read("{\"a.b\":3,\"c\":2,\"d.e.f\":{\"g.h.i.j\":1}}")); + ASSERT_TRUE(dict_val); + int integer_value = 0; + EXPECT_TRUE( + dict_val->GetIntegerWithoutPathExpansion("a.b", &integer_value)); + EXPECT_EQ(3, integer_value); + EXPECT_TRUE(dict_val->GetIntegerWithoutPathExpansion("c", &integer_value)); + EXPECT_EQ(2, integer_value); + DictionaryValue* inner_dict = nullptr; + ASSERT_TRUE( + dict_val->GetDictionaryWithoutPathExpansion("d.e.f", &inner_dict)); + EXPECT_EQ(1U, inner_dict->size()); + EXPECT_TRUE( + inner_dict->GetIntegerWithoutPathExpansion("g.h.i.j", &integer_value)); + EXPECT_EQ(1, integer_value); + + dict_val = + DictionaryValue::From(JSONReader::Read("{\"a\":{\"b\":2},\"a.b\":1}")); + ASSERT_TRUE(dict_val); + EXPECT_TRUE(dict_val->GetInteger("a.b", &integer_value)); + EXPECT_EQ(2, integer_value); + EXPECT_TRUE( + dict_val->GetIntegerWithoutPathExpansion("a.b", &integer_value)); + EXPECT_EQ(1, integer_value); + } + + { + // Invalid, no closing brace + EXPECT_FALSE(JSONReader::Read("{\"a\": true")); + + // Invalid, keys must be quoted + EXPECT_FALSE(JSONReader::Read("{foo:true}")); + + // Invalid, trailing comma + EXPECT_FALSE(JSONReader::Read("{\"a\":true,}")); + + // Invalid, too many commas + EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}")); + EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}", + JSON_ALLOW_TRAILING_COMMAS)); + + // Invalid, no separator + EXPECT_FALSE(JSONReader::Read("{\"a\" \"b\"}")); + + // Invalid, lone comma. + EXPECT_FALSE(JSONReader::Read("{,}")); + EXPECT_FALSE(JSONReader::Read("{,}", JSON_ALLOW_TRAILING_COMMAS)); + EXPECT_FALSE( + JSONReader::Read("{\"a\":true,,}", JSON_ALLOW_TRAILING_COMMAS)); + EXPECT_FALSE(JSONReader::Read("{,\"a\":true}", JSON_ALLOW_TRAILING_COMMAS)); + EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}", + JSON_ALLOW_TRAILING_COMMAS)); + } + + { + // Test stack overflow + std::string evil(1000000, '['); + evil.append(std::string(1000000, ']')); + EXPECT_FALSE(JSONReader::Read(evil)); + } + + { + // A few thousand adjacent lists is fine. + std::string not_evil("["); + not_evil.reserve(15010); + for (int i = 0; i < 5000; ++i) + not_evil.append("[],"); + not_evil.append("[]]"); + std::unique_ptr<ListValue> list = + ListValue::From(JSONReader::Read(not_evil)); + ASSERT_TRUE(list); + EXPECT_EQ(5001U, list->GetSize()); + } + + { + // Test utf8 encoded input + std::unique_ptr<Value> root = + JSONReader().ReadToValue("\"\xe7\xbd\x91\xe9\xa1\xb5\""); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); + std::string str_val; + EXPECT_TRUE(root->GetAsString(&str_val)); + EXPECT_EQ("\xE7\xBD\x91\xE9\xA1\xB5", str_val); + + std::unique_ptr<DictionaryValue> dict_val = + DictionaryValue::From(JSONReader().ReadToValue( + "{\"path\": \"/tmp/\xc3\xa0\xc3\xa8\xc3\xb2.png\"}")); + ASSERT_TRUE(dict_val); + EXPECT_TRUE(dict_val->GetString("path", &str_val)); + EXPECT_EQ("/tmp/\xC3\xA0\xC3\xA8\xC3\xB2.png", str_val); + } + + { + // Test invalid utf8 encoded input + EXPECT_FALSE(JSONReader().ReadToValue("\"345\xb0\xa1\xb0\xa2\"")); + EXPECT_FALSE(JSONReader().ReadToValue("\"123\xc0\x81\"")); + EXPECT_FALSE(JSONReader().ReadToValue("\"abc\xc0\xae\"")); + } + + { + // Test utf16 encoded strings. + std::unique_ptr<Value> root = JSONReader().ReadToValue("\"\\u20ac3,14\""); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); + std::string str_val; + EXPECT_TRUE(root->GetAsString(&str_val)); + EXPECT_EQ( + "\xe2\x82\xac" + "3,14", + str_val); + + root = JSONReader().ReadToValue("\"\\ud83d\\udca9\\ud83d\\udc6c\""); + ASSERT_TRUE(root); + EXPECT_TRUE(root->IsType(Value::TYPE_STRING)); + str_val.clear(); + EXPECT_TRUE(root->GetAsString(&str_val)); + EXPECT_EQ("\xf0\x9f\x92\xa9\xf0\x9f\x91\xac", str_val); + } + + { + // Test invalid utf16 strings. + const char* const cases[] = { + "\"\\u123\"", // Invalid scalar. + "\"\\ud83d\"", // Invalid scalar. + "\"\\u$%@!\"", // Invalid scalar. + "\"\\uzz89\"", // Invalid scalar. + "\"\\ud83d\\udca\"", // Invalid lower surrogate. + "\"\\ud83d\\ud83d\"", // Invalid lower surrogate. + "\"\\ud83foo\"", // No lower surrogate. + "\"\\ud83\\foo\"" // No lower surrogate. + }; + std::unique_ptr<Value> root; + for (size_t i = 0; i < arraysize(cases); ++i) { + root = JSONReader().ReadToValue(cases[i]); + EXPECT_FALSE(root) << cases[i]; + } + } + + { + // Test literal root objects. + std::unique_ptr<Value> root = JSONReader::Read("null"); + EXPECT_TRUE(root->IsType(Value::TYPE_NULL)); + + root = JSONReader::Read("true"); + ASSERT_TRUE(root); + bool bool_value; + EXPECT_TRUE(root->GetAsBoolean(&bool_value)); + EXPECT_TRUE(bool_value); + + root = JSONReader::Read("10"); + ASSERT_TRUE(root); + int integer_value; + EXPECT_TRUE(root->GetAsInteger(&integer_value)); + EXPECT_EQ(10, integer_value); + + root = JSONReader::Read("\"root\""); + ASSERT_TRUE(root); + std::string str_val; + EXPECT_TRUE(root->GetAsString(&str_val)); + EXPECT_EQ("root", str_val); + } } // Tests that the root of a JSON object can be deleted safely while its @@ -565,25 +589,25 @@ TEST(JSONReaderTest, StringOptimizations) { " ]" "}", JSON_DETACHABLE_CHILDREN); - ASSERT_TRUE(root.get()); + ASSERT_TRUE(root); - DictionaryValue* root_dict = NULL; + DictionaryValue* root_dict = nullptr; ASSERT_TRUE(root->GetAsDictionary(&root_dict)); - DictionaryValue* dict = NULL; - ListValue* list = NULL; + DictionaryValue* dict = nullptr; + ListValue* list = nullptr; ASSERT_TRUE(root_dict->GetDictionary("test", &dict)); ASSERT_TRUE(root_dict->GetList("list", &list)); - EXPECT_TRUE(dict->Remove("foo", &dict_literal_0)); - EXPECT_TRUE(dict->Remove("bar", &dict_literal_1)); - EXPECT_TRUE(dict->Remove("baz", &dict_string_0)); - EXPECT_TRUE(dict->Remove("moo", &dict_string_1)); + ASSERT_TRUE(dict->Remove("foo", &dict_literal_0)); + ASSERT_TRUE(dict->Remove("bar", &dict_literal_1)); + ASSERT_TRUE(dict->Remove("baz", &dict_string_0)); + ASSERT_TRUE(dict->Remove("moo", &dict_string_1)); ASSERT_EQ(2u, list->GetSize()); - EXPECT_TRUE(list->Remove(0, &list_value_0)); - EXPECT_TRUE(list->Remove(0, &list_value_1)); + ASSERT_TRUE(list->Remove(0, &list_value_0)); + ASSERT_TRUE(list->Remove(0, &list_value_1)); } bool b = false; @@ -612,19 +636,14 @@ TEST(JSONReaderTest, StringOptimizations) { // parser implementation against buffer overflow. Best run with DCHECKs so // that the one in NextChar fires. TEST(JSONReaderTest, InvalidSanity) { - const char* const invalid_json[] = { - "/* test *", - "{\"foo\"", - "{\"foo\":", - " [", - "\"\\u123g\"", - "{\n\"eh:\n}", + const char* const kInvalidJson[] = { + "/* test *", "{\"foo\"", "{\"foo\":", " [", "\"\\u123g\"", "{\n\"eh:\n}", }; - for (size_t i = 0; i < arraysize(invalid_json); ++i) { + for (size_t i = 0; i < arraysize(kInvalidJson); ++i) { JSONReader reader; - LOG(INFO) << "Sanity test " << i << ": <" << invalid_json[i] << ">"; - EXPECT_FALSE(reader.ReadToValue(invalid_json[i])); + LOG(INFO) << "Sanity test " << i << ": <" << kInvalidJson[i] << ">"; + EXPECT_FALSE(reader.ReadToValue(kInvalidJson[i])); EXPECT_NE(JSONReader::JSON_NO_ERROR, reader.error_code()); EXPECT_NE("", reader.GetErrorMessage()); } |