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_parser.h" 6 7 #include <stddef.h> 8 9 #include "base/json/json_reader.h" 10 #include "base/memory/scoped_ptr.h" 11 #include "base/values.h" 12 #include "testing/gtest/include/gtest/gtest.h" 13 14 namespace base { 15 namespace internal { 16 17 class JSONParserTest : public testing::Test { 18 public: 19 JSONParser* NewTestParser(const std::string& input) { 20 JSONParser* parser = new JSONParser(JSON_PARSE_RFC); 21 parser->start_pos_ = input.data(); 22 parser->pos_ = parser->start_pos_; 23 parser->end_pos_ = parser->start_pos_ + input.length(); 24 return parser; 25 } 26 27 void TestLastThree(JSONParser* parser) { 28 EXPECT_EQ(',', *parser->NextChar()); 29 EXPECT_EQ('|', *parser->NextChar()); 30 EXPECT_EQ('\0', *parser->NextChar()); 31 EXPECT_EQ(parser->end_pos_, parser->pos_); 32 } 33 }; 34 35 TEST_F(JSONParserTest, NextChar) { 36 std::string input("Hello world"); 37 scoped_ptr<JSONParser> parser(NewTestParser(input)); 38 39 EXPECT_EQ('H', *parser->pos_); 40 for (size_t i = 1; i < input.length(); ++i) { 41 EXPECT_EQ(input[i], *parser->NextChar()); 42 } 43 EXPECT_EQ(parser->end_pos_, parser->NextChar()); 44 } 45 46 TEST_F(JSONParserTest, ConsumeString) { 47 std::string input("\"test\",|"); 48 scoped_ptr<JSONParser> parser(NewTestParser(input)); 49 scoped_ptr<Value> value(parser->ConsumeString()); 50 EXPECT_EQ('"', *parser->pos_); 51 52 TestLastThree(parser.get()); 53 54 ASSERT_TRUE(value.get()); 55 std::string str; 56 EXPECT_TRUE(value->GetAsString(&str)); 57 EXPECT_EQ("test", str); 58 } 59 60 TEST_F(JSONParserTest, ConsumeList) { 61 std::string input("[true, false],|"); 62 scoped_ptr<JSONParser> parser(NewTestParser(input)); 63 scoped_ptr<Value> value(parser->ConsumeList()); 64 EXPECT_EQ(']', *parser->pos_); 65 66 TestLastThree(parser.get()); 67 68 ASSERT_TRUE(value.get()); 69 base::ListValue* list; 70 EXPECT_TRUE(value->GetAsList(&list)); 71 EXPECT_EQ(2u, list->GetSize()); 72 } 73 74 TEST_F(JSONParserTest, ConsumeDictionary) { 75 std::string input("{\"abc\":\"def\"},|"); 76 scoped_ptr<JSONParser> parser(NewTestParser(input)); 77 scoped_ptr<Value> value(parser->ConsumeDictionary()); 78 EXPECT_EQ('}', *parser->pos_); 79 80 TestLastThree(parser.get()); 81 82 ASSERT_TRUE(value.get()); 83 base::DictionaryValue* dict; 84 EXPECT_TRUE(value->GetAsDictionary(&dict)); 85 std::string str; 86 EXPECT_TRUE(dict->GetString("abc", &str)); 87 EXPECT_EQ("def", str); 88 } 89 90 TEST_F(JSONParserTest, ConsumeLiterals) { 91 // Literal |true|. 92 std::string input("true,|"); 93 scoped_ptr<JSONParser> parser(NewTestParser(input)); 94 scoped_ptr<Value> value(parser->ConsumeLiteral()); 95 EXPECT_EQ('e', *parser->pos_); 96 97 TestLastThree(parser.get()); 98 99 ASSERT_TRUE(value.get()); 100 bool bool_value = false; 101 EXPECT_TRUE(value->GetAsBoolean(&bool_value)); 102 EXPECT_TRUE(bool_value); 103 104 // Literal |false|. 105 input = "false,|"; 106 parser.reset(NewTestParser(input)); 107 value.reset(parser->ConsumeLiteral()); 108 EXPECT_EQ('e', *parser->pos_); 109 110 TestLastThree(parser.get()); 111 112 ASSERT_TRUE(value.get()); 113 EXPECT_TRUE(value->GetAsBoolean(&bool_value)); 114 EXPECT_FALSE(bool_value); 115 116 // Literal |null|. 117 input = "null,|"; 118 parser.reset(NewTestParser(input)); 119 value.reset(parser->ConsumeLiteral()); 120 EXPECT_EQ('l', *parser->pos_); 121 122 TestLastThree(parser.get()); 123 124 ASSERT_TRUE(value.get()); 125 EXPECT_TRUE(value->IsType(Value::TYPE_NULL)); 126 } 127 128 TEST_F(JSONParserTest, ConsumeNumbers) { 129 // Integer. 130 std::string input("1234,|"); 131 scoped_ptr<JSONParser> parser(NewTestParser(input)); 132 scoped_ptr<Value> value(parser->ConsumeNumber()); 133 EXPECT_EQ('4', *parser->pos_); 134 135 TestLastThree(parser.get()); 136 137 ASSERT_TRUE(value.get()); 138 int number_i; 139 EXPECT_TRUE(value->GetAsInteger(&number_i)); 140 EXPECT_EQ(1234, number_i); 141 142 // Negative integer. 143 input = "-1234,|"; 144 parser.reset(NewTestParser(input)); 145 value.reset(parser->ConsumeNumber()); 146 EXPECT_EQ('4', *parser->pos_); 147 148 TestLastThree(parser.get()); 149 150 ASSERT_TRUE(value.get()); 151 EXPECT_TRUE(value->GetAsInteger(&number_i)); 152 EXPECT_EQ(-1234, number_i); 153 154 // Double. 155 input = "12.34,|"; 156 parser.reset(NewTestParser(input)); 157 value.reset(parser->ConsumeNumber()); 158 EXPECT_EQ('4', *parser->pos_); 159 160 TestLastThree(parser.get()); 161 162 ASSERT_TRUE(value.get()); 163 double number_d; 164 EXPECT_TRUE(value->GetAsDouble(&number_d)); 165 EXPECT_EQ(12.34, number_d); 166 167 // Scientific. 168 input = "42e3,|"; 169 parser.reset(NewTestParser(input)); 170 value.reset(parser->ConsumeNumber()); 171 EXPECT_EQ('3', *parser->pos_); 172 173 TestLastThree(parser.get()); 174 175 ASSERT_TRUE(value.get()); 176 EXPECT_TRUE(value->GetAsDouble(&number_d)); 177 EXPECT_EQ(42000, number_d); 178 179 // Negative scientific. 180 input = "314159e-5,|"; 181 parser.reset(NewTestParser(input)); 182 value.reset(parser->ConsumeNumber()); 183 EXPECT_EQ('5', *parser->pos_); 184 185 TestLastThree(parser.get()); 186 187 ASSERT_TRUE(value.get()); 188 EXPECT_TRUE(value->GetAsDouble(&number_d)); 189 EXPECT_EQ(3.14159, number_d); 190 191 // Positive scientific. 192 input = "0.42e+3,|"; 193 parser.reset(NewTestParser(input)); 194 value.reset(parser->ConsumeNumber()); 195 EXPECT_EQ('3', *parser->pos_); 196 197 TestLastThree(parser.get()); 198 199 ASSERT_TRUE(value.get()); 200 EXPECT_TRUE(value->GetAsDouble(&number_d)); 201 EXPECT_EQ(420, number_d); 202 } 203 204 TEST_F(JSONParserTest, ErrorMessages) { 205 // Error strings should not be modified in case of success. 206 std::string error_message; 207 int error_code = 0; 208 scoped_ptr<Value> root = JSONReader::ReadAndReturnError( 209 "[42]", JSON_PARSE_RFC, &error_code, &error_message); 210 EXPECT_TRUE(error_message.empty()); 211 EXPECT_EQ(0, error_code); 212 213 // Test line and column counting 214 const char big_json[] = "[\n0,\n1,\n2,\n3,4,5,6 7,\n8,\n9\n]"; 215 // error here ----------------------------------^ 216 root = JSONReader::ReadAndReturnError(big_json, JSON_PARSE_RFC, &error_code, 217 &error_message); 218 EXPECT_FALSE(root.get()); 219 EXPECT_EQ(JSONParser::FormatErrorMessage(5, 10, JSONReader::kSyntaxError), 220 error_message); 221 EXPECT_EQ(JSONReader::JSON_SYNTAX_ERROR, error_code); 222 223 error_code = 0; 224 error_message = ""; 225 // Test line and column counting with "\r\n" line ending 226 const char big_json_crlf[] = 227 "[\r\n0,\r\n1,\r\n2,\r\n3,4,5,6 7,\r\n8,\r\n9\r\n]"; 228 // error here ----------------------^ 229 root = JSONReader::ReadAndReturnError(big_json_crlf, JSON_PARSE_RFC, 230 &error_code, &error_message); 231 EXPECT_FALSE(root.get()); 232 EXPECT_EQ(JSONParser::FormatErrorMessage(5, 10, JSONReader::kSyntaxError), 233 error_message); 234 EXPECT_EQ(JSONReader::JSON_SYNTAX_ERROR, error_code); 235 236 // Test each of the error conditions 237 root = JSONReader::ReadAndReturnError("{},{}", JSON_PARSE_RFC, &error_code, 238 &error_message); 239 EXPECT_FALSE(root.get()); 240 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 3, 241 JSONReader::kUnexpectedDataAfterRoot), error_message); 242 EXPECT_EQ(JSONReader::JSON_UNEXPECTED_DATA_AFTER_ROOT, error_code); 243 244 std::string nested_json; 245 for (int i = 0; i < 101; ++i) { 246 nested_json.insert(nested_json.begin(), '['); 247 nested_json.append(1, ']'); 248 } 249 root = JSONReader::ReadAndReturnError(nested_json, JSON_PARSE_RFC, 250 &error_code, &error_message); 251 EXPECT_FALSE(root.get()); 252 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 100, JSONReader::kTooMuchNesting), 253 error_message); 254 EXPECT_EQ(JSONReader::JSON_TOO_MUCH_NESTING, error_code); 255 256 root = JSONReader::ReadAndReturnError("[1,]", JSON_PARSE_RFC, &error_code, 257 &error_message); 258 EXPECT_FALSE(root.get()); 259 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 4, JSONReader::kTrailingComma), 260 error_message); 261 EXPECT_EQ(JSONReader::JSON_TRAILING_COMMA, error_code); 262 263 root = JSONReader::ReadAndReturnError("{foo:\"bar\"}", JSON_PARSE_RFC, 264 &error_code, &error_message); 265 EXPECT_FALSE(root.get()); 266 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 2, 267 JSONReader::kUnquotedDictionaryKey), error_message); 268 EXPECT_EQ(JSONReader::JSON_UNQUOTED_DICTIONARY_KEY, error_code); 269 270 root = JSONReader::ReadAndReturnError("{\"foo\":\"bar\",}", JSON_PARSE_RFC, 271 &error_code, &error_message); 272 EXPECT_FALSE(root.get()); 273 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 14, JSONReader::kTrailingComma), 274 error_message); 275 276 root = JSONReader::ReadAndReturnError("[nu]", JSON_PARSE_RFC, &error_code, 277 &error_message); 278 EXPECT_FALSE(root.get()); 279 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 2, JSONReader::kSyntaxError), 280 error_message); 281 EXPECT_EQ(JSONReader::JSON_SYNTAX_ERROR, error_code); 282 283 root = JSONReader::ReadAndReturnError("[\"xxx\\xq\"]", JSON_PARSE_RFC, 284 &error_code, &error_message); 285 EXPECT_FALSE(root.get()); 286 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape), 287 error_message); 288 EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code); 289 290 root = JSONReader::ReadAndReturnError("[\"xxx\\uq\"]", JSON_PARSE_RFC, 291 &error_code, &error_message); 292 EXPECT_FALSE(root.get()); 293 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape), 294 error_message); 295 EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code); 296 297 root = JSONReader::ReadAndReturnError("[\"xxx\\q\"]", JSON_PARSE_RFC, 298 &error_code, &error_message); 299 EXPECT_FALSE(root.get()); 300 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape), 301 error_message); 302 EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code); 303 } 304 305 TEST_F(JSONParserTest, Decode4ByteUtf8Char) { 306 // This test strings contains a 4 byte unicode character (a smiley!) that the 307 // reader should be able to handle (the character is \xf0\x9f\x98\x87). 308 const char kUtf8Data[] = 309 "[\"\",[],[],[],{\"google:suggesttype\":[]}]"; 310 std::string error_message; 311 int error_code = 0; 312 scoped_ptr<Value> root = JSONReader::ReadAndReturnError( 313 kUtf8Data, JSON_PARSE_RFC, &error_code, &error_message); 314 EXPECT_TRUE(root.get()) << error_message; 315 } 316 317 TEST_F(JSONParserTest, DecodeUnicodeNonCharacter) { 318 // Tests Unicode code points (encoded as escaped UTF-16) that are not valid 319 // characters. 320 EXPECT_FALSE(JSONReader::Read("[\"\\ufdd0\"]")); 321 EXPECT_FALSE(JSONReader::Read("[\"\\ufffe\"]")); 322 EXPECT_FALSE(JSONReader::Read("[\"\\ud83f\\udffe\"]")); 323 } 324 325 } // namespace internal 326 } // namespace base 327
