OLD | NEW |
| (Empty) |
1 // Copyright (c) 2006-2008 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 "testing/gtest/include/gtest/gtest.h" | |
6 #include "base/json_reader.h" | |
7 #include "base/scoped_ptr.h" | |
8 #include "base/values.h" | |
9 #include "build/build_config.h" | |
10 | |
11 TEST(JSONReaderTest, Reading) { | |
12 // some whitespace checking | |
13 scoped_ptr<Value> root; | |
14 root.reset(JSONReader().JsonToValue(" null ", false, false)); | |
15 ASSERT_TRUE(root.get()); | |
16 ASSERT_TRUE(root->IsType(Value::TYPE_NULL)); | |
17 | |
18 // Invalid JSON string | |
19 root.reset(JSONReader().JsonToValue("nu", false, false)); | |
20 ASSERT_FALSE(root.get()); | |
21 | |
22 // Simple bool | |
23 root.reset(JSONReader().JsonToValue("true ", false, false)); | |
24 ASSERT_TRUE(root.get()); | |
25 ASSERT_TRUE(root->IsType(Value::TYPE_BOOLEAN)); | |
26 | |
27 // Embedded comment | |
28 root.reset(JSONReader().JsonToValue("/* comment */null", false, false)); | |
29 ASSERT_TRUE(root.get()); | |
30 ASSERT_TRUE(root->IsType(Value::TYPE_NULL)); | |
31 root.reset(JSONReader().JsonToValue("40 /* comment */", false, false)); | |
32 ASSERT_TRUE(root.get()); | |
33 ASSERT_TRUE(root->IsType(Value::TYPE_INTEGER)); | |
34 root.reset(JSONReader().JsonToValue("true // comment", false, false)); | |
35 ASSERT_TRUE(root.get()); | |
36 ASSERT_TRUE(root->IsType(Value::TYPE_BOOLEAN)); | |
37 root.reset(JSONReader().JsonToValue("/* comment */\"sample string\"", | |
38 false, false)); | |
39 ASSERT_TRUE(root.get()); | |
40 ASSERT_TRUE(root->IsType(Value::TYPE_STRING)); | |
41 std::string value; | |
42 ASSERT_TRUE(root->GetAsString(&value)); | |
43 ASSERT_EQ("sample string", value); | |
44 | |
45 // Test number formats | |
46 root.reset(JSONReader().JsonToValue("43", false, false)); | |
47 ASSERT_TRUE(root.get()); | |
48 ASSERT_TRUE(root->IsType(Value::TYPE_INTEGER)); | |
49 int int_val = 0; | |
50 ASSERT_TRUE(root->GetAsInteger(&int_val)); | |
51 ASSERT_EQ(43, int_val); | |
52 | |
53 // According to RFC4627, oct, hex, and leading zeros are invalid JSON. | |
54 root.reset(JSONReader().JsonToValue("043", false, false)); | |
55 ASSERT_FALSE(root.get()); | |
56 root.reset(JSONReader().JsonToValue("0x43", false, false)); | |
57 ASSERT_FALSE(root.get()); | |
58 root.reset(JSONReader().JsonToValue("00", false, false)); | |
59 ASSERT_FALSE(root.get()); | |
60 | |
61 // Test 0 (which needs to be special cased because of the leading zero | |
62 // clause). | |
63 root.reset(JSONReader().JsonToValue("0", false, false)); | |
64 ASSERT_TRUE(root.get()); | |
65 ASSERT_TRUE(root->IsType(Value::TYPE_INTEGER)); | |
66 int_val = 1; | |
67 ASSERT_TRUE(root->GetAsInteger(&int_val)); | |
68 ASSERT_EQ(0, int_val); | |
69 | |
70 // Numbers that overflow ints should succeed, being internally promoted to | |
71 // storage as doubles | |
72 root.reset(JSONReader().JsonToValue("2147483648", false, false)); | |
73 ASSERT_TRUE(root.get()); | |
74 double real_val; | |
75 ASSERT_TRUE(root->IsType(Value::TYPE_REAL)); | |
76 real_val = 0.0; | |
77 ASSERT_TRUE(root->GetAsReal(&real_val)); | |
78 ASSERT_DOUBLE_EQ(2147483648.0, real_val); | |
79 root.reset(JSONReader().JsonToValue("-2147483649", false, false)); | |
80 ASSERT_TRUE(root.get()); | |
81 ASSERT_TRUE(root->IsType(Value::TYPE_REAL)); | |
82 real_val = 0.0; | |
83 ASSERT_TRUE(root->GetAsReal(&real_val)); | |
84 ASSERT_DOUBLE_EQ(-2147483649.0, real_val); | |
85 | |
86 // Parse a double | |
87 root.reset(JSONReader().JsonToValue("43.1", false, false)); | |
88 ASSERT_TRUE(root.get()); | |
89 ASSERT_TRUE(root->IsType(Value::TYPE_REAL)); | |
90 real_val = 0.0; | |
91 ASSERT_TRUE(root->GetAsReal(&real_val)); | |
92 ASSERT_DOUBLE_EQ(43.1, real_val); | |
93 | |
94 root.reset(JSONReader().JsonToValue("4.3e-1", false, false)); | |
95 ASSERT_TRUE(root.get()); | |
96 ASSERT_TRUE(root->IsType(Value::TYPE_REAL)); | |
97 real_val = 0.0; | |
98 ASSERT_TRUE(root->GetAsReal(&real_val)); | |
99 ASSERT_DOUBLE_EQ(.43, real_val); | |
100 | |
101 root.reset(JSONReader().JsonToValue("2.1e0", false, false)); | |
102 ASSERT_TRUE(root.get()); | |
103 ASSERT_TRUE(root->IsType(Value::TYPE_REAL)); | |
104 real_val = 0.0; | |
105 ASSERT_TRUE(root->GetAsReal(&real_val)); | |
106 ASSERT_DOUBLE_EQ(2.1, real_val); | |
107 | |
108 root.reset(JSONReader().JsonToValue("2.1e+0001", false, false)); | |
109 ASSERT_TRUE(root.get()); | |
110 ASSERT_TRUE(root->IsType(Value::TYPE_REAL)); | |
111 real_val = 0.0; | |
112 ASSERT_TRUE(root->GetAsReal(&real_val)); | |
113 ASSERT_DOUBLE_EQ(21.0, real_val); | |
114 | |
115 root.reset(JSONReader().JsonToValue("0.01", false, false)); | |
116 ASSERT_TRUE(root.get()); | |
117 ASSERT_TRUE(root->IsType(Value::TYPE_REAL)); | |
118 real_val = 0.0; | |
119 ASSERT_TRUE(root->GetAsReal(&real_val)); | |
120 ASSERT_DOUBLE_EQ(0.01, real_val); | |
121 | |
122 root.reset(JSONReader().JsonToValue("1.00", false, false)); | |
123 ASSERT_TRUE(root.get()); | |
124 ASSERT_TRUE(root->IsType(Value::TYPE_REAL)); | |
125 real_val = 0.0; | |
126 ASSERT_TRUE(root->GetAsReal(&real_val)); | |
127 ASSERT_DOUBLE_EQ(1.0, real_val); | |
128 | |
129 // Fractional parts must have a digit before and after the decimal point. | |
130 root.reset(JSONReader().JsonToValue("1.", false, false)); | |
131 ASSERT_FALSE(root.get()); | |
132 root.reset(JSONReader().JsonToValue(".1", false, false)); | |
133 ASSERT_FALSE(root.get()); | |
134 root.reset(JSONReader().JsonToValue("1.e10", false, false)); | |
135 ASSERT_FALSE(root.get()); | |
136 | |
137 // Exponent must have a digit following the 'e'. | |
138 root.reset(JSONReader().JsonToValue("1e", false, false)); | |
139 ASSERT_FALSE(root.get()); | |
140 root.reset(JSONReader().JsonToValue("1E", false, false)); | |
141 ASSERT_FALSE(root.get()); | |
142 root.reset(JSONReader().JsonToValue("1e1.", false, false)); | |
143 ASSERT_FALSE(root.get()); | |
144 root.reset(JSONReader().JsonToValue("1e1.0", false, false)); | |
145 ASSERT_FALSE(root.get()); | |
146 | |
147 // INF/-INF/NaN are not valid | |
148 root.reset(JSONReader().JsonToValue("1e1000", false, false)); | |
149 ASSERT_FALSE(root.get()); | |
150 root.reset(JSONReader().JsonToValue("-1e1000", false, false)); | |
151 ASSERT_FALSE(root.get()); | |
152 root.reset(JSONReader().JsonToValue("NaN", false, false)); | |
153 ASSERT_FALSE(root.get()); | |
154 root.reset(JSONReader().JsonToValue("nan", false, false)); | |
155 ASSERT_FALSE(root.get()); | |
156 root.reset(JSONReader().JsonToValue("inf", false, false)); | |
157 ASSERT_FALSE(root.get()); | |
158 | |
159 // Invalid number formats | |
160 root.reset(JSONReader().JsonToValue("4.3.1", false, false)); | |
161 ASSERT_FALSE(root.get()); | |
162 root.reset(JSONReader().JsonToValue("4e3.1", false, false)); | |
163 ASSERT_FALSE(root.get()); | |
164 | |
165 // Test string parser | |
166 root.reset(JSONReader().JsonToValue("\"hello world\"", false, false)); | |
167 ASSERT_TRUE(root.get()); | |
168 ASSERT_TRUE(root->IsType(Value::TYPE_STRING)); | |
169 std::wstring str_val; | |
170 ASSERT_TRUE(root->GetAsString(&str_val)); | |
171 ASSERT_EQ(L"hello world", str_val); | |
172 | |
173 // Empty string | |
174 root.reset(JSONReader().JsonToValue("\"\"", false, false)); | |
175 ASSERT_TRUE(root.get()); | |
176 ASSERT_TRUE(root->IsType(Value::TYPE_STRING)); | |
177 str_val.clear(); | |
178 ASSERT_TRUE(root->GetAsString(&str_val)); | |
179 ASSERT_EQ(L"", str_val); | |
180 | |
181 // Test basic string escapes | |
182 root.reset(JSONReader().JsonToValue("\" \\\"\\\\\\/\\b\\f\\n\\r\\t\\v\"", | |
183 false, false)); | |
184 ASSERT_TRUE(root.get()); | |
185 ASSERT_TRUE(root->IsType(Value::TYPE_STRING)); | |
186 str_val.clear(); | |
187 ASSERT_TRUE(root->GetAsString(&str_val)); | |
188 ASSERT_EQ(L" \"\\/\b\f\n\r\t\v", str_val); | |
189 | |
190 // Test hex and unicode escapes including the null character. | |
191 root.reset(JSONReader().JsonToValue("\"\\x41\\x00\\u1234\"", false, | |
192 false)); | |
193 ASSERT_TRUE(root.get()); | |
194 ASSERT_TRUE(root->IsType(Value::TYPE_STRING)); | |
195 str_val.clear(); | |
196 ASSERT_TRUE(root->GetAsString(&str_val)); | |
197 ASSERT_EQ(std::wstring(L"A\0\x1234", 3), str_val); | |
198 | |
199 // Test invalid strings | |
200 root.reset(JSONReader().JsonToValue("\"no closing quote", false, false)); | |
201 ASSERT_FALSE(root.get()); | |
202 root.reset(JSONReader().JsonToValue("\"\\z invalid escape char\"", false, | |
203 false)); | |
204 ASSERT_FALSE(root.get()); | |
205 root.reset(JSONReader().JsonToValue("\"\\xAQ invalid hex code\"", false, | |
206 false)); | |
207 ASSERT_FALSE(root.get()); | |
208 root.reset(JSONReader().JsonToValue("not enough hex chars\\x1\"", false, | |
209 false)); | |
210 ASSERT_FALSE(root.get()); | |
211 root.reset(JSONReader().JsonToValue("\"not enough escape chars\\u123\"", | |
212 false, false)); | |
213 ASSERT_FALSE(root.get()); | |
214 root.reset(JSONReader().JsonToValue("\"extra backslash at end of input\\\"", | |
215 false, false)); | |
216 ASSERT_FALSE(root.get()); | |
217 | |
218 // Basic array | |
219 root.reset(JSONReader::Read("[true, false, null]", false)); | |
220 ASSERT_TRUE(root.get()); | |
221 ASSERT_TRUE(root->IsType(Value::TYPE_LIST)); | |
222 ListValue* list = static_cast<ListValue*>(root.get()); | |
223 ASSERT_EQ(3U, list->GetSize()); | |
224 | |
225 // Test with trailing comma. Should be parsed the same as above. | |
226 scoped_ptr<Value> root2; | |
227 root2.reset(JSONReader::Read("[true, false, null, ]", true)); | |
228 EXPECT_TRUE(root->Equals(root2.get())); | |
229 | |
230 // Empty array | |
231 root.reset(JSONReader::Read("[]", false)); | |
232 ASSERT_TRUE(root.get()); | |
233 ASSERT_TRUE(root->IsType(Value::TYPE_LIST)); | |
234 list = static_cast<ListValue*>(root.get()); | |
235 ASSERT_EQ(0U, list->GetSize()); | |
236 | |
237 // Nested arrays | |
238 root.reset(JSONReader::Read("[[true], [], [false, [], [null]], null]", | |
239 false)); | |
240 ASSERT_TRUE(root.get()); | |
241 ASSERT_TRUE(root->IsType(Value::TYPE_LIST)); | |
242 list = static_cast<ListValue*>(root.get()); | |
243 ASSERT_EQ(4U, list->GetSize()); | |
244 | |
245 // Lots of trailing commas. | |
246 root2.reset(JSONReader::Read("[[true], [], [false, [], [null, ] , ], null,]", | |
247 true)); | |
248 EXPECT_TRUE(root->Equals(root2.get())); | |
249 | |
250 // Invalid, missing close brace. | |
251 root.reset(JSONReader::Read("[[true], [], [false, [], [null]], null", false)); | |
252 ASSERT_FALSE(root.get()); | |
253 | |
254 // Invalid, too many commas | |
255 root.reset(JSONReader::Read("[true,, null]", false)); | |
256 ASSERT_FALSE(root.get()); | |
257 root.reset(JSONReader::Read("[true,, null]", true)); | |
258 ASSERT_FALSE(root.get()); | |
259 | |
260 // Invalid, no commas | |
261 root.reset(JSONReader::Read("[true null]", false)); | |
262 ASSERT_FALSE(root.get()); | |
263 | |
264 // Invalid, trailing comma | |
265 root.reset(JSONReader::Read("[true,]", false)); | |
266 ASSERT_FALSE(root.get()); | |
267 | |
268 // Valid if we set |allow_trailing_comma| to true. | |
269 root.reset(JSONReader::Read("[true,]", true)); | |
270 ASSERT_TRUE(root.get()); | |
271 ASSERT_TRUE(root->IsType(Value::TYPE_LIST)); | |
272 list = static_cast<ListValue*>(root.get()); | |
273 EXPECT_EQ(1U, list->GetSize()); | |
274 Value* tmp_value = NULL; | |
275 ASSERT_TRUE(list->Get(0, &tmp_value)); | |
276 EXPECT_TRUE(tmp_value->IsType(Value::TYPE_BOOLEAN)); | |
277 bool bool_value = false; | |
278 ASSERT_TRUE(tmp_value->GetAsBoolean(&bool_value)); | |
279 EXPECT_TRUE(bool_value); | |
280 | |
281 // Don't allow empty elements, even if |allow_trailing_comma| is | |
282 // true. | |
283 root.reset(JSONReader::Read("[,]", true)); | |
284 EXPECT_FALSE(root.get()); | |
285 root.reset(JSONReader::Read("[true,,]", true)); | |
286 EXPECT_FALSE(root.get()); | |
287 root.reset(JSONReader::Read("[,true,]", true)); | |
288 EXPECT_FALSE(root.get()); | |
289 root.reset(JSONReader::Read("[true,,false]", true)); | |
290 EXPECT_FALSE(root.get()); | |
291 | |
292 // Test objects | |
293 root.reset(JSONReader::Read("{}", false)); | |
294 ASSERT_TRUE(root.get()); | |
295 ASSERT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); | |
296 | |
297 root.reset(JSONReader::Read( | |
298 "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\" }", | |
299 false)); | |
300 ASSERT_TRUE(root.get()); | |
301 ASSERT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); | |
302 DictionaryValue* dict_val = static_cast<DictionaryValue*>(root.get()); | |
303 real_val = 0.0; | |
304 ASSERT_TRUE(dict_val->GetReal(L"number", &real_val)); | |
305 ASSERT_DOUBLE_EQ(9.87654321, real_val); | |
306 Value* null_val = NULL; | |
307 ASSERT_TRUE(dict_val->Get(L"null", &null_val)); | |
308 ASSERT_TRUE(null_val->IsType(Value::TYPE_NULL)); | |
309 str_val.clear(); | |
310 ASSERT_TRUE(dict_val->GetString(L"S", &str_val)); | |
311 ASSERT_EQ(L"str", str_val); | |
312 | |
313 root2.reset(JSONReader::Read( | |
314 "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", }", true)); | |
315 ASSERT_TRUE(root2.get()); | |
316 EXPECT_TRUE(root->Equals(root2.get())); | |
317 | |
318 // Test newline equivalence. | |
319 root2.reset(JSONReader::Read( | |
320 "{\n" | |
321 " \"number\":9.87654321,\n" | |
322 " \"null\":null,\n" | |
323 " \"\\x53\":\"str\",\n" | |
324 "}\n", true)); | |
325 ASSERT_TRUE(root2.get()); | |
326 EXPECT_TRUE(root->Equals(root2.get())); | |
327 | |
328 root2.reset(JSONReader::Read( | |
329 "{\r\n" | |
330 " \"number\":9.87654321,\r\n" | |
331 " \"null\":null,\r\n" | |
332 " \"\\x53\":\"str\",\r\n" | |
333 "}\r\n", true)); | |
334 ASSERT_TRUE(root2.get()); | |
335 EXPECT_TRUE(root->Equals(root2.get())); | |
336 | |
337 // Test nesting | |
338 root.reset(JSONReader::Read( | |
339 "{\"inner\":{\"array\":[true]},\"false\":false,\"d\":{}}", false)); | |
340 ASSERT_TRUE(root.get()); | |
341 ASSERT_TRUE(root->IsType(Value::TYPE_DICTIONARY)); | |
342 dict_val = static_cast<DictionaryValue*>(root.get()); | |
343 DictionaryValue* inner_dict = NULL; | |
344 ASSERT_TRUE(dict_val->GetDictionary(L"inner", &inner_dict)); | |
345 ListValue* inner_array = NULL; | |
346 ASSERT_TRUE(inner_dict->GetList(L"array", &inner_array)); | |
347 ASSERT_EQ(1U, inner_array->GetSize()); | |
348 bool_value = true; | |
349 ASSERT_TRUE(dict_val->GetBoolean(L"false", &bool_value)); | |
350 ASSERT_FALSE(bool_value); | |
351 inner_dict = NULL; | |
352 ASSERT_TRUE(dict_val->GetDictionary(L"d", &inner_dict)); | |
353 | |
354 root2.reset(JSONReader::Read( | |
355 "{\"inner\": {\"array\":[true] , },\"false\":false,\"d\":{},}", true)); | |
356 EXPECT_TRUE(root->Equals(root2.get())); | |
357 | |
358 // Invalid, no closing brace | |
359 root.reset(JSONReader::Read("{\"a\": true", false)); | |
360 ASSERT_FALSE(root.get()); | |
361 | |
362 // Invalid, keys must be quoted | |
363 root.reset(JSONReader::Read("{foo:true}", false)); | |
364 ASSERT_FALSE(root.get()); | |
365 | |
366 // Invalid, trailing comma | |
367 root.reset(JSONReader::Read("{\"a\":true,}", false)); | |
368 ASSERT_FALSE(root.get()); | |
369 | |
370 // Invalid, too many commas | |
371 root.reset(JSONReader::Read("{\"a\":true,,\"b\":false}", false)); | |
372 ASSERT_FALSE(root.get()); | |
373 root.reset(JSONReader::Read("{\"a\":true,,\"b\":false}", true)); | |
374 ASSERT_FALSE(root.get()); | |
375 | |
376 // Invalid, no separator | |
377 root.reset(JSONReader::Read("{\"a\" \"b\"}", false)); | |
378 ASSERT_FALSE(root.get()); | |
379 | |
380 // Invalid, lone comma. | |
381 root.reset(JSONReader::Read("{,}", false)); | |
382 ASSERT_FALSE(root.get()); | |
383 root.reset(JSONReader::Read("{,}", true)); | |
384 ASSERT_FALSE(root.get()); | |
385 root.reset(JSONReader::Read("{\"a\":true,,}", true)); | |
386 ASSERT_FALSE(root.get()); | |
387 root.reset(JSONReader::Read("{,\"a\":true}", true)); | |
388 ASSERT_FALSE(root.get()); | |
389 root.reset(JSONReader::Read("{\"a\":true,,\"b\":false}", true)); | |
390 ASSERT_FALSE(root.get()); | |
391 | |
392 // Test stack overflow | |
393 std::string evil(1000000, '['); | |
394 evil.append(std::string(1000000, ']')); | |
395 root.reset(JSONReader::Read(evil, false)); | |
396 ASSERT_FALSE(root.get()); | |
397 | |
398 // A few thousand adjacent lists is fine. | |
399 std::string not_evil("["); | |
400 not_evil.reserve(15010); | |
401 for (int i = 0; i < 5000; ++i) { | |
402 not_evil.append("[],"); | |
403 } | |
404 not_evil.append("[]]"); | |
405 root.reset(JSONReader::Read(not_evil, false)); | |
406 ASSERT_TRUE(root.get()); | |
407 ASSERT_TRUE(root->IsType(Value::TYPE_LIST)); | |
408 list = static_cast<ListValue*>(root.get()); | |
409 ASSERT_EQ(5001U, list->GetSize()); | |
410 | |
411 // Test utf8 encoded input | |
412 root.reset(JSONReader().JsonToValue("\"\xe7\xbd\x91\xe9\xa1\xb5\"", | |
413 false, false)); | |
414 ASSERT_TRUE(root.get()); | |
415 ASSERT_TRUE(root->IsType(Value::TYPE_STRING)); | |
416 str_val.clear(); | |
417 ASSERT_TRUE(root->GetAsString(&str_val)); | |
418 ASSERT_EQ(L"\x7f51\x9875", str_val); | |
419 | |
420 // Test invalid utf8 encoded input | |
421 root.reset(JSONReader().JsonToValue("\"345\xb0\xa1\xb0\xa2\"", | |
422 false, false)); | |
423 ASSERT_FALSE(root.get()); | |
424 root.reset(JSONReader().JsonToValue("\"123\xc0\x81\"", | |
425 false, false)); | |
426 ASSERT_FALSE(root.get()); | |
427 | |
428 // Test invalid root objects. | |
429 root.reset(JSONReader::Read("null", false)); | |
430 ASSERT_FALSE(root.get()); | |
431 root.reset(JSONReader::Read("true", false)); | |
432 ASSERT_FALSE(root.get()); | |
433 root.reset(JSONReader::Read("10", false)); | |
434 ASSERT_FALSE(root.get()); | |
435 root.reset(JSONReader::Read("\"root\"", false)); | |
436 ASSERT_FALSE(root.get()); | |
437 } | |
438 | |
439 TEST(JSONReaderTest, ErrorMessages) { | |
440 // Error strings should not be modified in case of success. | |
441 std::string error_message; | |
442 scoped_ptr<Value> root; | |
443 root.reset(JSONReader::ReadAndReturnError("[42]", false, &error_message)); | |
444 EXPECT_TRUE(error_message.empty()); | |
445 | |
446 // Test line and column counting | |
447 const char* big_json = "[\n0,\n1,\n2,\n3,4,5,6 7,\n8,\n9\n]"; | |
448 // error here --------------------------------^ | |
449 root.reset(JSONReader::ReadAndReturnError(big_json, false, &error_message)); | |
450 EXPECT_FALSE(root.get()); | |
451 EXPECT_EQ(JSONReader::FormatErrorMessage(5, 9, JSONReader::kSyntaxError), | |
452 error_message); | |
453 | |
454 // Test each of the error conditions | |
455 root.reset(JSONReader::ReadAndReturnError("{},{}", false, &error_message)); | |
456 EXPECT_FALSE(root.get()); | |
457 EXPECT_EQ(JSONReader::FormatErrorMessage(1, 3, | |
458 JSONReader::kUnexpectedDataAfterRoot), error_message); | |
459 | |
460 std::string nested_json; | |
461 for (int i = 0; i < 101; ++i) { | |
462 nested_json.insert(nested_json.begin(), '['); | |
463 nested_json.append(1, ']'); | |
464 } | |
465 root.reset(JSONReader::ReadAndReturnError(nested_json, false, | |
466 &error_message)); | |
467 EXPECT_FALSE(root.get()); | |
468 EXPECT_EQ(JSONReader::FormatErrorMessage(1, 101, JSONReader::kTooMuchNesting), | |
469 error_message); | |
470 | |
471 root.reset(JSONReader::ReadAndReturnError("42", false, &error_message)); | |
472 EXPECT_FALSE(root.get()); | |
473 EXPECT_EQ(JSONReader::FormatErrorMessage(1, 1, | |
474 JSONReader::kBadRootElementType), error_message); | |
475 | |
476 root.reset(JSONReader::ReadAndReturnError("[1,]", false, &error_message)); | |
477 EXPECT_FALSE(root.get()); | |
478 EXPECT_EQ(JSONReader::FormatErrorMessage(1, 4, JSONReader::kTrailingComma), | |
479 error_message); | |
480 | |
481 root.reset(JSONReader::ReadAndReturnError("{foo:\"bar\"}", false, | |
482 &error_message)); | |
483 EXPECT_FALSE(root.get()); | |
484 EXPECT_EQ(JSONReader::FormatErrorMessage(1, 2, | |
485 JSONReader::kUnquotedDictionaryKey), error_message); | |
486 | |
487 root.reset(JSONReader::ReadAndReturnError("{\"foo\":\"bar\",}", false, | |
488 &error_message)); | |
489 EXPECT_FALSE(root.get()); | |
490 EXPECT_EQ(JSONReader::FormatErrorMessage(1, 14, JSONReader::kTrailingComma), | |
491 error_message); | |
492 | |
493 root.reset(JSONReader::ReadAndReturnError("[nu]", false, &error_message)); | |
494 EXPECT_FALSE(root.get()); | |
495 EXPECT_EQ(JSONReader::FormatErrorMessage(1, 2, JSONReader::kSyntaxError), | |
496 error_message); | |
497 | |
498 root.reset(JSONReader::ReadAndReturnError("[\"xxx\\xq\"]", false, | |
499 &error_message)); | |
500 EXPECT_FALSE(root.get()); | |
501 EXPECT_EQ(JSONReader::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape), | |
502 error_message); | |
503 | |
504 root.reset(JSONReader::ReadAndReturnError("[\"xxx\\uq\"]", false, | |
505 &error_message)); | |
506 EXPECT_FALSE(root.get()); | |
507 EXPECT_EQ(JSONReader::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape), | |
508 error_message); | |
509 | |
510 root.reset(JSONReader::ReadAndReturnError("[\"xxx\\q\"]", false, | |
511 &error_message)); | |
512 EXPECT_FALSE(root.get()); | |
513 EXPECT_EQ(JSONReader::FormatErrorMessage(1, 7, JSONReader::kInvalidEscape), | |
514 error_message); | |
515 | |
516 } | |
OLD | NEW |