Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(289)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: base/json_reader_unittest.cc

Issue 316016: Move the json-related files into a separate json directory. This hopefully al... (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/
Patch Set: '' Created 11 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « base/json_reader.cc ('k') | base/json_writer.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(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 }
OLDNEW
« no previous file with comments | « base/json_reader.cc ('k') | base/json_writer.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698