You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
463 lines
14 KiB
463 lines
14 KiB
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "base/json/json_parser.h"
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <memory>
|
|
|
|
#include "base/json/json_reader.h"
|
|
#include "base/memory/ptr_util.h"
|
|
#include "base/optional.h"
|
|
#include "base/strings/stringprintf.h"
|
|
#include "base/values.h"
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
|
|
namespace base {
|
|
namespace internal {
|
|
|
|
class JSONParserTest : public testing::Test {
|
|
public:
|
|
JSONParser* NewTestParser(const std::string& input,
|
|
int options = JSON_PARSE_RFC) {
|
|
JSONParser* parser = new JSONParser(options);
|
|
parser->input_ = input;
|
|
parser->index_ = 0;
|
|
return parser;
|
|
}
|
|
|
|
// MSan will do a better job detecting over-read errors if the input is
|
|
// not nul-terminated on the heap. This will copy |input| to a new buffer
|
|
// owned by |owner|, returning a StringPiece to |owner|.
|
|
StringPiece MakeNotNullTerminatedInput(const char* input,
|
|
std::unique_ptr<char[]>* owner) {
|
|
size_t str_len = strlen(input);
|
|
owner->reset(new char[str_len]);
|
|
memcpy(owner->get(), input, str_len);
|
|
return StringPiece(owner->get(), str_len);
|
|
}
|
|
|
|
void TestLastThree(JSONParser* parser) {
|
|
EXPECT_EQ(',', *parser->PeekChar());
|
|
parser->ConsumeChar();
|
|
EXPECT_EQ('|', *parser->PeekChar());
|
|
parser->ConsumeChar();
|
|
EXPECT_EQ('\0', *parser->pos());
|
|
EXPECT_EQ(static_cast<size_t>(parser->index_), parser->input_.length());
|
|
}
|
|
};
|
|
|
|
TEST_F(JSONParserTest, NextChar) {
|
|
std::string input("Hello world");
|
|
std::unique_ptr<JSONParser> parser(NewTestParser(input));
|
|
|
|
EXPECT_EQ('H', *parser->pos());
|
|
for (size_t i = 1; i < input.length(); ++i) {
|
|
parser->ConsumeChar();
|
|
EXPECT_EQ(input[i], *parser->PeekChar());
|
|
}
|
|
parser->ConsumeChar();
|
|
EXPECT_EQ('\0', *parser->pos());
|
|
EXPECT_EQ(static_cast<size_t>(parser->index_), parser->input_.length());
|
|
}
|
|
|
|
TEST_F(JSONParserTest, ConsumeString) {
|
|
std::string input("\"test\",|");
|
|
std::unique_ptr<JSONParser> parser(NewTestParser(input));
|
|
Optional<Value> value(parser->ConsumeString());
|
|
EXPECT_EQ(',', *parser->pos());
|
|
|
|
TestLastThree(parser.get());
|
|
|
|
ASSERT_TRUE(value);
|
|
std::string str;
|
|
EXPECT_TRUE(value->GetAsString(&str));
|
|
EXPECT_EQ("test", str);
|
|
}
|
|
|
|
TEST_F(JSONParserTest, ConsumeList) {
|
|
std::string input("[true, false],|");
|
|
std::unique_ptr<JSONParser> parser(NewTestParser(input));
|
|
Optional<Value> value(parser->ConsumeList());
|
|
EXPECT_EQ(',', *parser->pos());
|
|
|
|
TestLastThree(parser.get());
|
|
|
|
ASSERT_TRUE(value);
|
|
base::ListValue* list;
|
|
EXPECT_TRUE(value->GetAsList(&list));
|
|
EXPECT_EQ(2u, list->GetSize());
|
|
}
|
|
|
|
TEST_F(JSONParserTest, ConsumeDictionary) {
|
|
std::string input("{\"abc\":\"def\"},|");
|
|
std::unique_ptr<JSONParser> parser(NewTestParser(input));
|
|
Optional<Value> value(parser->ConsumeDictionary());
|
|
EXPECT_EQ(',', *parser->pos());
|
|
|
|
TestLastThree(parser.get());
|
|
|
|
ASSERT_TRUE(value);
|
|
base::DictionaryValue* dict;
|
|
EXPECT_TRUE(value->GetAsDictionary(&dict));
|
|
std::string str;
|
|
EXPECT_TRUE(dict->GetString("abc", &str));
|
|
EXPECT_EQ("def", str);
|
|
}
|
|
|
|
TEST_F(JSONParserTest, ConsumeLiterals) {
|
|
// Literal |true|.
|
|
std::string input("true,|");
|
|
std::unique_ptr<JSONParser> parser(NewTestParser(input));
|
|
Optional<Value> value(parser->ConsumeLiteral());
|
|
EXPECT_EQ(',', *parser->pos());
|
|
|
|
TestLastThree(parser.get());
|
|
|
|
ASSERT_TRUE(value);
|
|
bool bool_value = false;
|
|
EXPECT_TRUE(value->GetAsBoolean(&bool_value));
|
|
EXPECT_TRUE(bool_value);
|
|
|
|
// Literal |false|.
|
|
input = "false,|";
|
|
parser.reset(NewTestParser(input));
|
|
value = parser->ConsumeLiteral();
|
|
EXPECT_EQ(',', *parser->pos());
|
|
|
|
TestLastThree(parser.get());
|
|
|
|
ASSERT_TRUE(value);
|
|
EXPECT_TRUE(value->GetAsBoolean(&bool_value));
|
|
EXPECT_FALSE(bool_value);
|
|
|
|
// Literal |null|.
|
|
input = "null,|";
|
|
parser.reset(NewTestParser(input));
|
|
value = parser->ConsumeLiteral();
|
|
EXPECT_EQ(',', *parser->pos());
|
|
|
|
TestLastThree(parser.get());
|
|
|
|
ASSERT_TRUE(value);
|
|
EXPECT_TRUE(value->is_none());
|
|
}
|
|
|
|
TEST_F(JSONParserTest, ConsumeNumbers) {
|
|
// Integer.
|
|
std::string input("1234,|");
|
|
std::unique_ptr<JSONParser> parser(NewTestParser(input));
|
|
Optional<Value> value(parser->ConsumeNumber());
|
|
EXPECT_EQ(',', *parser->pos());
|
|
|
|
TestLastThree(parser.get());
|
|
|
|
ASSERT_TRUE(value);
|
|
int number_i;
|
|
EXPECT_TRUE(value->GetAsInteger(&number_i));
|
|
EXPECT_EQ(1234, number_i);
|
|
|
|
// Negative integer.
|
|
input = "-1234,|";
|
|
parser.reset(NewTestParser(input));
|
|
value = parser->ConsumeNumber();
|
|
EXPECT_EQ(',', *parser->pos());
|
|
|
|
TestLastThree(parser.get());
|
|
|
|
ASSERT_TRUE(value);
|
|
EXPECT_TRUE(value->GetAsInteger(&number_i));
|
|
EXPECT_EQ(-1234, number_i);
|
|
|
|
// Double.
|
|
input = "12.34,|";
|
|
parser.reset(NewTestParser(input));
|
|
value = parser->ConsumeNumber();
|
|
EXPECT_EQ(',', *parser->pos());
|
|
|
|
TestLastThree(parser.get());
|
|
|
|
ASSERT_TRUE(value);
|
|
double number_d;
|
|
EXPECT_TRUE(value->GetAsDouble(&number_d));
|
|
EXPECT_EQ(12.34, number_d);
|
|
|
|
// Scientific.
|
|
input = "42e3,|";
|
|
parser.reset(NewTestParser(input));
|
|
value = parser->ConsumeNumber();
|
|
EXPECT_EQ(',', *parser->pos());
|
|
|
|
TestLastThree(parser.get());
|
|
|
|
ASSERT_TRUE(value);
|
|
EXPECT_TRUE(value->GetAsDouble(&number_d));
|
|
EXPECT_EQ(42000, number_d);
|
|
|
|
// Negative scientific.
|
|
input = "314159e-5,|";
|
|
parser.reset(NewTestParser(input));
|
|
value = parser->ConsumeNumber();
|
|
EXPECT_EQ(',', *parser->pos());
|
|
|
|
TestLastThree(parser.get());
|
|
|
|
ASSERT_TRUE(value);
|
|
EXPECT_TRUE(value->GetAsDouble(&number_d));
|
|
EXPECT_EQ(3.14159, number_d);
|
|
|
|
// Positive scientific.
|
|
input = "0.42e+3,|";
|
|
parser.reset(NewTestParser(input));
|
|
value = parser->ConsumeNumber();
|
|
EXPECT_EQ(',', *parser->pos());
|
|
|
|
TestLastThree(parser.get());
|
|
|
|
ASSERT_TRUE(value);
|
|
EXPECT_TRUE(value->GetAsDouble(&number_d));
|
|
EXPECT_EQ(420, number_d);
|
|
}
|
|
|
|
TEST_F(JSONParserTest, ErrorMessages) {
|
|
// Error strings should not be modified in case of success.
|
|
std::string error_message;
|
|
int error_code = 0;
|
|
std::unique_ptr<Value> root = JSONReader::ReadAndReturnError(
|
|
"[42]", JSON_PARSE_RFC, &error_code, &error_message);
|
|
EXPECT_TRUE(error_message.empty());
|
|
EXPECT_EQ(0, error_code);
|
|
|
|
// Test line and column counting
|
|
const char big_json[] = "[\n0,\n1,\n2,\n3,4,5,6 7,\n8,\n9\n]";
|
|
// error here ----------------------------------^
|
|
root = JSONReader::ReadAndReturnError(big_json, JSON_PARSE_RFC, &error_code,
|
|
&error_message);
|
|
EXPECT_FALSE(root.get());
|
|
EXPECT_EQ(JSONParser::FormatErrorMessage(5, 10, JSONReader::kSyntaxError),
|
|
error_message);
|
|
EXPECT_EQ(JSONReader::JSON_SYNTAX_ERROR, error_code);
|
|
|
|
error_code = 0;
|
|
error_message = "";
|
|
// Test line and column counting with "\r\n" line ending
|
|
const char big_json_crlf[] =
|
|
"[\r\n0,\r\n1,\r\n2,\r\n3,4,5,6 7,\r\n8,\r\n9\r\n]";
|
|
// error here ----------------------^
|
|
root = JSONReader::ReadAndReturnError(big_json_crlf, JSON_PARSE_RFC,
|
|
&error_code, &error_message);
|
|
EXPECT_FALSE(root.get());
|
|
EXPECT_EQ(JSONParser::FormatErrorMessage(5, 10, JSONReader::kSyntaxError),
|
|
error_message);
|
|
EXPECT_EQ(JSONReader::JSON_SYNTAX_ERROR, error_code);
|
|
|
|
// Test each of the error conditions
|
|
root = JSONReader::ReadAndReturnError("{},{}", JSON_PARSE_RFC, &error_code,
|
|
&error_message);
|
|
EXPECT_FALSE(root.get());
|
|
EXPECT_EQ(JSONParser::FormatErrorMessage(1, 3,
|
|
JSONReader::kUnexpectedDataAfterRoot), error_message);
|
|
EXPECT_EQ(JSONReader::JSON_UNEXPECTED_DATA_AFTER_ROOT, error_code);
|
|
|
|
std::string nested_json;
|
|
for (int i = 0; i < 201; ++i) {
|
|
nested_json.insert(nested_json.begin(), '[');
|
|
nested_json.append(1, ']');
|
|
}
|
|
root = JSONReader::ReadAndReturnError(nested_json, JSON_PARSE_RFC,
|
|
&error_code, &error_message);
|
|
EXPECT_FALSE(root.get());
|
|
EXPECT_EQ(JSONParser::FormatErrorMessage(1, 200, JSONReader::kTooMuchNesting),
|
|
error_message);
|
|
EXPECT_EQ(JSONReader::JSON_TOO_MUCH_NESTING, error_code);
|
|
|
|
root = JSONReader::ReadAndReturnError("[1,]", JSON_PARSE_RFC, &error_code,
|
|
&error_message);
|
|
EXPECT_FALSE(root.get());
|
|
EXPECT_EQ(JSONParser::FormatErrorMessage(1, 4, JSONReader::kTrailingComma),
|
|
error_message);
|
|
EXPECT_EQ(JSONReader::JSON_TRAILING_COMMA, error_code);
|
|
|
|
root = JSONReader::ReadAndReturnError("{foo:\"bar\"}", JSON_PARSE_RFC,
|
|
&error_code, &error_message);
|
|
EXPECT_FALSE(root.get());
|
|
EXPECT_EQ(JSONParser::FormatErrorMessage(1, 2,
|
|
JSONReader::kUnquotedDictionaryKey), error_message);
|
|
EXPECT_EQ(JSONReader::JSON_UNQUOTED_DICTIONARY_KEY, error_code);
|
|
|
|
root = JSONReader::ReadAndReturnError("{\"foo\":\"bar\",}", JSON_PARSE_RFC,
|
|
&error_code, &error_message);
|
|
EXPECT_FALSE(root.get());
|
|
EXPECT_EQ(JSONParser::FormatErrorMessage(1, 14, JSONReader::kTrailingComma),
|
|
error_message);
|
|
|
|
root = JSONReader::ReadAndReturnError("[nu]", JSON_PARSE_RFC, &error_code,
|
|
&error_message);
|
|
EXPECT_FALSE(root.get());
|
|
EXPECT_EQ(JSONParser::FormatErrorMessage(1, 2, JSONReader::kSyntaxError),
|
|
error_message);
|
|
EXPECT_EQ(JSONReader::JSON_SYNTAX_ERROR, error_code);
|
|
|
|
root = JSONReader::ReadAndReturnError("[\"xxx\\xq\"]", JSON_PARSE_RFC,
|
|
&error_code, &error_message);
|
|
EXPECT_FALSE(root.get());
|
|
EXPECT_EQ(JSONParser::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape),
|
|
error_message);
|
|
EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code);
|
|
|
|
root = JSONReader::ReadAndReturnError("[\"xxx\\uq\"]", JSON_PARSE_RFC,
|
|
&error_code, &error_message);
|
|
EXPECT_FALSE(root.get());
|
|
EXPECT_EQ(JSONParser::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape),
|
|
error_message);
|
|
EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code);
|
|
|
|
root = JSONReader::ReadAndReturnError("[\"xxx\\q\"]", JSON_PARSE_RFC,
|
|
&error_code, &error_message);
|
|
EXPECT_FALSE(root.get());
|
|
EXPECT_EQ(JSONParser::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape),
|
|
error_message);
|
|
EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code);
|
|
|
|
root = JSONReader::ReadAndReturnError(("[\"\\ufffe\"]"), JSON_PARSE_RFC,
|
|
&error_code, &error_message);
|
|
EXPECT_EQ(JSONParser::FormatErrorMessage(1, 8, JSONReader::kInvalidEscape),
|
|
error_message);
|
|
EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code);
|
|
}
|
|
|
|
TEST_F(JSONParserTest, Decode4ByteUtf8Char) {
|
|
// This test strings contains a 4 byte unicode character (a smiley!) that the
|
|
// reader should be able to handle (the character is \xf0\x9f\x98\x87).
|
|
const char kUtf8Data[] =
|
|
"[\"😇\",[],[],[],{\"google:suggesttype\":[]}]";
|
|
std::string error_message;
|
|
int error_code = 0;
|
|
std::unique_ptr<Value> root = JSONReader::ReadAndReturnError(
|
|
kUtf8Data, JSON_PARSE_RFC, &error_code, &error_message);
|
|
EXPECT_TRUE(root.get()) << error_message;
|
|
}
|
|
|
|
TEST_F(JSONParserTest, DecodeUnicodeNonCharacter) {
|
|
// Tests Unicode code points (encoded as escaped UTF-16) that are not valid
|
|
// characters.
|
|
EXPECT_FALSE(JSONReader::Read("[\"\\ufdd0\"]"));
|
|
EXPECT_FALSE(JSONReader::Read("[\"\\ufffe\"]"));
|
|
EXPECT_FALSE(JSONReader::Read("[\"\\ud83f\\udffe\"]"));
|
|
|
|
EXPECT_TRUE(
|
|
JSONReader::Read("[\"\\ufdd0\"]", JSON_REPLACE_INVALID_CHARACTERS));
|
|
EXPECT_TRUE(
|
|
JSONReader::Read("[\"\\ufffe\"]", JSON_REPLACE_INVALID_CHARACTERS));
|
|
}
|
|
|
|
TEST_F(JSONParserTest, DecodeNegativeEscapeSequence) {
|
|
EXPECT_FALSE(JSONReader::Read("[\"\\x-A\"]"));
|
|
EXPECT_FALSE(JSONReader::Read("[\"\\u-00A\"]"));
|
|
}
|
|
|
|
// Verifies invalid utf-8 characters are replaced.
|
|
TEST_F(JSONParserTest, ReplaceInvalidCharacters) {
|
|
const std::string bogus_char = "";
|
|
const std::string quoted_bogus_char = "\"" + bogus_char + "\"";
|
|
std::unique_ptr<JSONParser> parser(
|
|
NewTestParser(quoted_bogus_char, JSON_REPLACE_INVALID_CHARACTERS));
|
|
Optional<Value> value(parser->ConsumeString());
|
|
ASSERT_TRUE(value);
|
|
std::string str;
|
|
EXPECT_TRUE(value->GetAsString(&str));
|
|
EXPECT_EQ(kUnicodeReplacementString, str);
|
|
}
|
|
|
|
TEST_F(JSONParserTest, ReplaceInvalidUTF16EscapeSequence) {
|
|
const std::string invalid = "\"\\ufffe\"";
|
|
std::unique_ptr<JSONParser> parser(
|
|
NewTestParser(invalid, JSON_REPLACE_INVALID_CHARACTERS));
|
|
Optional<Value> value(parser->ConsumeString());
|
|
ASSERT_TRUE(value);
|
|
std::string str;
|
|
EXPECT_TRUE(value->GetAsString(&str));
|
|
EXPECT_EQ(kUnicodeReplacementString, str);
|
|
}
|
|
|
|
TEST_F(JSONParserTest, ParseNumberErrors) {
|
|
const struct {
|
|
const char* input;
|
|
bool parse_success;
|
|
double value;
|
|
} kCases[] = {
|
|
// clang-format off
|
|
{"1", true, 1},
|
|
{"2.", false, 0},
|
|
{"42", true, 42},
|
|
{"6e", false, 0},
|
|
{"43e2", true, 4300},
|
|
{"43e-", false, 0},
|
|
{"9e-3", true, 0.009},
|
|
{"2e+", false, 0},
|
|
{"2e+2", true, 200},
|
|
// clang-format on
|
|
};
|
|
|
|
for (unsigned int i = 0; i < arraysize(kCases); ++i) {
|
|
auto test_case = kCases[i];
|
|
SCOPED_TRACE(StringPrintf("case %u: \"%s\"", i, test_case.input));
|
|
|
|
std::unique_ptr<char[]> input_owner;
|
|
StringPiece input =
|
|
MakeNotNullTerminatedInput(test_case.input, &input_owner);
|
|
|
|
std::unique_ptr<Value> result = JSONReader::Read(input);
|
|
if (test_case.parse_success) {
|
|
EXPECT_TRUE(result);
|
|
} else {
|
|
EXPECT_FALSE(result);
|
|
}
|
|
|
|
if (!result)
|
|
continue;
|
|
|
|
double double_value = 0;
|
|
EXPECT_TRUE(result->GetAsDouble(&double_value));
|
|
EXPECT_EQ(test_case.value, double_value);
|
|
}
|
|
}
|
|
|
|
TEST_F(JSONParserTest, UnterminatedInputs) {
|
|
const char* kCases[] = {
|
|
// clang-format off
|
|
"/",
|
|
"//",
|
|
"/*",
|
|
"\"xxxxxx",
|
|
"\"",
|
|
"{ ",
|
|
"[\t",
|
|
"tru",
|
|
"fals",
|
|
"nul",
|
|
"\"\\x",
|
|
"\"\\x2",
|
|
"\"\\u123",
|
|
"\"\\uD803\\u",
|
|
"\"\\",
|
|
"\"\\/",
|
|
// clang-format on
|
|
};
|
|
|
|
for (unsigned int i = 0; i < arraysize(kCases); ++i) {
|
|
auto* test_case = kCases[i];
|
|
SCOPED_TRACE(StringPrintf("case %u: \"%s\"", i, test_case));
|
|
|
|
std::unique_ptr<char[]> input_owner;
|
|
StringPiece input = MakeNotNullTerminatedInput(test_case, &input_owner);
|
|
|
|
EXPECT_FALSE(JSONReader::Read(input));
|
|
}
|
|
}
|
|
|
|
} // namespace internal
|
|
} // namespace base
|