1 // Copyright 2012 The Chromium Authors
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_reader.h"
6
7 #include <stddef.h>
8
9 #include <cmath>
10 #include <utility>
11
12 #include "base/base_paths.h"
13 #include "base/features.h"
14 #include "base/files/file_util.h"
15 #include "base/logging.h"
16 #include "base/path_service.h"
17 #include "base/rust_buildflags.h"
18 #include "base/strings/string_piece.h"
19 #include "base/strings/stringprintf.h"
20 #include "base/strings/utf_string_conversions.h"
21 #include "base/test/gmock_expected_support.h"
22 #include "base/test/metrics/histogram_tester.h"
23 #include "base/test/scoped_feature_list.h"
24 #include "base/values.h"
25 #include "build/build_config.h"
26 #include "testing/gmock/include/gmock/gmock.h"
27 #include "testing/gtest/include/gtest/gtest.h"
28 #include "third_party/abseil-cpp/absl/types/optional.h"
29
30 namespace {
31
32 // MSan will do a better job detecting over-read errors if the input is not
33 // nul-terminated on the heap. This will copy |input| to a new buffer owned by
34 // |owner|, returning a base::StringPiece to |owner|.
MakeNotNullTerminatedInput(const char * input,std::unique_ptr<char[]> * owner)35 base::StringPiece MakeNotNullTerminatedInput(const char* input,
36 std::unique_ptr<char[]>* owner) {
37 size_t str_len = strlen(input);
38 owner->reset(new char[str_len]);
39 memcpy(owner->get(), input, str_len);
40 return base::StringPiece(owner->get(), str_len);
41 }
42
43 } // namespace
44
45 namespace base {
46
47 class JSONReaderTest : public testing::TestWithParam<bool> {
48 public:
SetUp()49 void SetUp() override {
50 feature_list_.InitWithFeatureState(base::features::kUseRustJsonParser,
51 using_rust_);
52 }
53
54 protected:
55 bool using_rust_ = GetParam();
56 base::test::ScopedFeatureList feature_list_;
57 };
58
TEST_P(JSONReaderTest,Whitespace)59 TEST_P(JSONReaderTest, Whitespace) {
60 absl::optional<Value> root = JSONReader::Read(" null ");
61 ASSERT_TRUE(root);
62 EXPECT_TRUE(root->is_none());
63 }
64
TEST_P(JSONReaderTest,InvalidString)65 TEST_P(JSONReaderTest, InvalidString) {
66 // These are invalid because they do not represent a JSON value,
67 // see https://tools.ietf.org/rfc/rfc8259.txt
68 EXPECT_FALSE(JSONReader::Read(""));
69 EXPECT_FALSE(JSONReader::Read("nu"));
70 }
71
TEST_P(JSONReaderTest,SimpleBool)72 TEST_P(JSONReaderTest, SimpleBool) {
73 #if BUILDFLAG(BUILD_RUST_JSON_READER)
74 base::HistogramTester histograms;
75 #endif // BUILDFLAG(BUILD_RUST_JSON_READER)
76 absl::optional<Value> root = JSONReader::Read("true ");
77 ASSERT_TRUE(root);
78 EXPECT_TRUE(root->is_bool());
79 #if BUILDFLAG(BUILD_RUST_JSON_READER)
80 histograms.ExpectTotalCount("Security.JSONParser.ParsingTime", 1);
81 #endif // BUILDFLAG(BUILD_RUST_JSON_READER)
82 }
83
TEST_P(JSONReaderTest,EmbeddedComments)84 TEST_P(JSONReaderTest, EmbeddedComments) {
85 absl::optional<Value> root = JSONReader::Read("/* comment */null");
86 ASSERT_TRUE(root);
87 EXPECT_TRUE(root->is_none());
88 root = JSONReader::Read("40 /* comment */");
89 ASSERT_TRUE(root);
90 EXPECT_TRUE(root->is_int());
91 root = JSONReader::Read("true // comment");
92 ASSERT_TRUE(root);
93 EXPECT_TRUE(root->is_bool());
94 // Comments in different contexts.
95 root = JSONReader::Read("{ \"cheese\": 3\n\n // Here's a comment\n}");
96 ASSERT_TRUE(root);
97 EXPECT_TRUE(root->is_dict());
98 root = JSONReader::Read("{ \"cheese\": 3// Here's a comment\n}");
99 ASSERT_TRUE(root);
100 EXPECT_TRUE(root->is_dict());
101 // Multiple comment markers.
102 root = JSONReader::Read(
103 "{ \"cheese\": 3// Here's a comment // and another\n}");
104 ASSERT_TRUE(root);
105 EXPECT_TRUE(root->is_dict());
106 root = JSONReader::Read("/* comment */\"sample string\"");
107 ASSERT_TRUE(root);
108 ASSERT_TRUE(root->is_string());
109 EXPECT_EQ("sample string", root->GetString());
110 root = JSONReader::Read("[1, /* comment, 2 ] */ \n 3]");
111 ASSERT_TRUE(root);
112 Value::List* list = root->GetIfList();
113 ASSERT_TRUE(list);
114 ASSERT_EQ(2u, list->size());
115 ASSERT_TRUE((*list)[0].is_int());
116 EXPECT_EQ(1, (*list)[0].GetInt());
117 ASSERT_TRUE((*list)[1].is_int());
118 EXPECT_EQ(3, (*list)[1].GetInt());
119 root = JSONReader::Read("[1, /*a*/2, 3]");
120 ASSERT_TRUE(root);
121 list = root->GetIfList();
122 ASSERT_TRUE(list);
123 EXPECT_EQ(3u, (*list).size());
124 root = JSONReader::Read("/* comment **/42");
125 ASSERT_TRUE(root);
126 ASSERT_TRUE(root->is_int());
127 EXPECT_EQ(42, root->GetInt());
128 root = JSONReader::Read(
129 "/* comment **/\n"
130 "// */ 43\n"
131 "44");
132 ASSERT_TRUE(root);
133 EXPECT_TRUE(root->is_int());
134 EXPECT_EQ(44, root->GetInt());
135
136 // At one point, this parsed successfully as the value three.
137 EXPECT_FALSE(JSONReader::Read("/33"));
138 }
139
TEST_P(JSONReaderTest,Ints)140 TEST_P(JSONReaderTest, Ints) {
141 absl::optional<Value> root = JSONReader::Read("43");
142 ASSERT_TRUE(root);
143 ASSERT_TRUE(root->is_int());
144 EXPECT_EQ(43, root->GetInt());
145 }
146
TEST_P(JSONReaderTest,NonDecimalNumbers)147 TEST_P(JSONReaderTest, NonDecimalNumbers) {
148 // According to RFC 8259, oct, hex, and leading zeros are invalid JSON.
149 EXPECT_FALSE(JSONReader::Read("043"));
150 EXPECT_FALSE(JSONReader::Read("0x43"));
151 EXPECT_FALSE(JSONReader::Read("00"));
152 }
153
TEST_P(JSONReaderTest,NumberZero)154 TEST_P(JSONReaderTest, NumberZero) {
155 // Test 0 (which needs to be special cased because of the leading zero
156 // clause).
157 absl::optional<Value> root = JSONReader::Read("0");
158 ASSERT_TRUE(root);
159 ASSERT_TRUE(root->is_int());
160 EXPECT_EQ(0, root->GetInt());
161 }
162
TEST_P(JSONReaderTest,LargeIntPromotion)163 TEST_P(JSONReaderTest, LargeIntPromotion) {
164 // Numbers that overflow ints should succeed, being internally promoted to
165 // storage as doubles
166 absl::optional<Value> root = JSONReader::Read("2147483648");
167 ASSERT_TRUE(root);
168 EXPECT_TRUE(root->is_double());
169 EXPECT_DOUBLE_EQ(2147483648.0, root->GetDouble());
170 root = JSONReader::Read("-2147483649");
171 ASSERT_TRUE(root);
172 EXPECT_TRUE(root->is_double());
173 EXPECT_DOUBLE_EQ(-2147483649.0, root->GetDouble());
174 }
175
TEST_P(JSONReaderTest,LargerIntIsLossy)176 TEST_P(JSONReaderTest, LargerIntIsLossy) {
177 // Parse LONG_MAX as a JSON number (not a JSON string). The result of the
178 // parse is a base::Value, either a (32-bit) int or a (64-bit) double.
179 // LONG_MAX would overflow an int and can only be approximated by a double.
180 // In this case, parsing is lossy.
181 const char* etc807 = "9223372036854775807";
182 const char* etc808 = "9223372036854775808.000000";
183 absl::optional<Value> root = JSONReader::Read(etc807);
184 ASSERT_TRUE(root);
185 ASSERT_FALSE(root->is_int());
186 ASSERT_TRUE(root->is_double());
187 // We use StringPrintf instead of NumberToString, because the NumberToString
188 // function does not let you specify the precision, and its default output,
189 // "9.223372036854776e+18", isn't precise enough to see the lossiness.
190 EXPECT_EQ(std::string(etc808), StringPrintf("%f", root->GetDouble()));
191 }
192
TEST_P(JSONReaderTest,Doubles)193 TEST_P(JSONReaderTest, Doubles) {
194 absl::optional<Value> root = JSONReader::Read("43.1");
195 ASSERT_TRUE(root);
196 EXPECT_TRUE(root->is_double());
197 EXPECT_DOUBLE_EQ(43.1, root->GetDouble());
198
199 root = JSONReader::Read("4.3e-1");
200 ASSERT_TRUE(root);
201 EXPECT_TRUE(root->is_double());
202 EXPECT_DOUBLE_EQ(.43, root->GetDouble());
203
204 root = JSONReader::Read("2.1e0");
205 ASSERT_TRUE(root);
206 EXPECT_TRUE(root->is_double());
207 EXPECT_DOUBLE_EQ(2.1, root->GetDouble());
208
209 root = JSONReader::Read("2.1e+0001");
210 ASSERT_TRUE(root);
211 EXPECT_TRUE(root->is_double());
212 EXPECT_DOUBLE_EQ(21.0, root->GetDouble());
213
214 root = JSONReader::Read("0.01");
215 ASSERT_TRUE(root);
216 EXPECT_TRUE(root->is_double());
217 EXPECT_DOUBLE_EQ(0.01, root->GetDouble());
218
219 root = JSONReader::Read("1.00");
220 ASSERT_TRUE(root);
221 EXPECT_TRUE(root->is_double());
222 EXPECT_DOUBLE_EQ(1.0, root->GetDouble());
223
224 // Some "parse to float64" implementations find this one tricky.
225 // https://github.com/serde-rs/json/issues/707
226 root = JSONReader::Read("122.416294033786585");
227 ASSERT_TRUE(root);
228 EXPECT_TRUE(root->is_double());
229 EXPECT_DOUBLE_EQ(122.416294033786585, root->GetDouble());
230
231 // This is syntaxtically valid, but out of range of a double.
232 auto value =
233 JSONReader::ReadAndReturnValueWithError("1e1000", JSON_PARSE_RFC);
234 ASSERT_FALSE(value.has_value());
235 }
236
TEST_P(JSONReaderTest,FractionalNumbers)237 TEST_P(JSONReaderTest, FractionalNumbers) {
238 // Fractional parts must have a digit before and after the decimal point.
239 EXPECT_FALSE(JSONReader::Read("1."));
240 EXPECT_FALSE(JSONReader::Read(".1"));
241 EXPECT_FALSE(JSONReader::Read("1.e10"));
242 }
243
TEST_P(JSONReaderTest,ExponentialNumbers)244 TEST_P(JSONReaderTest, ExponentialNumbers) {
245 // Exponent must have a digit following the 'e'.
246 EXPECT_FALSE(JSONReader::Read("1e"));
247 EXPECT_FALSE(JSONReader::Read("1E"));
248 EXPECT_FALSE(JSONReader::Read("1e1."));
249 EXPECT_FALSE(JSONReader::Read("1e1.0"));
250 }
251
TEST_P(JSONReaderTest,InvalidInfNAN)252 TEST_P(JSONReaderTest, InvalidInfNAN) {
253 // The largest finite double is roughly 1.8e308.
254 EXPECT_FALSE(JSONReader::Read("1e1000"));
255 EXPECT_FALSE(JSONReader::Read("-1e1000"));
256 EXPECT_FALSE(JSONReader::Read("NaN"));
257 EXPECT_FALSE(JSONReader::Read("nan"));
258 EXPECT_FALSE(JSONReader::Read("inf"));
259 }
260
TEST_P(JSONReaderTest,InvalidNumbers)261 TEST_P(JSONReaderTest, InvalidNumbers) {
262 EXPECT_TRUE(JSONReader::Read("4.3"));
263 EXPECT_FALSE(JSONReader::Read("4."));
264 EXPECT_FALSE(JSONReader::Read("4.3.1"));
265 EXPECT_FALSE(JSONReader::Read("4e3.1"));
266 EXPECT_FALSE(JSONReader::Read("4.a"));
267 EXPECT_FALSE(JSONReader::Read("42a"));
268 }
269
TEST_P(JSONReaderTest,Zeroes)270 TEST_P(JSONReaderTest, Zeroes) {
271 absl::optional<Value> root = JSONReader::Read("0");
272 ASSERT_TRUE(root);
273 EXPECT_TRUE(root->is_int());
274 EXPECT_DOUBLE_EQ(0, root->GetInt());
275
276 root = JSONReader::Read("0.0");
277 ASSERT_TRUE(root);
278 EXPECT_TRUE(root->is_double());
279 EXPECT_DOUBLE_EQ(0.0, root->GetDouble());
280 EXPECT_FALSE(std::signbit(root->GetDouble()));
281
282 root = JSONReader::Read("-0");
283 ASSERT_TRUE(root);
284 EXPECT_TRUE(root->is_double());
285 EXPECT_DOUBLE_EQ(0.0, root->GetDouble());
286 EXPECT_TRUE(std::signbit(root->GetDouble()));
287
288 root = JSONReader::Read("-0.0");
289 ASSERT_TRUE(root);
290 EXPECT_TRUE(root->is_double());
291 EXPECT_DOUBLE_EQ(-0.0, root->GetDouble());
292 EXPECT_TRUE(std::signbit(root->GetDouble()));
293 }
294
TEST_P(JSONReaderTest,SimpleString)295 TEST_P(JSONReaderTest, SimpleString) {
296 absl::optional<Value> root = JSONReader::Read("\"hello world\"");
297 ASSERT_TRUE(root);
298 ASSERT_TRUE(root->is_string());
299 EXPECT_EQ("hello world", root->GetString());
300 }
301
TEST_P(JSONReaderTest,EmptyString)302 TEST_P(JSONReaderTest, EmptyString) {
303 absl::optional<Value> root = JSONReader::Read("\"\"");
304 ASSERT_TRUE(root);
305 ASSERT_TRUE(root->is_string());
306 EXPECT_EQ("", root->GetString());
307 }
308
TEST_P(JSONReaderTest,BasicStringEscapes)309 TEST_P(JSONReaderTest, BasicStringEscapes) {
310 absl::optional<Value> root =
311 JSONReader::Read("\" \\\"\\\\\\/\\b\\f\\n\\r\\t\\v\"");
312 ASSERT_TRUE(root);
313 ASSERT_TRUE(root->is_string());
314 EXPECT_EQ(" \"\\/\b\f\n\r\t\v", root->GetString());
315 }
316
TEST_P(JSONReaderTest,UnicodeEscapes)317 TEST_P(JSONReaderTest, UnicodeEscapes) {
318 // Test hex and unicode escapes including the null character.
319 absl::optional<Value> root =
320 JSONReader::Read("\"\\x41\\xFF\\x00\\u1234\\u0000\"");
321 ASSERT_TRUE(root);
322 ASSERT_TRUE(root->is_string());
323 const std::string& str_val = root->GetString();
324 EXPECT_EQ(std::wstring(L"A\x00FF\0\x1234\0", 5), UTF8ToWide(str_val));
325
326 // The contents of a Unicode escape may only be four hex chars. Previously the
327 // parser accepted things like "0x01" and "0X01".
328 EXPECT_FALSE(JSONReader::Read("\"\\u0x12\""));
329
330 // Surrogate pairs are allowed in JSON.
331 EXPECT_TRUE(JSONReader::Read("\"\\uD834\\uDD1E\"")); // U+1D11E
332 }
333
TEST_P(JSONReaderTest,InvalidStrings)334 TEST_P(JSONReaderTest, InvalidStrings) {
335 EXPECT_FALSE(JSONReader::Read("\"no closing quote"));
336 EXPECT_FALSE(JSONReader::Read("\"\\z invalid escape char\""));
337 EXPECT_FALSE(JSONReader::Read("\"\\xAQ invalid hex code\""));
338 EXPECT_FALSE(JSONReader::Read("not enough hex chars\\x1\""));
339 EXPECT_FALSE(JSONReader::Read("\"not enough escape chars\\u123\""));
340 EXPECT_FALSE(JSONReader::Read("\"extra backslash at end of input\\\""));
341 }
342
TEST_P(JSONReaderTest,BasicArray)343 TEST_P(JSONReaderTest, BasicArray) {
344 absl::optional<Value> root = JSONReader::Read("[true, false, null]");
345 ASSERT_TRUE(root);
346 Value::List* list = root->GetIfList();
347 ASSERT_TRUE(list);
348 EXPECT_EQ(3U, list->size());
349
350 // Test with trailing comma. Should be parsed the same as above.
351 absl::optional<Value> root2 =
352 JSONReader::Read("[true, false, null, ]", JSON_ALLOW_TRAILING_COMMAS);
353 ASSERT_TRUE(root2);
354 EXPECT_EQ(*list, *root2);
355 }
356
TEST_P(JSONReaderTest,EmptyArray)357 TEST_P(JSONReaderTest, EmptyArray) {
358 absl::optional<Value> value = JSONReader::Read("[]");
359 ASSERT_TRUE(value);
360 Value::List* list = value->GetIfList();
361 ASSERT_TRUE(list);
362 EXPECT_TRUE(list->empty());
363 }
364
TEST_P(JSONReaderTest,CompleteArray)365 TEST_P(JSONReaderTest, CompleteArray) {
366 absl::optional<Value> value = JSONReader::Read("[\"a\", 3, 4.56, null]");
367 ASSERT_TRUE(value);
368 Value::List* list = value->GetIfList();
369 ASSERT_TRUE(list);
370 EXPECT_EQ(4U, list->size());
371 }
372
TEST_P(JSONReaderTest,NestedArrays)373 TEST_P(JSONReaderTest, NestedArrays) {
374 absl::optional<Value> value = JSONReader::Read(
375 "[[true], [], {\"smell\": \"nice\",\"taste\": \"yummy\" }, [false, [], "
376 "[null]], null]");
377 ASSERT_TRUE(value);
378 Value::List* list = value->GetIfList();
379 ASSERT_TRUE(list);
380 EXPECT_EQ(5U, list->size());
381
382 // Lots of trailing commas.
383 absl::optional<Value> root2 = JSONReader::Read(
384 "[[true], [], {\"smell\": \"nice\",\"taste\": \"yummy\" }, [false, [], "
385 "[null, ] , ], null,]",
386 JSON_ALLOW_TRAILING_COMMAS);
387 ASSERT_TRUE(root2);
388 EXPECT_EQ(*list, *root2);
389 }
390
TEST_P(JSONReaderTest,InvalidArrays)391 TEST_P(JSONReaderTest, InvalidArrays) {
392 // Missing close brace.
393 EXPECT_FALSE(JSONReader::Read("[[true], [], [false, [], [null]], null"));
394
395 // Too many commas.
396 EXPECT_FALSE(JSONReader::Read("[true,, null]"));
397 EXPECT_FALSE(JSONReader::Read("[true,, null]", JSON_ALLOW_TRAILING_COMMAS));
398
399 // No commas.
400 EXPECT_FALSE(JSONReader::Read("[true null]"));
401
402 // Trailing comma.
403 EXPECT_FALSE(JSONReader::Read("[true,]"));
404 }
405
TEST_P(JSONReaderTest,ArrayTrailingComma)406 TEST_P(JSONReaderTest, ArrayTrailingComma) {
407 // Valid if we set |allow_trailing_comma| to true.
408 absl::optional<Value> value =
409 JSONReader::Read("[true,]", JSON_ALLOW_TRAILING_COMMAS);
410 ASSERT_TRUE(value);
411 Value::List* list = value->GetIfList();
412 ASSERT_TRUE(list);
413 ASSERT_EQ(1U, list->size());
414 const Value& value1 = (*list)[0];
415 ASSERT_TRUE(value1.is_bool());
416 EXPECT_TRUE(value1.GetBool());
417 }
418
TEST_P(JSONReaderTest,ArrayTrailingCommaNoEmptyElements)419 TEST_P(JSONReaderTest, ArrayTrailingCommaNoEmptyElements) {
420 // Don't allow empty elements, even if |allow_trailing_comma| is
421 // true.
422 EXPECT_FALSE(JSONReader::Read("[,]", JSON_ALLOW_TRAILING_COMMAS));
423 EXPECT_FALSE(JSONReader::Read("[true,,]", JSON_ALLOW_TRAILING_COMMAS));
424 EXPECT_FALSE(JSONReader::Read("[,true,]", JSON_ALLOW_TRAILING_COMMAS));
425 EXPECT_FALSE(JSONReader::Read("[true,,false]", JSON_ALLOW_TRAILING_COMMAS));
426 }
427
TEST_P(JSONReaderTest,EmptyDictionary)428 TEST_P(JSONReaderTest, EmptyDictionary) {
429 absl::optional<Value> dict_val = JSONReader::Read("{}");
430 ASSERT_TRUE(dict_val);
431 ASSERT_TRUE(dict_val->is_dict());
432 }
433
TEST_P(JSONReaderTest,CompleteDictionary)434 TEST_P(JSONReaderTest, CompleteDictionary) {
435 absl::optional<Value> root1 = JSONReader::Read(
436 "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", \"bool\": "
437 "false, \"more\": {} }");
438 ASSERT_TRUE(root1);
439 const Value::Dict* root1_dict = root1->GetIfDict();
440 ASSERT_TRUE(root1_dict);
441 auto double_val = root1_dict->FindDouble("number");
442 ASSERT_TRUE(double_val);
443 EXPECT_DOUBLE_EQ(9.87654321, *double_val);
444 const Value* null_val = root1_dict->Find("null");
445 ASSERT_TRUE(null_val);
446 EXPECT_TRUE(null_val->is_none());
447 const std::string* str_val = root1_dict->FindString("S");
448 ASSERT_TRUE(str_val);
449 EXPECT_EQ("str", *str_val);
450 auto bool_val = root1_dict->FindBool("bool");
451 ASSERT_TRUE(bool_val);
452 ASSERT_FALSE(*bool_val);
453
454 absl::optional<Value> root2 = JSONReader::Read(
455 "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", \"bool\": "
456 "false, \"more\": {},}",
457 JSON_PARSE_CHROMIUM_EXTENSIONS | JSON_ALLOW_TRAILING_COMMAS);
458 ASSERT_TRUE(root2);
459 Value::Dict* root2_dict = root2->GetIfDict();
460 ASSERT_TRUE(root2_dict);
461 EXPECT_EQ(*root1_dict, *root2_dict);
462
463 // Test newline equivalence.
464 root2 = JSONReader::Read(
465 "{\n"
466 " \"number\":9.87654321,\n"
467 " \"null\":null,\n"
468 " \"\\x53\":\"str\",\n"
469 " \"bool\": false,\n"
470 " \"more\": {},\n"
471 "}\n",
472 JSON_PARSE_CHROMIUM_EXTENSIONS | JSON_ALLOW_TRAILING_COMMAS);
473 ASSERT_TRUE(root2);
474 root2_dict = root2->GetIfDict();
475 ASSERT_TRUE(root2);
476 EXPECT_EQ(*root1_dict, *root2_dict);
477
478 root2 = JSONReader::Read(
479 "{\r\n"
480 " \"number\":9.87654321,\r\n"
481 " \"null\":null,\r\n"
482 " \"\\x53\":\"str\",\r\n"
483 " \"bool\": false,\r\n"
484 " \"more\": {},\r\n"
485 "}\r\n",
486 JSON_PARSE_CHROMIUM_EXTENSIONS | JSON_ALLOW_TRAILING_COMMAS);
487 ASSERT_TRUE(root2);
488 root2_dict = root2->GetIfDict();
489 ASSERT_TRUE(root2_dict);
490 EXPECT_EQ(*root1_dict, *root2_dict);
491 }
492
TEST_P(JSONReaderTest,NestedDictionaries)493 TEST_P(JSONReaderTest, NestedDictionaries) {
494 absl::optional<Value> root1 = JSONReader::Read(
495 "{\"inner\":{\"array\":[true, 3, 4.56, null]},\"false\":false,\"d\":{}}");
496 ASSERT_TRUE(root1);
497 const base::Value::Dict* root1_dict = root1->GetIfDict();
498 ASSERT_TRUE(root1_dict);
499 const Value::Dict* inner_dict = root1_dict->FindDict("inner");
500 ASSERT_TRUE(inner_dict);
501 const Value::List* inner_array = inner_dict->FindList("array");
502 ASSERT_TRUE(inner_array);
503 EXPECT_EQ(4U, inner_array->size());
504 auto bool_value = root1_dict->FindBool("false");
505 ASSERT_TRUE(bool_value);
506 EXPECT_FALSE(*bool_value);
507 inner_dict = root1_dict->FindDict("d");
508 EXPECT_TRUE(inner_dict);
509
510 absl::optional<Value> root2 = JSONReader::Read(
511 "{\"inner\": {\"array\":[true, 3, 4.56, null] , "
512 "},\"false\":false,\"d\":{},}",
513 JSON_ALLOW_TRAILING_COMMAS);
514 ASSERT_TRUE(root2);
515 EXPECT_EQ(*root1_dict, *root2);
516 }
517
TEST_P(JSONReaderTest,DictionaryKeysWithPeriods)518 TEST_P(JSONReaderTest, DictionaryKeysWithPeriods) {
519 absl::optional<Value> root =
520 JSONReader::Read("{\"a.b\":3,\"c\":2,\"d.e.f\":{\"g.h.i.j\":1}}");
521 ASSERT_TRUE(root);
522 Value::Dict* root_dict = root->GetIfDict();
523 ASSERT_TRUE(root_dict);
524
525 auto integer_value = root_dict->FindInt("a.b");
526 ASSERT_TRUE(integer_value);
527 EXPECT_EQ(3, *integer_value);
528 integer_value = root_dict->FindInt("c");
529 ASSERT_TRUE(integer_value);
530 EXPECT_EQ(2, *integer_value);
531 const Value::Dict* inner_dict = root_dict->FindDict("d.e.f");
532 ASSERT_TRUE(inner_dict);
533 EXPECT_EQ(1U, inner_dict->size());
534 integer_value = inner_dict->FindInt("g.h.i.j");
535 ASSERT_TRUE(integer_value);
536 EXPECT_EQ(1, *integer_value);
537
538 root = JSONReader::Read("{\"a\":{\"b\":2},\"a.b\":1}");
539 ASSERT_TRUE(root);
540 root_dict = root->GetIfDict();
541 ASSERT_TRUE(root_dict);
542 const Value* integer_path_value = root_dict->FindByDottedPath("a.b");
543 ASSERT_TRUE(integer_path_value);
544 EXPECT_EQ(2, integer_path_value->GetInt());
545 integer_value = root_dict->FindInt("a.b");
546 ASSERT_TRUE(integer_value);
547 EXPECT_EQ(1, *integer_value);
548 }
549
TEST_P(JSONReaderTest,DuplicateKeys)550 TEST_P(JSONReaderTest, DuplicateKeys) {
551 absl::optional<Value> root = JSONReader::Read("{\"x\":1,\"x\":2,\"y\":3}");
552 ASSERT_TRUE(root);
553 const Value::Dict* root_dict = root->GetIfDict();
554 ASSERT_TRUE(root_dict);
555
556 auto integer_value = root_dict->FindInt("x");
557 ASSERT_TRUE(integer_value);
558 EXPECT_EQ(2, *integer_value);
559 }
560
TEST_P(JSONReaderTest,InvalidDictionaries)561 TEST_P(JSONReaderTest, InvalidDictionaries) {
562 // No closing brace.
563 EXPECT_FALSE(JSONReader::Read("{\"a\": true"));
564
565 // Keys must be quoted strings.
566 EXPECT_FALSE(JSONReader::Read("{foo:true}"));
567 EXPECT_FALSE(JSONReader::Read("{1234: false}"));
568 EXPECT_FALSE(JSONReader::Read("{:false}"));
569 EXPECT_FALSE(JSONReader::Read("{ , }"));
570
571 // Trailing comma.
572 EXPECT_FALSE(JSONReader::Read("{\"a\":true,}"));
573
574 // Too many commas.
575 EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}"));
576 EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}",
577 JSON_ALLOW_TRAILING_COMMAS));
578
579 // No separator.
580 EXPECT_FALSE(JSONReader::Read("{\"a\" \"b\"}"));
581
582 // Lone comma.
583 EXPECT_FALSE(JSONReader::Read("{,}"));
584 EXPECT_FALSE(JSONReader::Read("{,}", JSON_ALLOW_TRAILING_COMMAS));
585 EXPECT_FALSE(JSONReader::Read("{\"a\":true,,}", JSON_ALLOW_TRAILING_COMMAS));
586 EXPECT_FALSE(JSONReader::Read("{,\"a\":true}", JSON_ALLOW_TRAILING_COMMAS));
587 EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}",
588 JSON_ALLOW_TRAILING_COMMAS));
589 }
590
TEST_P(JSONReaderTest,StackOverflow)591 TEST_P(JSONReaderTest, StackOverflow) {
592 std::string evil(1000000, '[');
593 evil.append(std::string(1000000, ']'));
594 EXPECT_FALSE(JSONReader::Read(evil));
595
596 // A few thousand adjacent lists is fine.
597 std::string not_evil("[");
598 not_evil.reserve(15010);
599 for (int i = 0; i < 5000; ++i)
600 not_evil.append("[],");
601 not_evil.append("[]]");
602 absl::optional<Value> value = JSONReader::Read(not_evil);
603 ASSERT_TRUE(value);
604 Value::List* list = value->GetIfList();
605 ASSERT_TRUE(list);
606 EXPECT_EQ(5001U, list->size());
607 }
608
TEST_P(JSONReaderTest,UTF8Input)609 TEST_P(JSONReaderTest, UTF8Input) {
610 absl::optional<Value> root = JSONReader::Read("\"\xe7\xbd\x91\xe9\xa1\xb5\"");
611 ASSERT_TRUE(root);
612 ASSERT_TRUE(root->is_string());
613 const std::string& str_val = root->GetString();
614 EXPECT_EQ(L"\x7f51\x9875", UTF8ToWide(str_val));
615
616 root = JSONReader::Read("{\"path\": \"/tmp/\xc3\xa0\xc3\xa8\xc3\xb2.png\"}");
617 ASSERT_TRUE(root);
618 const Value::Dict* root_dict = root->GetIfDict();
619 ASSERT_TRUE(root_dict);
620 const std::string* maybe_string = root_dict->FindString("path");
621 ASSERT_TRUE(maybe_string);
622 EXPECT_EQ("/tmp/\xC3\xA0\xC3\xA8\xC3\xB2.png", *maybe_string);
623
624 // JSON can encode non-characters.
625 const char* const noncharacters[] = {
626 "\"\xEF\xB7\x90\"", // U+FDD0
627 "\"\xEF\xB7\x9F\"", // U+FDDF
628 "\"\xEF\xB7\xAF\"", // U+FDEF
629 "\"\xEF\xBF\xBE\"", // U+FFFE
630 "\"\xEF\xBF\xBF\"", // U+FFFF
631 "\"\xF0\x9F\xBF\xBE\"", // U+01FFFE
632 "\"\xF0\x9F\xBF\xBF\"", // U+01FFFF
633 "\"\xF0\xAF\xBF\xBE\"", // U+02FFFE
634 "\"\xF0\xAF\xBF\xBF\"", // U+02FFFF
635 "\"\xF0\xBF\xBF\xBE\"", // U+03FFFE
636 "\"\xF0\xBF\xBF\xBF\"", // U+03FFFF
637 "\"\xF1\x8F\xBF\xBE\"", // U+04FFFE
638 "\"\xF1\x8F\xBF\xBF\"", // U+04FFFF
639 "\"\xF1\x9F\xBF\xBE\"", // U+05FFFE
640 "\"\xF1\x9F\xBF\xBF\"", // U+05FFFF
641 "\"\xF1\xAF\xBF\xBE\"", // U+06FFFE
642 "\"\xF1\xAF\xBF\xBF\"", // U+06FFFF
643 "\"\xF1\xBF\xBF\xBE\"", // U+07FFFE
644 "\"\xF1\xBF\xBF\xBF\"", // U+07FFFF
645 "\"\xF2\x8F\xBF\xBE\"", // U+08FFFE
646 "\"\xF2\x8F\xBF\xBF\"", // U+08FFFF
647 "\"\xF2\x9F\xBF\xBE\"", // U+09FFFE
648 "\"\xF2\x9F\xBF\xBF\"", // U+09FFFF
649 "\"\xF2\xAF\xBF\xBE\"", // U+0AFFFE
650 "\"\xF2\xAF\xBF\xBF\"", // U+0AFFFF
651 "\"\xF2\xBF\xBF\xBE\"", // U+0BFFFE
652 "\"\xF2\xBF\xBF\xBF\"", // U+0BFFFF
653 "\"\xF3\x8F\xBF\xBE\"", // U+0CFFFE
654 "\"\xF3\x8F\xBF\xBF\"", // U+0CFFFF
655 "\"\xF3\x9F\xBF\xBE\"", // U+0DFFFE
656 "\"\xF3\x9F\xBF\xBF\"", // U+0DFFFF
657 "\"\xF3\xAF\xBF\xBE\"", // U+0EFFFE
658 "\"\xF3\xAF\xBF\xBF\"", // U+0EFFFF
659 "\"\xF3\xBF\xBF\xBE\"", // U+0FFFFE
660 "\"\xF3\xBF\xBF\xBF\"", // U+0FFFFF
661 "\"\xF4\x8F\xBF\xBE\"", // U+10FFFE
662 "\"\xF4\x8F\xBF\xBF\"", // U+10FFFF
663 };
664 for (auto* noncharacter : noncharacters) {
665 root = JSONReader::Read(noncharacter);
666 ASSERT_TRUE(root);
667 ASSERT_TRUE(root->is_string());
668 EXPECT_EQ(std::string(noncharacter + 1, strlen(noncharacter) - 2),
669 root->GetString());
670 }
671 }
672
TEST_P(JSONReaderTest,InvalidUTF8Input)673 TEST_P(JSONReaderTest, InvalidUTF8Input) {
674 EXPECT_FALSE(JSONReader::Read("\"345\xb0\xa1\xb0\xa2\""));
675 EXPECT_FALSE(JSONReader::Read("\"123\xc0\x81\""));
676 EXPECT_FALSE(JSONReader::Read("\"abc\xc0\xae\""));
677 }
678
TEST_P(JSONReaderTest,UTF16Escapes)679 TEST_P(JSONReaderTest, UTF16Escapes) {
680 absl::optional<Value> root = JSONReader::Read("\"\\u20ac3,14\"");
681 ASSERT_TRUE(root);
682 ASSERT_TRUE(root->is_string());
683 EXPECT_EQ(
684 "\xe2\x82\xac"
685 "3,14",
686 root->GetString());
687
688 root = JSONReader::Read("\"\\ud83d\\udca9\\ud83d\\udc6c\"");
689 ASSERT_TRUE(root);
690 ASSERT_TRUE(root->is_string());
691 EXPECT_EQ("\xf0\x9f\x92\xa9\xf0\x9f\x91\xac", root->GetString());
692 }
693
TEST_P(JSONReaderTest,InvalidUTF16Escapes)694 TEST_P(JSONReaderTest, InvalidUTF16Escapes) {
695 const char* const cases[] = {
696 "\"\\u123\"", // Invalid scalar.
697 "\"\\ud83d\"", // Invalid scalar.
698 "\"\\u$%@!\"", // Invalid scalar.
699 "\"\\uzz89\"", // Invalid scalar.
700 "\"\\ud83d\\udca\"", // Invalid lower surrogate.
701 "\"\\ud83d\\ud83d\"", // Invalid lower surrogate.
702 "\"\\ud83d\\uaaaZ\"", // Invalid lower surrogate.
703 "\"\\ud83foo\"", // No lower surrogate.
704 "\"\\ud83d\\foo\"", // No lower surrogate.
705 "\"\\ud83\\foo\"", // Invalid upper surrogate.
706 "\"\\ud83d\\u1\"", // No lower surrogate.
707 "\"\\ud83\\u1\"", // Invalid upper surrogate.
708 };
709 absl::optional<Value> root;
710 for (auto* i : cases) {
711 root = JSONReader::Read(i);
712 EXPECT_FALSE(root) << i;
713 }
714 }
715
TEST_P(JSONReaderTest,LiteralRoots)716 TEST_P(JSONReaderTest, LiteralRoots) {
717 absl::optional<Value> root = JSONReader::Read("null");
718 ASSERT_TRUE(root);
719 EXPECT_TRUE(root->is_none());
720
721 root = JSONReader::Read("true");
722 ASSERT_TRUE(root);
723 ASSERT_TRUE(root->is_bool());
724 EXPECT_TRUE(root->GetBool());
725
726 root = JSONReader::Read("10");
727 ASSERT_TRUE(root);
728 ASSERT_TRUE(root->is_int());
729 EXPECT_EQ(10, root->GetInt());
730
731 root = JSONReader::Read("\"root\"");
732 ASSERT_TRUE(root);
733 ASSERT_TRUE(root->is_string());
734 EXPECT_EQ("root", root->GetString());
735 }
736
TEST_P(JSONReaderTest,ReadFromFile)737 TEST_P(JSONReaderTest, ReadFromFile) {
738 FilePath path;
739 ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &path));
740 path = path.AppendASCII("json");
741 ASSERT_TRUE(base::PathExists(path));
742
743 std::string input;
744 ASSERT_TRUE(ReadFileToString(path.AppendASCII("bom_feff.json"), &input));
745
746 EXPECT_THAT(
747 JSONReader::ReadAndReturnValueWithError(input),
748 base::test::ValueIs(::testing::Property(&base::Value::is_dict, true)));
749 }
750
751 // Tests that the root of a JSON object can be deleted safely while its
752 // children outlive it.
TEST_P(JSONReaderTest,StringOptimizations)753 TEST_P(JSONReaderTest, StringOptimizations) {
754 Value dict_literal_0;
755 Value dict_literal_1;
756 Value dict_string_0;
757 Value dict_string_1;
758 Value list_value_0;
759 Value list_value_1;
760
761 {
762 absl::optional<Value> root = JSONReader::Read(
763 "{"
764 " \"test\": {"
765 " \"foo\": true,"
766 " \"bar\": 3.14,"
767 " \"baz\": \"bat\","
768 " \"moo\": \"cow\""
769 " },"
770 " \"list\": ["
771 " \"a\","
772 " \"b\""
773 " ]"
774 "}",
775 JSON_PARSE_RFC);
776 ASSERT_TRUE(root);
777 Value::Dict* root_dict = root->GetIfDict();
778 ASSERT_TRUE(root_dict);
779
780 Value::Dict* dict = root_dict->FindDict("test");
781 ASSERT_TRUE(dict);
782 Value::List* list = root_dict->FindList("list");
783 ASSERT_TRUE(list);
784
785 Value* to_move = dict->Find("foo");
786 ASSERT_TRUE(to_move);
787 dict_literal_0 = std::move(*to_move);
788 to_move = dict->Find("bar");
789 ASSERT_TRUE(to_move);
790 dict_literal_1 = std::move(*to_move);
791 to_move = dict->Find("baz");
792 ASSERT_TRUE(to_move);
793 dict_string_0 = std::move(*to_move);
794 to_move = dict->Find("moo");
795 ASSERT_TRUE(to_move);
796 dict_string_1 = std::move(*to_move);
797 ASSERT_TRUE(dict->Remove("foo"));
798 ASSERT_TRUE(dict->Remove("bar"));
799 ASSERT_TRUE(dict->Remove("baz"));
800 ASSERT_TRUE(dict->Remove("moo"));
801
802 ASSERT_EQ(2u, list->size());
803 list_value_0 = std::move((*list)[0]);
804 list_value_1 = std::move((*list)[1]);
805 list->clear();
806 }
807
808 ASSERT_TRUE(dict_literal_0.is_bool());
809 EXPECT_TRUE(dict_literal_0.GetBool());
810
811 ASSERT_TRUE(dict_literal_1.is_double());
812 EXPECT_EQ(3.14, dict_literal_1.GetDouble());
813
814 ASSERT_TRUE(dict_string_0.is_string());
815 EXPECT_EQ("bat", dict_string_0.GetString());
816
817 ASSERT_TRUE(dict_string_1.is_string());
818 EXPECT_EQ("cow", dict_string_1.GetString());
819
820 ASSERT_TRUE(list_value_0.is_string());
821 EXPECT_EQ("a", list_value_0.GetString());
822 ASSERT_TRUE(list_value_1.is_string());
823 EXPECT_EQ("b", list_value_1.GetString());
824 }
825
826 // A smattering of invalid JSON designed to test specific portions of the
827 // parser implementation against buffer overflow. Best run with DCHECKs so
828 // that the one in NextChar fires.
TEST_P(JSONReaderTest,InvalidSanity)829 TEST_P(JSONReaderTest, InvalidSanity) {
830 const char* const kInvalidJson[] = {
831 "/* test *", "{\"foo\"", "{\"foo\":", " [", "\"\\u123g\"", "{\n\"eh:\n}",
832 };
833
834 for (size_t i = 0; i < std::size(kInvalidJson); ++i) {
835 LOG(INFO) << "Sanity test " << i << ": <" << kInvalidJson[i] << ">";
836 auto root = JSONReader::ReadAndReturnValueWithError(kInvalidJson[i]);
837 EXPECT_FALSE(root.has_value());
838 EXPECT_NE("", root.error().message);
839 }
840 }
841
TEST_P(JSONReaderTest,IllegalTrailingNull)842 TEST_P(JSONReaderTest, IllegalTrailingNull) {
843 const char json[] = {'"', 'n', 'u', 'l', 'l', '"', '\0'};
844 std::string json_string(json, sizeof(json));
845 auto root = JSONReader::ReadAndReturnValueWithError(json_string);
846 EXPECT_FALSE(root.has_value());
847 EXPECT_NE("", root.error().message);
848 }
849
TEST_P(JSONReaderTest,ASCIIControlCodes)850 TEST_P(JSONReaderTest, ASCIIControlCodes) {
851 // A literal NUL byte or a literal new line, in a JSON string, should be
852 // rejected. RFC 8259 section 7 says "the characters that MUST be escaped
853 // [include]... the control characters (U+0000 through U+001F)".
854 //
855 // Nonetheless, we accept them, for backwards compatibility.
856 const char json[] = {'"', 'a', '\0', 'b', '\n', 'c', '"'};
857 absl::optional<Value> root =
858 JSONReader::Read(std::string(json, sizeof(json)));
859 ASSERT_TRUE(root);
860 ASSERT_TRUE(root->is_string());
861 EXPECT_EQ(5u, root->GetString().length());
862 }
863
TEST_P(JSONReaderTest,MaxNesting)864 TEST_P(JSONReaderTest, MaxNesting) {
865 std::string json(R"({"outer": { "inner": {"foo": true}}})");
866 EXPECT_FALSE(JSONReader::Read(json, JSON_PARSE_RFC, 3));
867 EXPECT_TRUE(JSONReader::Read(json, JSON_PARSE_RFC, 4));
868 }
869
TEST_P(JSONReaderTest,Decode4ByteUtf8Char)870 TEST_P(JSONReaderTest, Decode4ByteUtf8Char) {
871 // kUtf8Data contains a 4 byte unicode character (a smiley!) that JSONReader
872 // should be able to handle. The UTF-8 encoding of U+1F607 SMILING FACE WITH
873 // HALO is "\xF0\x9F\x98\x87".
874 const char kUtf8Data[] = "[\"��\",[],[],[],{\"google:suggesttype\":[]}]";
875 absl::optional<Value> root = JSONReader::Read(kUtf8Data, JSON_PARSE_RFC);
876 ASSERT_TRUE(root);
877 Value::List* list = root->GetIfList();
878 ASSERT_TRUE(list);
879 ASSERT_EQ(5u, list->size());
880 ASSERT_TRUE((*list)[0].is_string());
881 EXPECT_EQ("\xF0\x9F\x98\x87", (*list)[0].GetString());
882 }
883
TEST_P(JSONReaderTest,DecodeUnicodeNonCharacter)884 TEST_P(JSONReaderTest, DecodeUnicodeNonCharacter) {
885 // Tests Unicode code points (encoded as escaped UTF-16) that are not valid
886 // characters.
887 EXPECT_TRUE(JSONReader::Read("[\"\\uFDD0\"]")); // U+FDD0
888 EXPECT_TRUE(JSONReader::Read("[\"\\uFDDF\"]")); // U+FDDF
889 EXPECT_TRUE(JSONReader::Read("[\"\\uFDEF\"]")); // U+FDEF
890 EXPECT_TRUE(JSONReader::Read("[\"\\uFFFE\"]")); // U+FFFE
891 EXPECT_TRUE(JSONReader::Read("[\"\\uFFFF\"]")); // U+FFFF
892 EXPECT_TRUE(JSONReader::Read("[\"\\uD83F\\uDFFE\"]")); // U+01FFFE
893 EXPECT_TRUE(JSONReader::Read("[\"\\uD83F\\uDFFF\"]")); // U+01FFFF
894 EXPECT_TRUE(JSONReader::Read("[\"\\uD87F\\uDFFE\"]")); // U+02FFFE
895 EXPECT_TRUE(JSONReader::Read("[\"\\uD87F\\uDFFF\"]")); // U+02FFFF
896 EXPECT_TRUE(JSONReader::Read("[\"\\uD8BF\\uDFFE\"]")); // U+03FFFE
897 EXPECT_TRUE(JSONReader::Read("[\"\\uD8BF\\uDFFF\"]")); // U+03FFFF
898 EXPECT_TRUE(JSONReader::Read("[\"\\uD8FF\\uDFFE\"]")); // U+04FFFE
899 EXPECT_TRUE(JSONReader::Read("[\"\\uD8FF\\uDFFF\"]")); // U+04FFFF
900 EXPECT_TRUE(JSONReader::Read("[\"\\uD93F\\uDFFE\"]")); // U+05FFFE
901 EXPECT_TRUE(JSONReader::Read("[\"\\uD93F\\uDFFF\"]")); // U+05FFFF
902 EXPECT_TRUE(JSONReader::Read("[\"\\uD97F\\uDFFE\"]")); // U+06FFFE
903 EXPECT_TRUE(JSONReader::Read("[\"\\uD97F\\uDFFF\"]")); // U+06FFFF
904 EXPECT_TRUE(JSONReader::Read("[\"\\uD9BF\\uDFFE\"]")); // U+07FFFE
905 EXPECT_TRUE(JSONReader::Read("[\"\\uD9BF\\uDFFF\"]")); // U+07FFFF
906 EXPECT_TRUE(JSONReader::Read("[\"\\uD9FF\\uDFFE\"]")); // U+08FFFE
907 EXPECT_TRUE(JSONReader::Read("[\"\\uD9FF\\uDFFF\"]")); // U+08FFFF
908 EXPECT_TRUE(JSONReader::Read("[\"\\uDA3F\\uDFFE\"]")); // U+09FFFE
909 EXPECT_TRUE(JSONReader::Read("[\"\\uDA3F\\uDFFF\"]")); // U+09FFFF
910 EXPECT_TRUE(JSONReader::Read("[\"\\uDA7F\\uDFFE\"]")); // U+0AFFFE
911 EXPECT_TRUE(JSONReader::Read("[\"\\uDA7F\\uDFFF\"]")); // U+0AFFFF
912 EXPECT_TRUE(JSONReader::Read("[\"\\uDABF\\uDFFE\"]")); // U+0BFFFE
913 EXPECT_TRUE(JSONReader::Read("[\"\\uDABF\\uDFFF\"]")); // U+0BFFFF
914 EXPECT_TRUE(JSONReader::Read("[\"\\uDAFF\\uDFFE\"]")); // U+0CFFFE
915 EXPECT_TRUE(JSONReader::Read("[\"\\uDAFF\\uDFFF\"]")); // U+0CFFFF
916 EXPECT_TRUE(JSONReader::Read("[\"\\uDB3F\\uDFFE\"]")); // U+0DFFFE
917 EXPECT_TRUE(JSONReader::Read("[\"\\uDB3F\\uDFFF\"]")); // U+0DFFFF
918 EXPECT_TRUE(JSONReader::Read("[\"\\uDB7F\\uDFFE\"]")); // U+0EFFFE
919 EXPECT_TRUE(JSONReader::Read("[\"\\uDB7F\\uDFFF\"]")); // U+0EFFFF
920 EXPECT_TRUE(JSONReader::Read("[\"\\uDBBF\\uDFFE\"]")); // U+0FFFFE
921 EXPECT_TRUE(JSONReader::Read("[\"\\uDBBF\\uDFFF\"]")); // U+0FFFFF
922 EXPECT_TRUE(JSONReader::Read("[\"\\uDBFF\\uDFFE\"]")); // U+10FFFE
923 EXPECT_TRUE(JSONReader::Read("[\"\\uDBFF\\uDFFF\"]")); // U+10FFFF
924 }
925
TEST_P(JSONReaderTest,DecodeNegativeEscapeSequence)926 TEST_P(JSONReaderTest, DecodeNegativeEscapeSequence) {
927 EXPECT_FALSE(JSONReader::Read("[\"\\x-A\"]"));
928 EXPECT_FALSE(JSONReader::Read("[\"\\u-00A\"]"));
929 }
930
931 // Verifies invalid code points are replaced.
TEST_P(JSONReaderTest,ReplaceInvalidCharacters)932 TEST_P(JSONReaderTest, ReplaceInvalidCharacters) {
933 // U+D800 is a lone high surrogate.
934 const std::string invalid_high = "\"\xED\xA0\x80\"";
935 absl::optional<Value> value =
936 JSONReader::Read(invalid_high, JSON_REPLACE_INVALID_CHARACTERS);
937 ASSERT_TRUE(value);
938 ASSERT_TRUE(value->is_string());
939 // Expect three U+FFFD (one for each UTF-8 byte in the invalid code point).
940 EXPECT_EQ("\xEF\xBF\xBD\xEF\xBF\xBD\xEF\xBF\xBD", value->GetString());
941
942 // U+DFFF is a lone low surrogate.
943 const std::string invalid_low = "\"\xED\xBF\xBF\"";
944 value = JSONReader::Read(invalid_low, JSON_REPLACE_INVALID_CHARACTERS);
945 ASSERT_TRUE(value);
946 ASSERT_TRUE(value->is_string());
947 // Expect three U+FFFD (one for each UTF-8 byte in the invalid code point).
948 EXPECT_EQ("\xEF\xBF\xBD\xEF\xBF\xBD\xEF\xBF\xBD", value->GetString());
949 }
950
TEST_P(JSONReaderTest,ReplaceInvalidUTF16EscapeSequence)951 TEST_P(JSONReaderTest, ReplaceInvalidUTF16EscapeSequence) {
952 // U+D800 is a lone high surrogate.
953 const std::string invalid_high = "\"_\\uD800_\"";
954 absl::optional<Value> value =
955 JSONReader::Read(invalid_high, JSON_REPLACE_INVALID_CHARACTERS);
956 ASSERT_TRUE(value);
957 ASSERT_TRUE(value->is_string());
958 EXPECT_EQ("_\xEF\xBF\xBD_", value->GetString());
959
960 // U+DFFF is a lone low surrogate.
961 const std::string invalid_low = "\"_\\uDFFF_\"";
962 value = JSONReader::Read(invalid_low, JSON_REPLACE_INVALID_CHARACTERS);
963 ASSERT_TRUE(value);
964 ASSERT_TRUE(value->is_string());
965 EXPECT_EQ("_\xEF\xBF\xBD_", value->GetString());
966 }
967
TEST_P(JSONReaderTest,ParseNumberErrors)968 TEST_P(JSONReaderTest, ParseNumberErrors) {
969 const struct {
970 const char* input;
971 bool parse_success;
972 double value;
973 } kCases[] = {
974 // clang-format off
975 {"1", true, 1},
976 {"2.", false, 0},
977 {"42", true, 42},
978 {"6e", false, 0},
979 {"43e2", true, 4300},
980 {"43e-", false, 0},
981 {"9e-3", true, 0.009},
982 {"2e+", false, 0},
983 {"2e+2", true, 200},
984 // clang-format on
985 };
986
987 for (unsigned int i = 0; i < std::size(kCases); ++i) {
988 auto test_case = kCases[i];
989 SCOPED_TRACE(StringPrintf("case %u: \"%s\"", i, test_case.input));
990
991 std::unique_ptr<char[]> input_owner;
992 StringPiece input =
993 MakeNotNullTerminatedInput(test_case.input, &input_owner);
994
995 absl::optional<Value> result = JSONReader::Read(input);
996 EXPECT_EQ(test_case.parse_success, result.has_value());
997
998 if (!result)
999 continue;
1000
1001 ASSERT_TRUE(result->is_double() || result->is_int());
1002 EXPECT_EQ(test_case.value, result->GetDouble());
1003 }
1004 }
1005
TEST_P(JSONReaderTest,UnterminatedInputs)1006 TEST_P(JSONReaderTest, UnterminatedInputs) {
1007 const char* const kCases[] = {
1008 // clang-format off
1009 "/",
1010 "//",
1011 "/*",
1012 "\"xxxxxx",
1013 "\"",
1014 "{ ",
1015 "[\t",
1016 "tru",
1017 "fals",
1018 "nul",
1019 "\"\\x",
1020 "\"\\x2",
1021 "\"\\u123",
1022 "\"\\uD803\\u",
1023 "\"\\",
1024 "\"\\/",
1025 // clang-format on
1026 };
1027
1028 for (unsigned int i = 0; i < std::size(kCases); ++i) {
1029 auto* test_case = kCases[i];
1030 SCOPED_TRACE(StringPrintf("case %u: \"%s\"", i, test_case));
1031
1032 std::unique_ptr<char[]> input_owner;
1033 StringPiece input = MakeNotNullTerminatedInput(test_case, &input_owner);
1034
1035 EXPECT_FALSE(JSONReader::Read(input));
1036 }
1037 }
1038
TEST_P(JSONReaderTest,LineColumnCounting)1039 TEST_P(JSONReaderTest, LineColumnCounting) {
1040 const struct {
1041 const char* input;
1042 int error_line;
1043 int error_column;
1044 } kCases[] = {
1045 // For all but the "q_is_not_etc" case, the error (indicated by ^ in the
1046 // comments) is seeing a digit when expecting ',' or ']'.
1047 {
1048 // Line and column counts are 1-based, not 0-based.
1049 "q_is_not_the_start_of_any_valid_JSON_token",
1050 1,
1051 1,
1052 },
1053 {
1054 "[2,4,6 8",
1055 // -----^
1056 1,
1057 8,
1058 },
1059 {
1060 "[2,4,6\t8",
1061 // ------^
1062 1,
1063 8,
1064 },
1065 {
1066 "[2,4,6\n8",
1067 // ------^
1068 2,
1069 1,
1070 },
1071 {
1072 "[\n0,\n1,\n2,\n3,4,5,6 7,\n8,\n9\n]",
1073 // ---------------------^
1074 5,
1075 9,
1076 },
1077 {
1078 // Same as the previous example, but with "\r\n"s instead of "\n"s.
1079 "[\r\n0,\r\n1,\r\n2,\r\n3,4,5,6 7,\r\n8,\r\n9\r\n]",
1080 // -----------------------------^
1081 5,
1082 9,
1083 },
1084 // The JSON spec forbids unescaped ASCII control characters (including
1085 // line breaks) within a string, but our implementation is more lenient.
1086 {
1087 "[\"3\n1\" 4",
1088 // --------^
1089 2,
1090 4,
1091 },
1092 {
1093 "[\"3\r\n1\" 4",
1094 // ----------^
1095 2,
1096 4,
1097 },
1098 };
1099
1100 for (unsigned int i = 0; i < std::size(kCases); ++i) {
1101 auto test_case = kCases[i];
1102 SCOPED_TRACE(StringPrintf("case %u: \"%s\"", i, test_case.input));
1103
1104 auto root = JSONReader::ReadAndReturnValueWithError(
1105 test_case.input, JSON_PARSE_RFC | JSON_ALLOW_CONTROL_CHARS);
1106 EXPECT_FALSE(root.has_value());
1107 EXPECT_EQ(test_case.error_line, root.error().line);
1108 EXPECT_EQ(test_case.error_column, root.error().column);
1109 }
1110 }
1111
TEST_P(JSONReaderTest,ChromiumExtensions)1112 TEST_P(JSONReaderTest, ChromiumExtensions) {
1113 // All of these cases should parse with JSON_PARSE_CHROMIUM_EXTENSIONS but
1114 // fail with JSON_PARSE_RFC.
1115 const struct {
1116 // The JSON input.
1117 const char* input;
1118 // What JSON_* option permits this extension.
1119 int option;
1120 } kCases[] = {
1121 {"{ /* comment */ \"foo\": 3 }", JSON_ALLOW_COMMENTS},
1122 {"{ // comment\n \"foo\": 3 }", JSON_ALLOW_COMMENTS},
1123 {"[\"\\xAB\"]", JSON_ALLOW_X_ESCAPES},
1124 {"[\"\b\"]", JSON_ALLOW_CONTROL_CHARS},
1125 {"[\"\f\"]", JSON_ALLOW_CONTROL_CHARS},
1126 {"[\"\n\"]", JSON_ALLOW_CONTROL_CHARS},
1127 {"[\"\r\"]", JSON_ALLOW_CONTROL_CHARS},
1128 {"[\"\t\"]", JSON_ALLOW_CONTROL_CHARS},
1129 {"[\"\v\"]", JSON_ALLOW_CONTROL_CHARS},
1130 {"[\"\\v\"]", JSON_ALLOW_VERT_TAB},
1131 };
1132
1133 for (size_t i = 0; i < std::size(kCases); ++i) {
1134 SCOPED_TRACE(testing::Message() << "case " << i);
1135 const auto& test_case = kCases[i];
1136
1137 auto result = JSONReader::ReadAndReturnValueWithError(test_case.input,
1138 JSON_PARSE_RFC);
1139 EXPECT_FALSE(result.has_value());
1140
1141 result = JSONReader::ReadAndReturnValueWithError(
1142 test_case.input, JSON_PARSE_RFC | test_case.option);
1143 EXPECT_TRUE(result.has_value());
1144
1145 result = JSONReader::ReadAndReturnValueWithError(
1146 test_case.input, JSON_PARSE_CHROMIUM_EXTENSIONS);
1147 EXPECT_TRUE(result.has_value());
1148
1149 result = JSONReader::ReadAndReturnValueWithError(
1150 test_case.input, JSON_PARSE_CHROMIUM_EXTENSIONS & ~test_case.option);
1151 EXPECT_FALSE(result.has_value());
1152 }
1153 }
1154
TEST_P(JSONReaderTest,UsingRust)1155 TEST_P(JSONReaderTest, UsingRust) {
1156 ASSERT_EQ(JSONReader::UsingRust(), using_rust_);
1157 }
1158
1159 INSTANTIATE_TEST_SUITE_P(All,
1160 JSONReaderTest,
1161 #if BUILDFLAG(BUILD_RUST_JSON_READER)
1162 testing::Bool(),
1163 #else // BUILDFLAG(BUILD_RUST_JSON_READER)
1164 testing::Values(false),
1165 #endif // BUILDFLAG(BUILD_RUST_JSON_READER)
__anonc1092b710502(const testing::TestParamInfo<bool>& info) 1166 [](const testing::TestParamInfo<bool>& info) {
1167 return info.param ? "Rust" : "Cpp";
1168 });
1169
1170 } // namespace base
1171