0

Add a flag to JSONReader to allow trailing commas.

Lots of unittests for this behavior.

BUG=1295713

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@51 0039d316-1c4b-4281-b951-d872f2087c98
This commit is contained in:
tc@google.com
2008-07-29 00:01:31 +00:00
parent 1b66f31cbe
commit e724599d3f
3 changed files with 185 additions and 85 deletions

@ -98,13 +98,17 @@ bool ReadHexDigits(JSONReader::Token& token, int digits) {
} // anonymous namespace
/* static */
bool JSONReader::Read(const std::string& json, Value** root) {
return JsonToValue(json, root, true);
bool JSONReader::Read(const std::string& json,
Value** root,
bool allow_trailing_comma) {
return JsonToValue(json, root, true, allow_trailing_comma);
}
/* static */
bool JSONReader::JsonToValue(const std::string& json, Value** root,
bool check_root) {
bool JSONReader::JsonToValue(const std::string& json,
Value** root,
bool check_root,
bool allow_trailing_comma) {
// Assume input is UTF8. The conversion from UTF8 to wstring removes null
// bytes for us (a good thing).
std::wstring json_wide(UTF8ToWide(json));
@ -119,7 +123,7 @@ bool JSONReader::JsonToValue(const std::string& json, Value** root,
++json_cstr;
}
JSONReader reader(json_cstr);
JSONReader reader(json_cstr, allow_trailing_comma);
Value* temp_root = NULL;
bool success = reader.BuildValue(&temp_root, check_root);
@ -135,8 +139,11 @@ bool JSONReader::JsonToValue(const std::string& json, Value** root,
return false;
}
JSONReader::JSONReader(const wchar_t* json_start_pos)
: json_pos_(json_start_pos), stack_depth_(0) {}
JSONReader::JSONReader(const wchar_t* json_start_pos,
bool allow_trailing_comma)
: json_pos_(json_start_pos),
stack_depth_(0),
allow_trailing_comma_(allow_trailing_comma) {}
bool JSONReader::BuildValue(Value** node, bool is_root) {
++stack_depth_;
@ -196,10 +203,15 @@ bool JSONReader::BuildValue(Value** node, bool is_root) {
if (token.type == Token::LIST_SEPARATOR) {
json_pos_ += token.length;
token = ParseToken();
// Trailing commas are invalid
// Trailing commas are invalid according to the JSON RFC, but some
// consumers need the parsing leniency, so handle accordingly.
if (token.type == Token::ARRAY_END) {
delete array;
return false;
if (!allow_trailing_comma_) {
delete array;
return false;
}
// Trailing comma OK, stop parsing the Array.
break;
}
} else if (token.type != Token::ARRAY_END) {
// Unexpected value after list value. Bail out.
@ -259,11 +271,15 @@ bool JSONReader::BuildValue(Value** node, bool is_root) {
if (token.type == Token::LIST_SEPARATOR) {
json_pos_ += token.length;
token = ParseToken();
// Trailing commas are invalid. TODO(tc): Should we allow trailing
// commas in objects? Seems harmless and quite convenient...
// Trailing commas are invalid according to the JSON RFC, but some
// consumers need the parsing leniency, so handle accordingly.
if (token.type == Token::OBJECT_END) {
delete dict;
return false;
if (!allow_trailing_comma_) {
delete dict;
return false;
}
// Trailing comma OK, stop parsing the Object.
break;
}
} else if (token.type != Token::OBJECT_END) {
// Unexpected value after last object value. Bail out.

@ -46,11 +46,11 @@
// character, the function skips a Unicode BOM at the beginning of the
// Unicode string (converted from the input UTF-8 string) before parsing it.
//
// TODO(tc): It would be nice to give back an error string when we fail to parse JSON.
// Parsing options:
// - Relax trailing commas in arrays and objects
// - Relax object keys being wrapped in double quotes
// - Disable comment stripping
// TODO(tc): It would be nice to give back an error string when we fail to
// parse JSON.
// TODO(tc): Add a parsing option to to relax object keys being wrapped in
// double quotes
// TODO(tc): Add an option to disable comment stripping
#ifndef CHROME_COMMON_JSON_READER_H__
#define CHROME_COMMON_JSON_READER_H__
@ -99,12 +99,16 @@ class JSONReader {
}
};
// Reads and parses |json| and populates |root|. If |json| is not a
// properly formed JSON string, returns false and leaves root unaltered.
static bool Read(const std::string& json, Value** root);
// Reads and parses |json| and populates |root|. If |json| is not a properly
// formed JSON string, returns false and leaves root unaltered. If
// allow_trailing_comma is true, we will ignore trailing commas in objects
// and arrays even though this goes against the RFC.
static bool Read(const std::string& json,
Value** root,
bool allow_trailing_comma);
private:
JSONReader(const wchar_t* json_start_pos);
JSONReader(const wchar_t* json_start_pos, bool allow_trailing_comma);
DISALLOW_EVIL_CONSTRUCTORS(JSONReader);
FRIEND_TEST(JSONReaderTest, Reading);
@ -112,7 +116,8 @@ class JSONReader {
// Pass through method from JSONReader::Read. We have this so unittests can
// disable the root check.
static bool JsonToValue(const std::string& json, Value** root,
bool check_root);
bool check_root,
bool allow_trailing_comma);
// Recursively build Value. Returns false if we don't have a valid JSON
// string. If |is_root| is true, we verify that the root element is either
@ -160,6 +165,9 @@ class JSONReader {
// Used to keep track of how many nested lists/dicts there are.
int stack_depth_;
// A parser flag that allows trailing commas in objects and arrays.
bool allow_trailing_comma_;
};
#endif // CHROME_COMMON_JSON_READER_H__

@ -34,26 +34,26 @@
TEST(JSONReaderTest, Reading) {
// some whitespace checking
Value* root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue(" null ", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue(" null ", &root, false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_NULL));
delete root;
// Invalid JSON string
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("nu", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("nu", &root, false, false));
ASSERT_FALSE(root);
// Simple bool
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("true ", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue("true ", &root, false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_BOOLEAN));
delete root;
// Test number formats
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("43", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue("43", &root, false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_INTEGER));
int int_val = 0;
@ -63,19 +63,19 @@ TEST(JSONReaderTest, Reading) {
// According to RFC4627, oct, hex, and leading zeros are invalid JSON.
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("043", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("043", &root, false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("0x43", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("0x43", &root, false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("00", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("00", &root, false, false));
ASSERT_FALSE(root);
// Test 0 (which needs to be special cased because of the leading zero
// clause).
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("0", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue("0", &root, false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_INTEGER));
int_val = 1;
@ -85,15 +85,15 @@ TEST(JSONReaderTest, Reading) {
// Numbers that overflow ints should fail
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("2147483648", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("2147483648", &root, false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("-2147483649", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("-2147483649", &root, false, false));
ASSERT_FALSE(root);
// Parse a double
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("43.1", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue("43.1", &root, false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_REAL));
double real_val = 0.0;
@ -102,7 +102,7 @@ TEST(JSONReaderTest, Reading) {
delete root;
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("4.3e-1", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue("4.3e-1", &root, false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_REAL));
real_val = 0.0;
@ -111,7 +111,7 @@ TEST(JSONReaderTest, Reading) {
delete root;
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("2.1e0", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue("2.1e0", &root, false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_REAL));
real_val = 0.0;
@ -120,7 +120,7 @@ TEST(JSONReaderTest, Reading) {
delete root;
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("2.1e+0001", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue("2.1e+0001", &root, false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_REAL));
real_val = 0.0;
@ -129,7 +129,7 @@ TEST(JSONReaderTest, Reading) {
delete root;
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("0.01", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue("0.01", &root, false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_REAL));
real_val = 0.0;
@ -138,7 +138,7 @@ TEST(JSONReaderTest, Reading) {
delete root;
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("1.00", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue("1.00", &root, false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_REAL));
real_val = 0.0;
@ -148,51 +148,51 @@ TEST(JSONReaderTest, Reading) {
// Fractional parts must have a digit before and after the decimal point.
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("1.", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("1.", &root, false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue(".1", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue(".1", &root, false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("1.e10", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("1.e10", &root, false, false));
ASSERT_FALSE(root);
// Exponent must have a digit following the 'e'.
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("1e", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("1e", &root, false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("1E", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("1E", &root, false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("1e1.", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("1e1.", &root, false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("1e1.0", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("1e1.0", &root, false, false));
ASSERT_FALSE(root);
// INF/-INF/NaN are not valid
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("1e1000", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("1e1000", &root, false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("-1e1000", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("-1e1000", &root, false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("NaN", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("NaN", &root, false, false));
ASSERT_FALSE(root);
// Invalid number formats
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("4.3.1", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("4.3.1", &root, false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("4e3.1", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("4e3.1", &root, false, false));
ASSERT_FALSE(root);
// Test string parser
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("\"hello world\"", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue("\"hello world\"", &root, false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_STRING));
std::wstring str_val;
@ -202,7 +202,7 @@ TEST(JSONReaderTest, Reading) {
// Empty string
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("\"\"", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue("\"\"", &root, false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_STRING));
str_val.clear();
@ -213,7 +213,7 @@ TEST(JSONReaderTest, Reading) {
// Test basic string escapes
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("\" \\\"\\\\\\/\\b\\f\\n\\r\\t\"", &root,
false));
false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_STRING));
str_val.clear();
@ -223,7 +223,8 @@ TEST(JSONReaderTest, Reading) {
// Test hex and unicode escapes including the null character.
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("\"\\x41\\x00\\u1234\"", &root, false));
ASSERT_TRUE(JSONReader::JsonToValue("\"\\x41\\x00\\u1234\"", &root, false,
false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_STRING));
str_val.clear();
@ -233,41 +234,48 @@ TEST(JSONReaderTest, Reading) {
// Test invalid strings
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("\"no closing quote", &root, false));
ASSERT_FALSE(JSONReader::JsonToValue("\"no closing quote", &root, false,
false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("\"\\z invalid escape char\"", &root,
false));
false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("\"\\xAQ invalid hex code\"", &root,
false));
false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("not enough hex chars\\x1\"", &root,
false));
false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("\"not enough escape chars\\u123\"",
&root, false));
&root, false, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::JsonToValue("\"extra backslash at end of input\\\"",
&root, false));
&root, false, false));
ASSERT_FALSE(root);
// Basic array
root = NULL;
ASSERT_TRUE(JSONReader::Read("[true, false, null]", &root));
ASSERT_TRUE(JSONReader::Read("[true, false, null]", &root, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_LIST));
ListValue* list = static_cast<ListValue*>(root);
ASSERT_EQ(3, list->GetSize());
// Test with trailing comma. Should be parsed the same as above.
Value* root2 = NULL;
ASSERT_TRUE(JSONReader::Read("[true, false, null, ]", &root2, true));
EXPECT_TRUE(root->Equals(root2));
delete root;
delete root2;
// Empty array
root = NULL;
ASSERT_TRUE(JSONReader::Read("[]", &root));
ASSERT_TRUE(JSONReader::Read("[]", &root, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_LIST));
list = static_cast<ListValue*>(root);
@ -276,43 +284,81 @@ TEST(JSONReaderTest, Reading) {
// Nested arrays
root = NULL;
ASSERT_TRUE(JSONReader::Read("[[true], [], [false, [], [null]], null]", &root));
ASSERT_TRUE(JSONReader::Read("[[true], [], [false, [], [null]], null]", &root,
false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_LIST));
list = static_cast<ListValue*>(root);
ASSERT_EQ(4, list->GetSize());
// Lots of trailing commas.
root2 = NULL;
ASSERT_TRUE(JSONReader::Read("[[true], [], [false, [], [null, ] , ], null,]",
&root2, true));
EXPECT_TRUE(root->Equals(root2));
delete root;
delete root2;
// Invalid, missing close brace.
root = NULL;
ASSERT_FALSE(JSONReader::Read("[[true], [], [false, [], [null]], null", &root));
ASSERT_FALSE(JSONReader::Read("[[true], [], [false, [], [null]], null", &root,
false));
ASSERT_FALSE(root);
// Invalid, too many commas
root = NULL;
ASSERT_FALSE(JSONReader::Read("[true,, null]", &root));
ASSERT_FALSE(JSONReader::Read("[true,, null]", &root, false));
ASSERT_FALSE(root);
ASSERT_FALSE(JSONReader::Read("[true,, null]", &root, true));
ASSERT_FALSE(root);
// Invalid, no commas
root = NULL;
ASSERT_FALSE(JSONReader::Read("[true null]", &root));
ASSERT_FALSE(JSONReader::Read("[true null]", &root, false));
ASSERT_FALSE(root);
// Invalid, trailing comma
root = NULL;
ASSERT_FALSE(JSONReader::Read("[true,]", &root));
ASSERT_FALSE(JSONReader::Read("[true,]", &root, false));
ASSERT_FALSE(root);
// Valid if we set |allow_trailing_comma| to true.
EXPECT_TRUE(JSONReader::Read("[true,]", &root, true));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_LIST));
list = static_cast<ListValue*>(root);
EXPECT_EQ(1, 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;
ASSERT_TRUE(tmp_value->GetAsBoolean(&bool_value));
EXPECT_TRUE(bool_value);
delete root;
// Don't allow empty elements, even if |allow_trailing_comma| is
// true.
root = NULL;
EXPECT_FALSE(JSONReader::Read("[,]", &root, true));
EXPECT_FALSE(root);
EXPECT_FALSE(JSONReader::Read("[true,,]", &root, true));
EXPECT_FALSE(root);
EXPECT_FALSE(JSONReader::Read("[,true,]", &root, true));
EXPECT_FALSE(root);
EXPECT_FALSE(JSONReader::Read("[true,,false]", &root, true));
EXPECT_FALSE(root);
// Test objects
root = NULL;
ASSERT_TRUE(JSONReader::Read("{}", &root));
ASSERT_TRUE(JSONReader::Read("{}", &root, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_DICTIONARY));
delete root;
root = NULL;
ASSERT_TRUE(JSONReader::Read(
"{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\" }", &root));
"{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\" }", &root,
false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_DICTIONARY));
DictionaryValue* dict_val = static_cast<DictionaryValue*>(root);
@ -325,12 +371,19 @@ TEST(JSONReaderTest, Reading) {
str_val.clear();
ASSERT_TRUE(dict_val->GetString(L"S", &str_val));
ASSERT_EQ(L"str", str_val);
root2 = NULL;
ASSERT_TRUE(JSONReader::Read(
"{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", }", &root2,
true));
EXPECT_TRUE(root->Equals(root2));
delete root;
delete root2;
// Test nesting
root = NULL;
ASSERT_TRUE(JSONReader::Read(
"{\"inner\":{\"array\":[true]},\"false\":false,\"d\":{}}", &root));
"{\"inner\":{\"array\":[true]},\"false\":false,\"d\":{}}", &root, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_DICTIONARY));
dict_val = static_cast<DictionaryValue*>(root);
@ -339,43 +392,66 @@ TEST(JSONReaderTest, Reading) {
ListValue* inner_array = NULL;
ASSERT_TRUE(inner_dict->GetList(L"array", &inner_array));
ASSERT_EQ(1, inner_array->GetSize());
bool bool_value = true;
bool_value = true;
ASSERT_TRUE(dict_val->GetBoolean(L"false", &bool_value));
ASSERT_FALSE(bool_value);
inner_dict = NULL;
ASSERT_TRUE(dict_val->GetDictionary(L"d", &inner_dict));
root2 = NULL;
ASSERT_TRUE(JSONReader::Read(
"{\"inner\": {\"array\":[true] , },\"false\":false,\"d\":{},}", &root2,
true));
EXPECT_TRUE(root->Equals(root2));
delete root;
delete root2;
// Invalid, no closing brace
root = NULL;
ASSERT_FALSE(JSONReader::Read("{\"a\": true", &root));
ASSERT_FALSE(JSONReader::Read("{\"a\": true", &root, false));
ASSERT_FALSE(root);
// Invalid, keys must be quoted
root = NULL;
ASSERT_FALSE(JSONReader::Read("{foo:true}", &root));
ASSERT_FALSE(JSONReader::Read("{foo:true}", &root, false));
ASSERT_FALSE(root);
// Invalid, trailing comma
root = NULL;
ASSERT_FALSE(JSONReader::Read("{\"a\":true,}", &root));
ASSERT_FALSE(JSONReader::Read("{\"a\":true,}", &root, false));
ASSERT_FALSE(root);
// Invalid, too many commas
root = NULL;
ASSERT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}", &root));
ASSERT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}", &root, false));
ASSERT_FALSE(root);
root = NULL;
ASSERT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}", &root, true));
ASSERT_FALSE(root);
// Invalid, no separator
root = NULL;
ASSERT_FALSE(JSONReader::Read("{\"a\" \"b\"}", &root));
ASSERT_FALSE(JSONReader::Read("{\"a\" \"b\"}", &root, false));
ASSERT_FALSE(root);
// Invalid, lone comma.
root = NULL;
ASSERT_FALSE(JSONReader::Read("{,}", &root, false));
ASSERT_FALSE(root);
ASSERT_FALSE(JSONReader::Read("{,}", &root, true));
ASSERT_FALSE(root);
ASSERT_FALSE(JSONReader::Read("{\"a\":true,,}", &root, true));
ASSERT_FALSE(root);
ASSERT_FALSE(JSONReader::Read("{,\"a\":true}", &root, true));
ASSERT_FALSE(root);
ASSERT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}", &root, true));
ASSERT_FALSE(root);
// Test stack overflow
root = NULL;
std::string evil(1000000, '[');
evil.append(std::string(1000000, ']'));
ASSERT_FALSE(JSONReader::Read(evil, &root));
ASSERT_FALSE(JSONReader::Read(evil, &root, false));
ASSERT_FALSE(root);
// A few thousand adjacent lists is fine.
@ -385,7 +461,7 @@ TEST(JSONReaderTest, Reading) {
not_evil.append("[],");
}
not_evil.append("[]]");
ASSERT_TRUE(JSONReader::Read(not_evil, &root));
ASSERT_TRUE(JSONReader::Read(not_evil, &root, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_LIST));
list = static_cast<ListValue*>(root);
@ -395,7 +471,7 @@ TEST(JSONReaderTest, Reading) {
// Test utf8 encoded input
root = NULL;
ASSERT_TRUE(JSONReader::JsonToValue("\"\xe7\xbd\x91\xe9\xa1\xb5\"", &root,
false));
false, false));
ASSERT_TRUE(root);
ASSERT_TRUE(root->IsType(Value::TYPE_STRING));
str_val.clear();
@ -405,8 +481,8 @@ TEST(JSONReaderTest, Reading) {
// Test invalid root objects.
root = NULL;
ASSERT_FALSE(JSONReader::Read("null", &root));
ASSERT_FALSE(JSONReader::Read("true", &root));
ASSERT_FALSE(JSONReader::Read("10", &root));
ASSERT_FALSE(JSONReader::Read("\"root\"", &root));
ASSERT_FALSE(JSONReader::Read("null", &root, false));
ASSERT_FALSE(JSONReader::Read("true", &root, false));
ASSERT_FALSE(JSONReader::Read("10", &root, false));
ASSERT_FALSE(JSONReader::Read("\"root\"", &root, false));
}