OLD | NEW |
---|---|
(Empty) | |
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 | |
12 using base::internal::JSONParser; | |
tfarina
2012/04/19 22:56:23
nit: I don't think you need this, as you have both
Robert Sesek
2012/05/03 15:34:52
Done.
| |
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->pos_); | |
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; | |
209 root.reset(JSONReader::ReadAndReturnError("[42]", JSON_PARSE_RFC, | |
210 &error_code, &error_message)); | |
211 EXPECT_TRUE(error_message.empty()); | |
212 EXPECT_EQ(0, error_code); | |
213 | |
214 // Test line and column counting | |
215 const char* big_json = "[\n0,\n1,\n2,\n3,4,5,6 7,\n8,\n9\n]"; | |
216 // error here ---------------------------------^ | |
217 root.reset(JSONReader::ReadAndReturnError(big_json, JSON_PARSE_RFC, | |
218 &error_code, &error_message)); | |
219 EXPECT_FALSE(root.get()); | |
220 EXPECT_EQ(JSONParser::FormatErrorMessage(5, 10, JSONReader::kSyntaxError), | |
221 error_message); | |
222 EXPECT_EQ(JSONReader::JSON_SYNTAX_ERROR, error_code); | |
223 | |
224 // Test each of the error conditions | |
225 root.reset(JSONReader::ReadAndReturnError("{},{}", JSON_PARSE_RFC, | |
226 &error_code, &error_message)); | |
227 EXPECT_FALSE(root.get()); | |
228 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 3, | |
229 JSONReader::kUnexpectedDataAfterRoot), error_message); | |
230 EXPECT_EQ(JSONReader::JSON_UNEXPECTED_DATA_AFTER_ROOT, error_code); | |
231 | |
232 std::string nested_json; | |
233 for (int i = 0; i < 101; ++i) { | |
234 nested_json.insert(nested_json.begin(), '['); | |
235 nested_json.append(1, ']'); | |
236 } | |
237 root.reset(JSONReader::ReadAndReturnError(nested_json, JSON_PARSE_RFC, | |
238 &error_code, &error_message)); | |
239 EXPECT_FALSE(root.get()); | |
240 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 100, JSONReader::kTooMuchNesting), | |
241 error_message); | |
242 EXPECT_EQ(JSONReader::JSON_TOO_MUCH_NESTING, error_code); | |
243 | |
244 root.reset(JSONReader::ReadAndReturnError("[1,]", JSON_PARSE_RFC, | |
245 &error_code, &error_message)); | |
246 EXPECT_FALSE(root.get()); | |
247 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 4, JSONReader::kTrailingComma), | |
248 error_message); | |
249 EXPECT_EQ(JSONReader::JSON_TRAILING_COMMA, error_code); | |
250 | |
251 root.reset(JSONReader::ReadAndReturnError("{foo:\"bar\"}", JSON_PARSE_RFC, | |
252 &error_code, &error_message)); | |
253 EXPECT_FALSE(root.get()); | |
254 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 2, | |
255 JSONReader::kUnquotedDictionaryKey), error_message); | |
256 EXPECT_EQ(JSONReader::JSON_UNQUOTED_DICTIONARY_KEY, error_code); | |
257 | |
258 root.reset(JSONReader::ReadAndReturnError("{\"foo\":\"bar\",}", | |
259 JSON_PARSE_RFC, | |
260 &error_code, &error_message)); | |
261 EXPECT_FALSE(root.get()); | |
262 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 14, JSONReader::kTrailingComma), | |
263 error_message); | |
264 | |
265 root.reset(JSONReader::ReadAndReturnError("[nu]", JSON_PARSE_RFC, | |
266 &error_code, &error_message)); | |
267 EXPECT_FALSE(root.get()); | |
268 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 2, JSONReader::kSyntaxError), | |
269 error_message); | |
270 EXPECT_EQ(JSONReader::JSON_SYNTAX_ERROR, error_code); | |
271 | |
272 root.reset(JSONReader::ReadAndReturnError("[\"xxx\\xq\"]", JSON_PARSE_RFC, | |
273 &error_code, &error_message)); | |
274 EXPECT_FALSE(root.get()); | |
275 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape), | |
276 error_message); | |
277 EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code); | |
278 | |
279 root.reset(JSONReader::ReadAndReturnError("[\"xxx\\uq\"]", JSON_PARSE_RFC, | |
280 &error_code, &error_message)); | |
281 EXPECT_FALSE(root.get()); | |
282 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape), | |
283 error_message); | |
284 EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code); | |
285 | |
286 root.reset(JSONReader::ReadAndReturnError("[\"xxx\\q\"]", JSON_PARSE_RFC, | |
287 &error_code, &error_message)); | |
288 EXPECT_FALSE(root.get()); | |
289 EXPECT_EQ(JSONParser::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape), | |
290 error_message); | |
291 EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code); | |
292 } | |
293 | |
294 } // namespace internal | |
295 } // namespace base | |
OLD | NEW |