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