// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/json/json_reader.h"

#include <stddef.h>

#include <array>
#include <cmath>
#include <string_view>
#include <utility>

#include "base/base_paths.h"
#include "base/compiler_specific.h"
#include "base/containers/heap_array.h"
#include "base/containers/span.h"
#include "base/files/file_util.h"
#include "base/logging.h"
#include "base/path_service.h"
#include "base/strings/string_view_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/gmock_expected_support.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/values.h"
#include "build/build_config.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/fuzztest/src/fuzztest/fuzztest.h"

// U+FFFD, REPLACEMENT CHARACTER, encoded in UTF-8.
#define U_FFFD "\xEF\xBF\xBD"

namespace {

// MSan will do a better job detecting over-read errors if the input is not
// nul-terminated on the heap. This will copy |input| to a new buffer owned by
// |owner|, returning a std::string_view to |owner|.
base::HeapArray<char> MakeNotNullTerminatedInput(const char* input) {
  // std::string_view is not nul terminated, so we won't be copying the nul
  // char.
  auto input_span = base::span(std::string_view(input));
  return base::HeapArray<char>::CopiedFrom(input_span);
}

}  // namespace

namespace base {

TEST(JSONReaderTest, Whitespace) {
  std::optional<Value> root =
      JSONReader::Read("   null   ", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_none());
}

TEST(JSONReaderTest, InvalidString) {
  // These are invalid because they do not represent a JSON value,
  // see https://tools.ietf.org/rfc/rfc8259.txt
  EXPECT_FALSE(JSONReader::Read("", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("nu", JSON_PARSE_CHROMIUM_EXTENSIONS));
}

TEST(JSONReaderTest, SimpleBool) {
  base::HistogramTester histograms;
  std::optional<Value> root =
      JSONReader::Read("true  ", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_bool());
  histograms.ExpectTotalCount("Security.JSONParser.ParsingTime", 1);
}

TEST(JSONReaderTest, EmbeddedComments) {
  std::optional<Value> root =
      JSONReader::Read("/* comment */null", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_none());
  root = JSONReader::Read("40 /* comment */", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_int());
  root = JSONReader::Read("true // comment", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_bool());
  // Comments in different contexts.
  root = JSONReader::Read("{   \"cheese\": 3\n\n   // Here's a comment\n}",
                          JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_dict());
  root = JSONReader::Read("{   \"cheese\": 3// Here's a comment\n}",
                          JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_dict());
  // Multiple comment markers.
  root =
      JSONReader::Read("{   \"cheese\": 3// Here's a comment // and another\n}",
                       JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_dict());
  root = JSONReader::Read("/* comment */\"sample string\"",
                          JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_string());
  EXPECT_EQ("sample string", root->GetString());
  root = JSONReader::Read("[1, /* comment, 2 ] */ \n 3]",
                          JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  Value::List* list = root->GetIfList();
  ASSERT_TRUE(list);
  ASSERT_EQ(2u, list->size());
  ASSERT_TRUE((*list)[0].is_int());
  EXPECT_EQ(1, (*list)[0].GetInt());
  ASSERT_TRUE((*list)[1].is_int());
  EXPECT_EQ(3, (*list)[1].GetInt());
  root = JSONReader::Read("[1, /*a*/2, 3]", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  list = root->GetIfList();
  ASSERT_TRUE(list);
  EXPECT_EQ(3u, (*list).size());
  root = JSONReader::Read("/* comment **/42", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_int());
  EXPECT_EQ(42, root->GetInt());
  root = JSONReader::Read(
      "/* comment **/\n"
      "// */ 43\n"
      "44",
      JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_int());
  EXPECT_EQ(44, root->GetInt());

  // At one point, this parsed successfully as the value three.
  EXPECT_FALSE(JSONReader::Read("/33", JSON_PARSE_CHROMIUM_EXTENSIONS));
}

TEST(JSONReaderTest, Ints) {
  std::optional<Value> root =
      JSONReader::Read("43", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_int());
  EXPECT_EQ(43, root->GetInt());
}

TEST(JSONReaderTest, NonDecimalNumbers) {
  // According to RFC 8259, oct, hex, and leading zeros are invalid JSON.
  EXPECT_FALSE(JSONReader::Read("043", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("0x43", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("00", JSON_PARSE_CHROMIUM_EXTENSIONS));
}

TEST(JSONReaderTest, NumberZero) {
  // Test 0 (which needs to be special cased because of the leading zero
  // clause).
  std::optional<Value> root =
      JSONReader::Read("0", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_int());
  EXPECT_EQ(0, root->GetInt());
}

TEST(JSONReaderTest, LargeIntPromotion) {
  // Numbers that overflow ints should succeed, being internally promoted to
  // storage as doubles
  std::optional<Value> root =
      JSONReader::Read("2147483648", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_double());
  EXPECT_DOUBLE_EQ(2147483648.0, root->GetDouble());
  root = JSONReader::Read("-2147483649", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_double());
  EXPECT_DOUBLE_EQ(-2147483649.0, root->GetDouble());
}

TEST(JSONReaderTest, LargerIntIsLossy) {
  // Parse LONG_MAX as a JSON number (not a JSON string). The result of the
  // parse is a base::Value, either a (32-bit) int or a (64-bit) double.
  // LONG_MAX would overflow an int and can only be approximated by a double.
  // In this case, parsing is lossy.
  const char* etc807 = "9223372036854775807";
  const char* etc808 = "9223372036854775808.000000";
  std::optional<Value> root =
      JSONReader::Read(etc807, JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_FALSE(root->is_int());
  ASSERT_TRUE(root->is_double());
  // We use StringPrintf instead of NumberToString, because the NumberToString
  // function does not let you specify the precision, and its default output,
  // "9.223372036854776e+18", isn't precise enough to see the lossiness.
  EXPECT_EQ(std::string(etc808), StringPrintf("%f", root->GetDouble()));
}

TEST(JSONReaderTest, Doubles) {
  std::optional<Value> root =
      JSONReader::Read("43.1", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_double());
  EXPECT_DOUBLE_EQ(43.1, root->GetDouble());

  root = JSONReader::Read("4.3e-1", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_double());
  EXPECT_DOUBLE_EQ(.43, root->GetDouble());

  root = JSONReader::Read("2.1e0", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_double());
  EXPECT_DOUBLE_EQ(2.1, root->GetDouble());

  root = JSONReader::Read("2.1e+0001", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_double());
  EXPECT_DOUBLE_EQ(21.0, root->GetDouble());

  root = JSONReader::Read("0.01", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_double());
  EXPECT_DOUBLE_EQ(0.01, root->GetDouble());

  root = JSONReader::Read("1.00", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_double());
  EXPECT_DOUBLE_EQ(1.0, root->GetDouble());

  // Some "parse to float64" implementations find this one tricky.
  // https://github.com/serde-rs/json/issues/707
  root =
      JSONReader::Read("122.416294033786585", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_double());
  EXPECT_DOUBLE_EQ(122.416294033786585, root->GetDouble());

  // This is syntaxtically valid, but out of range of a double.
  auto value =
      JSONReader::ReadAndReturnValueWithError("1e1000", JSON_PARSE_RFC);
  ASSERT_FALSE(value.has_value());
}

TEST(JSONReaderTest, FractionalNumbers) {
  // Fractional parts must have a digit before and after the decimal point.
  EXPECT_FALSE(JSONReader::Read("1.", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read(".1", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("1.e10", JSON_PARSE_CHROMIUM_EXTENSIONS));
}

TEST(JSONReaderTest, ExponentialNumbers) {
  // Exponent must have a digit following the 'e'.
  EXPECT_FALSE(JSONReader::Read("1e", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("1E", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("1e1.", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("1e1.0", JSON_PARSE_CHROMIUM_EXTENSIONS));
}

TEST(JSONReaderTest, InvalidInfNAN) {
  // The largest finite double is roughly 1.8e308.
  EXPECT_FALSE(JSONReader::Read("1e1000", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("-1e1000", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("NaN", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("nan", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("inf", JSON_PARSE_CHROMIUM_EXTENSIONS));
}

TEST(JSONReaderTest, InvalidNumbers) {
  EXPECT_TRUE(JSONReader::Read("4.3", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("4.", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("4.3.1", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("4e3.1", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("4.a", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("42a", JSON_PARSE_CHROMIUM_EXTENSIONS));
}

TEST(JSONReaderTest, Zeroes) {
  std::optional<Value> root =
      JSONReader::Read("0", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_int());
  EXPECT_DOUBLE_EQ(0, root->GetInt());

  root = JSONReader::Read("0.0", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_double());
  EXPECT_DOUBLE_EQ(0.0, root->GetDouble());
  EXPECT_FALSE(std::signbit(root->GetDouble()));

  root = JSONReader::Read("-0", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_double());
  EXPECT_DOUBLE_EQ(0.0, root->GetDouble());
  EXPECT_TRUE(std::signbit(root->GetDouble()));

  root = JSONReader::Read("-0.0", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_double());
  EXPECT_DOUBLE_EQ(-0.0, root->GetDouble());
  EXPECT_TRUE(std::signbit(root->GetDouble()));
}

TEST(JSONReaderTest, SimpleString) {
  std::optional<Value> root =
      JSONReader::Read("\"hello world\"", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_string());
  EXPECT_EQ("hello world", root->GetString());
}

TEST(JSONReaderTest, EmptyString) {
  std::optional<Value> root =
      JSONReader::Read("\"\"", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_string());
  EXPECT_EQ("", root->GetString());
}

TEST(JSONReaderTest, BasicStringEscapes) {
  std::optional<Value> root = JSONReader::Read(
      "\" \\\"\\\\\\/\\b\\f\\n\\r\\t\"", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_string());
  EXPECT_EQ(" \"\\/\b\f\n\r\t", root->GetString());
}

TEST(JSONReaderTest, UnicodeEscapes) {
  // Test hex and unicode escapes including the null character.
  std::optional<Value> root = JSONReader::Read(
      "\"\\x41\\xFF\\x00\\u1234\\u0000\"", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_string());
  const std::string& str_val = root->GetString();
  EXPECT_EQ(std::wstring(L"A\x00FF\0\x1234\0", 5), UTF8ToWide(str_val));

  // The contents of a Unicode escape may only be four hex chars. Previously the
  // parser accepted things like "0x01" and "0X01".
  EXPECT_FALSE(JSONReader::Read("\"\\u0x12\"", JSON_PARSE_CHROMIUM_EXTENSIONS));

  // Surrogate pairs are allowed in JSON.
  EXPECT_TRUE(JSONReader::Read("\"\\uD834\\uDD1E\"",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+1D11E
}

TEST(JSONReaderTest, InvalidStrings) {
  EXPECT_FALSE(
      JSONReader::Read("\"no closing quote", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("\"\\z invalid escape char\"",
                                JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("\"\\xAQ invalid hex code\"",
                                JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("not enough hex chars\\x1\"",
                                JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("\"not enough escape chars\\u123\"",
                                JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("\"extra backslash at end of input\\\"",
                                JSON_PARSE_CHROMIUM_EXTENSIONS));
}

TEST(JSONReaderTest, BasicArray) {
  std::optional<Value> root =
      JSONReader::Read("[true, false, null]", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  Value::List* list = root->GetIfList();
  ASSERT_TRUE(list);
  EXPECT_EQ(3U, list->size());

  // Test with trailing comma.  Should be parsed the same as above.
  std::optional<Value> root2 =
      JSONReader::Read("[true, false, null, ]", JSON_ALLOW_TRAILING_COMMAS);
  ASSERT_TRUE(root2);
  EXPECT_EQ(*list, *root2);
}

TEST(JSONReaderTest, EmptyArray) {
  std::optional<Value> value =
      JSONReader::Read("[]", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(value);
  Value::List* list = value->GetIfList();
  ASSERT_TRUE(list);
  EXPECT_TRUE(list->empty());
}

TEST(JSONReaderTest, CompleteArray) {
  std::optional<Value> value = JSONReader::Read("[\"a\", 3, 4.56, null]",
                                                JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(value);
  Value::List* list = value->GetIfList();
  ASSERT_TRUE(list);
  EXPECT_EQ(4U, list->size());
}

TEST(JSONReaderTest, NestedArrays) {
  std::optional<Value> value = JSONReader::Read(
      "[[true], [], {\"smell\": \"nice\",\"taste\": \"yummy\" }, [false, [], "
      "[null]], null]",
      JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(value);
  Value::List* list = value->GetIfList();
  ASSERT_TRUE(list);
  EXPECT_EQ(5U, list->size());

  // Lots of trailing commas.
  std::optional<Value> root2 = JSONReader::Read(
      "[[true], [], {\"smell\": \"nice\",\"taste\": \"yummy\" }, [false, [], "
      "[null, ]  , ], null,]",
      JSON_ALLOW_TRAILING_COMMAS);
  ASSERT_TRUE(root2);
  EXPECT_EQ(*list, *root2);
}

TEST(JSONReaderTest, InvalidArrays) {
  // Missing close brace.
  EXPECT_FALSE(JSONReader::Read("[[true], [], [false, [], [null]], null",
                                JSON_PARSE_CHROMIUM_EXTENSIONS));

  // Too many commas.
  EXPECT_FALSE(
      JSONReader::Read("[true,, null]", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("[true,, null]", JSON_ALLOW_TRAILING_COMMAS));

  // No commas.
  EXPECT_FALSE(JSONReader::Read("[true null]", JSON_PARSE_CHROMIUM_EXTENSIONS));

  // Trailing comma.
  EXPECT_FALSE(JSONReader::Read("[true,]", JSON_PARSE_CHROMIUM_EXTENSIONS));
}

TEST(JSONReaderTest, ArrayTrailingComma) {
  // Valid if we set |allow_trailing_comma| to true.
  std::optional<Value> value =
      JSONReader::Read("[true,]", JSON_ALLOW_TRAILING_COMMAS);
  ASSERT_TRUE(value);
  Value::List* list = value->GetIfList();
  ASSERT_TRUE(list);
  ASSERT_EQ(1U, list->size());
  const Value& value1 = (*list)[0];
  ASSERT_TRUE(value1.is_bool());
  EXPECT_TRUE(value1.GetBool());
}

TEST(JSONReaderTest, ArrayTrailingCommaNoEmptyElements) {
  // Don't allow empty elements, even if |allow_trailing_comma| is
  // true.
  EXPECT_FALSE(JSONReader::Read("[,]", JSON_ALLOW_TRAILING_COMMAS));
  EXPECT_FALSE(JSONReader::Read("[true,,]", JSON_ALLOW_TRAILING_COMMAS));
  EXPECT_FALSE(JSONReader::Read("[,true,]", JSON_ALLOW_TRAILING_COMMAS));
  EXPECT_FALSE(JSONReader::Read("[true,,false]", JSON_ALLOW_TRAILING_COMMAS));
}

TEST(JSONReaderTest, EmptyDictionary) {
  std::optional<Value> dict_val =
      JSONReader::Read("{}", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(dict_val);
  ASSERT_TRUE(dict_val->is_dict());
}

TEST(JSONReaderTest, CompleteDictionary) {
  std::optional<Value> root1 = JSONReader::Read(
      "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", \"bool\": "
      "false, \"more\": {} }",
      JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root1);
  const Value::Dict* root1_dict = root1->GetIfDict();
  ASSERT_TRUE(root1_dict);
  auto double_val = root1_dict->FindDouble("number");
  ASSERT_TRUE(double_val);
  EXPECT_DOUBLE_EQ(9.87654321, *double_val);
  const Value* null_val = root1_dict->Find("null");
  ASSERT_TRUE(null_val);
  EXPECT_TRUE(null_val->is_none());
  const std::string* str_val = root1_dict->FindString("S");
  ASSERT_TRUE(str_val);
  EXPECT_EQ("str", *str_val);
  auto bool_val = root1_dict->FindBool("bool");
  ASSERT_TRUE(bool_val);
  ASSERT_FALSE(*bool_val);

  std::optional<Value> root2 = JSONReader::Read(
      "{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\", \"bool\": "
      "false, \"more\": {},}",
      JSON_PARSE_CHROMIUM_EXTENSIONS | JSON_ALLOW_TRAILING_COMMAS);
  ASSERT_TRUE(root2);
  Value::Dict* root2_dict = root2->GetIfDict();
  ASSERT_TRUE(root2_dict);
  EXPECT_EQ(*root1_dict, *root2_dict);

  // Test newline equivalence.
  root2 = JSONReader::Read(
      "{\n"
      "  \"number\":9.87654321,\n"
      "  \"null\":null,\n"
      "  \"\\x53\":\"str\",\n"
      "  \"bool\": false,\n"
      "  \"more\": {},\n"
      "}\n",
      JSON_PARSE_CHROMIUM_EXTENSIONS | JSON_ALLOW_TRAILING_COMMAS);
  ASSERT_TRUE(root2);
  root2_dict = root2->GetIfDict();
  ASSERT_TRUE(root2);
  EXPECT_EQ(*root1_dict, *root2_dict);

  root2 = JSONReader::Read(
      "{\r\n"
      "  \"number\":9.87654321,\r\n"
      "  \"null\":null,\r\n"
      "  \"\\x53\":\"str\",\r\n"
      "  \"bool\": false,\r\n"
      "  \"more\": {},\r\n"
      "}\r\n",
      JSON_PARSE_CHROMIUM_EXTENSIONS | JSON_ALLOW_TRAILING_COMMAS);
  ASSERT_TRUE(root2);
  root2_dict = root2->GetIfDict();
  ASSERT_TRUE(root2_dict);
  EXPECT_EQ(*root1_dict, *root2_dict);
}

TEST(JSONReaderTest, NestedDictionaries) {
  std::optional<Value> root1 = JSONReader::Read(
      "{\"inner\":{\"array\":[true, 3, 4.56, null]},\"false\":false,\"d\":{}}",
      JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root1);
  const base::Value::Dict* root1_dict = root1->GetIfDict();
  ASSERT_TRUE(root1_dict);
  const Value::Dict* inner_dict = root1_dict->FindDict("inner");
  ASSERT_TRUE(inner_dict);
  const Value::List* inner_array = inner_dict->FindList("array");
  ASSERT_TRUE(inner_array);
  EXPECT_EQ(4U, inner_array->size());
  auto bool_value = root1_dict->FindBool("false");
  ASSERT_TRUE(bool_value);
  EXPECT_FALSE(*bool_value);
  inner_dict = root1_dict->FindDict("d");
  EXPECT_TRUE(inner_dict);

  std::optional<Value> root2 = JSONReader::Read(
      "{\"inner\": {\"array\":[true, 3, 4.56, null] , "
      "},\"false\":false,\"d\":{},}",
      JSON_ALLOW_TRAILING_COMMAS);
  ASSERT_TRUE(root2);
  EXPECT_EQ(*root1_dict, *root2);
}

TEST(JSONReaderTest, DictionaryKeysWithPeriods) {
  std::optional<Value> root =
      JSONReader::Read("{\"a.b\":3,\"c\":2,\"d.e.f\":{\"g.h.i.j\":1}}",
                       JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  Value::Dict* root_dict = root->GetIfDict();
  ASSERT_TRUE(root_dict);

  auto integer_value = root_dict->FindInt("a.b");
  ASSERT_TRUE(integer_value);
  EXPECT_EQ(3, *integer_value);
  integer_value = root_dict->FindInt("c");
  ASSERT_TRUE(integer_value);
  EXPECT_EQ(2, *integer_value);
  const Value::Dict* inner_dict = root_dict->FindDict("d.e.f");
  ASSERT_TRUE(inner_dict);
  EXPECT_EQ(1U, inner_dict->size());
  integer_value = inner_dict->FindInt("g.h.i.j");
  ASSERT_TRUE(integer_value);
  EXPECT_EQ(1, *integer_value);

  root = JSONReader::Read("{\"a\":{\"b\":2},\"a.b\":1}",
                          JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  root_dict = root->GetIfDict();
  ASSERT_TRUE(root_dict);
  const Value* integer_path_value = root_dict->FindByDottedPath("a.b");
  ASSERT_TRUE(integer_path_value);
  EXPECT_EQ(2, integer_path_value->GetInt());
  integer_value = root_dict->FindInt("a.b");
  ASSERT_TRUE(integer_value);
  EXPECT_EQ(1, *integer_value);
}

TEST(JSONReaderTest, DuplicateKeys) {
  std::optional<Value> root = JSONReader::Read("{\"x\":1,\"x\":2,\"y\":3}",
                                               JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  const Value::Dict* root_dict = root->GetIfDict();
  ASSERT_TRUE(root_dict);

  auto integer_value = root_dict->FindInt("x");
  ASSERT_TRUE(integer_value);
  EXPECT_EQ(2, *integer_value);
}

TEST(JSONReaderTest, InvalidDictionaries) {
  // No closing brace.
  EXPECT_FALSE(
      JSONReader::Read("{\"a\": true", JSON_PARSE_CHROMIUM_EXTENSIONS));

  // Keys must be quoted strings.
  EXPECT_FALSE(JSONReader::Read("{foo:true}", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(
      JSONReader::Read("{1234: false}", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("{:false}", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("{ , }", JSON_PARSE_CHROMIUM_EXTENSIONS));

  // Trailing comma.
  EXPECT_FALSE(
      JSONReader::Read("{\"a\":true,}", JSON_PARSE_CHROMIUM_EXTENSIONS));

  // Too many commas.
  EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}",
                                JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}",
                                JSON_ALLOW_TRAILING_COMMAS));

  // No separator.
  EXPECT_FALSE(
      JSONReader::Read("{\"a\" \"b\"}", JSON_PARSE_CHROMIUM_EXTENSIONS));

  // Lone comma.
  EXPECT_FALSE(JSONReader::Read("{,}", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(JSONReader::Read("{,}", JSON_ALLOW_TRAILING_COMMAS));
  EXPECT_FALSE(JSONReader::Read("{\"a\":true,,}", JSON_ALLOW_TRAILING_COMMAS));
  EXPECT_FALSE(JSONReader::Read("{,\"a\":true}", JSON_ALLOW_TRAILING_COMMAS));
  EXPECT_FALSE(JSONReader::Read("{\"a\":true,,\"b\":false}",
                                JSON_ALLOW_TRAILING_COMMAS));
}

TEST(JSONReaderTest, StackOverflow) {
  std::string evil(1000000, '[');
  evil.append(std::string(1000000, ']'));
  EXPECT_FALSE(JSONReader::Read(evil, JSON_PARSE_CHROMIUM_EXTENSIONS));

  // A few thousand adjacent lists is fine.
  std::string not_evil("[");
  not_evil.reserve(15010);
  for (int i = 0; i < 5000; ++i) {
    not_evil.append("[],");
  }
  not_evil.append("[]]");
  std::optional<Value> value =
      JSONReader::Read(not_evil, JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(value);
  Value::List* list = value->GetIfList();
  ASSERT_TRUE(list);
  EXPECT_EQ(5001U, list->size());
}

TEST(JSONReaderTest, UTF8Input) {
  std::optional<Value> root = JSONReader::Read("\"\xe7\xbd\x91\xe9\xa1\xb5\"",
                                               JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_string());
  const std::string& str_val = root->GetString();
  EXPECT_EQ(L"\x7f51\x9875", UTF8ToWide(str_val));

  root = JSONReader::Read("{\"path\": \"/tmp/\xc3\xa0\xc3\xa8\xc3\xb2.png\"}",
                          JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  const Value::Dict* root_dict = root->GetIfDict();
  ASSERT_TRUE(root_dict);
  const std::string* maybe_string = root_dict->FindString("path");
  ASSERT_TRUE(maybe_string);
  EXPECT_EQ("/tmp/\xC3\xA0\xC3\xA8\xC3\xB2.png", *maybe_string);

  // JSON can encode non-characters.
  const char* const noncharacters[] = {
      "\"\xEF\xB7\x90\"",      // U+FDD0
      "\"\xEF\xB7\x9F\"",      // U+FDDF
      "\"\xEF\xB7\xAF\"",      // U+FDEF
      "\"\xEF\xBF\xBE\"",      // U+FFFE
      "\"\xEF\xBF\xBF\"",      // U+FFFF
      "\"\xF0\x9F\xBF\xBE\"",  // U+01FFFE
      "\"\xF0\x9F\xBF\xBF\"",  // U+01FFFF
      "\"\xF0\xAF\xBF\xBE\"",  // U+02FFFE
      "\"\xF0\xAF\xBF\xBF\"",  // U+02FFFF
      "\"\xF0\xBF\xBF\xBE\"",  // U+03FFFE
      "\"\xF0\xBF\xBF\xBF\"",  // U+03FFFF
      "\"\xF1\x8F\xBF\xBE\"",  // U+04FFFE
      "\"\xF1\x8F\xBF\xBF\"",  // U+04FFFF
      "\"\xF1\x9F\xBF\xBE\"",  // U+05FFFE
      "\"\xF1\x9F\xBF\xBF\"",  // U+05FFFF
      "\"\xF1\xAF\xBF\xBE\"",  // U+06FFFE
      "\"\xF1\xAF\xBF\xBF\"",  // U+06FFFF
      "\"\xF1\xBF\xBF\xBE\"",  // U+07FFFE
      "\"\xF1\xBF\xBF\xBF\"",  // U+07FFFF
      "\"\xF2\x8F\xBF\xBE\"",  // U+08FFFE
      "\"\xF2\x8F\xBF\xBF\"",  // U+08FFFF
      "\"\xF2\x9F\xBF\xBE\"",  // U+09FFFE
      "\"\xF2\x9F\xBF\xBF\"",  // U+09FFFF
      "\"\xF2\xAF\xBF\xBE\"",  // U+0AFFFE
      "\"\xF2\xAF\xBF\xBF\"",  // U+0AFFFF
      "\"\xF2\xBF\xBF\xBE\"",  // U+0BFFFE
      "\"\xF2\xBF\xBF\xBF\"",  // U+0BFFFF
      "\"\xF3\x8F\xBF\xBE\"",  // U+0CFFFE
      "\"\xF3\x8F\xBF\xBF\"",  // U+0CFFFF
      "\"\xF3\x9F\xBF\xBE\"",  // U+0DFFFE
      "\"\xF3\x9F\xBF\xBF\"",  // U+0DFFFF
      "\"\xF3\xAF\xBF\xBE\"",  // U+0EFFFE
      "\"\xF3\xAF\xBF\xBF\"",  // U+0EFFFF
      "\"\xF3\xBF\xBF\xBE\"",  // U+0FFFFE
      "\"\xF3\xBF\xBF\xBF\"",  // U+0FFFFF
      "\"\xF4\x8F\xBF\xBE\"",  // U+10FFFE
      "\"\xF4\x8F\xBF\xBF\"",  // U+10FFFF
  };
  for (auto* noncharacter : noncharacters) {
    root = JSONReader::Read(noncharacter, JSON_PARSE_CHROMIUM_EXTENSIONS);
    ASSERT_TRUE(root);
    ASSERT_TRUE(root->is_string());
    UNSAFE_TODO(
        EXPECT_EQ(std::string(noncharacter + 1, strlen(noncharacter) - 2),
                  root->GetString()));
  }
}

TEST(JSONReaderTest, InvalidUTF8Input) {
  EXPECT_FALSE(JSONReader::Read("\"345\xb0\xa1\xb0\xa2\"",
                                JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(
      JSONReader::Read("\"123\xc0\x81\"", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(
      JSONReader::Read("\"abc\xc0\xae\"", JSON_PARSE_CHROMIUM_EXTENSIONS));
}

TEST(JSONReaderTest, UTF16Escapes) {
  std::optional<Value> root =
      JSONReader::Read("\"\\u20ac3,14\"", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_string());
  EXPECT_EQ(
      "\xe2\x82\xac"
      "3,14",
      root->GetString());

  root = JSONReader::Read("\"\\ud83d\\udca9\\ud83d\\udc6c\"",
                          JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_string());
  EXPECT_EQ("\xf0\x9f\x92\xa9\xf0\x9f\x91\xac", root->GetString());
}

TEST(JSONReaderTest, InvalidUTF16Escapes) {
  const char* const cases[] = {
      "\"\\u123\"",          // Invalid scalar.
      "\"\\ud83d\"",         // Invalid scalar.
      "\"\\u$%@!\"",         // Invalid scalar.
      "\"\\uzz89\"",         // Invalid scalar.
      "\"\\ud83d\\udca\"",   // Invalid lower surrogate.
      "\"\\ud83d\\ud83d\"",  // Invalid lower surrogate.
      "\"\\ud83d\\uaaaZ\"",  // Invalid lower surrogate.
      "\"\\ud83foo\"",       // No lower surrogate.
      "\"\\ud83d\\foo\"",    // No lower surrogate.
      "\"\\ud83\\foo\"",     // Invalid upper surrogate.
      "\"\\ud83d\\u1\"",     // No lower surrogate.
      "\"\\ud83\\u1\"",      // Invalid upper surrogate.
  };
  std::optional<Value> root;
  for (auto* i : cases) {
    root = JSONReader::Read(i, JSON_PARSE_CHROMIUM_EXTENSIONS);
    EXPECT_FALSE(root) << i;
  }
}

TEST(JSONReaderTest, LiteralRoots) {
  std::optional<Value> root =
      JSONReader::Read("null", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  EXPECT_TRUE(root->is_none());

  root = JSONReader::Read("true", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_bool());
  EXPECT_TRUE(root->GetBool());

  root = JSONReader::Read("10", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_int());
  EXPECT_EQ(10, root->GetInt());

  root = JSONReader::Read("\"root\"", JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_TRUE(root);
  ASSERT_TRUE(root->is_string());
  EXPECT_EQ("root", root->GetString());
}

TEST(JSONReaderTest, ReadFromFile) {
  FilePath path;
  ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &path));
  path = path.AppendASCII("json");
  ASSERT_TRUE(base::PathExists(path));

  std::string input;
  ASSERT_TRUE(ReadFileToString(path.AppendASCII("bom_feff.json"), &input));

  EXPECT_THAT(
      JSONReader::ReadAndReturnValueWithError(input,
                                              JSON_PARSE_CHROMIUM_EXTENSIONS),
      base::test::ValueIs(::testing::Property(&base::Value::is_dict, true)));
}

// Tests that the root of a JSON object can be deleted safely while its
// children outlive it.
TEST(JSONReaderTest, StringOptimizations) {
  Value dict_literal_0;
  Value dict_literal_1;
  Value dict_string_0;
  Value dict_string_1;
  Value list_value_0;
  Value list_value_1;

  {
    std::optional<Value> root = JSONReader::Read(
        "{"
        "  \"test\": {"
        "    \"foo\": true,"
        "    \"bar\": 3.14,"
        "    \"baz\": \"bat\","
        "    \"moo\": \"cow\""
        "  },"
        "  \"list\": ["
        "    \"a\","
        "    \"b\""
        "  ]"
        "}",
        JSON_PARSE_RFC);
    ASSERT_TRUE(root);
    Value::Dict* root_dict = root->GetIfDict();
    ASSERT_TRUE(root_dict);

    Value::Dict* dict = root_dict->FindDict("test");
    ASSERT_TRUE(dict);
    Value::List* list = root_dict->FindList("list");
    ASSERT_TRUE(list);

    Value* to_move = dict->Find("foo");
    ASSERT_TRUE(to_move);
    dict_literal_0 = std::move(*to_move);
    to_move = dict->Find("bar");
    ASSERT_TRUE(to_move);
    dict_literal_1 = std::move(*to_move);
    to_move = dict->Find("baz");
    ASSERT_TRUE(to_move);
    dict_string_0 = std::move(*to_move);
    to_move = dict->Find("moo");
    ASSERT_TRUE(to_move);
    dict_string_1 = std::move(*to_move);
    ASSERT_TRUE(dict->Remove("foo"));
    ASSERT_TRUE(dict->Remove("bar"));
    ASSERT_TRUE(dict->Remove("baz"));
    ASSERT_TRUE(dict->Remove("moo"));

    ASSERT_EQ(2u, list->size());
    list_value_0 = std::move((*list)[0]);
    list_value_1 = std::move((*list)[1]);
    list->clear();
  }

  ASSERT_TRUE(dict_literal_0.is_bool());
  EXPECT_TRUE(dict_literal_0.GetBool());

  ASSERT_TRUE(dict_literal_1.is_double());
  EXPECT_EQ(3.14, dict_literal_1.GetDouble());

  ASSERT_TRUE(dict_string_0.is_string());
  EXPECT_EQ("bat", dict_string_0.GetString());

  ASSERT_TRUE(dict_string_1.is_string());
  EXPECT_EQ("cow", dict_string_1.GetString());

  ASSERT_TRUE(list_value_0.is_string());
  EXPECT_EQ("a", list_value_0.GetString());
  ASSERT_TRUE(list_value_1.is_string());
  EXPECT_EQ("b", list_value_1.GetString());
}

// A smattering of invalid JSON designed to test specific portions of the
// parser implementation against buffer overflow. Best run with DCHECKs so
// that the one in NextChar fires.
TEST(JSONReaderTest, InvalidSanity) {
  const auto kInvalidJson = std::to_array<const char*>({
      "/* test *",
      "{\"foo\"",
      "{\"foo\":",
      "  [",
      "\"\\u123g\"",
      "{\n\"eh:\n}",
  });

  for (size_t i = 0; i < std::size(kInvalidJson); ++i) {
    LOG(INFO) << "Sanity test " << i << ": <" << kInvalidJson[i] << ">";
    auto root = JSONReader::ReadAndReturnValueWithError(
        kInvalidJson[i], JSON_PARSE_CHROMIUM_EXTENSIONS);
    EXPECT_FALSE(root.has_value());
    EXPECT_NE("", root.error().message);
  }
}

TEST(JSONReaderTest, IllegalTrailingNull) {
  const auto json = std::to_array<char>({'"', 'n', 'u', 'l', 'l', '"', '\0'});
  std::string json_string(json.data(), sizeof(json));
  auto root = JSONReader::ReadAndReturnValueWithError(
      json_string, JSON_PARSE_CHROMIUM_EXTENSIONS);
  EXPECT_FALSE(root.has_value());
  EXPECT_NE("", root.error().message);
}

TEST(JSONReaderTest, ASCIIControlCodes) {
  // A literal NUL byte or a literal new line, in a JSON string, should be
  // rejected. RFC 8259 section 7 says "the characters that MUST be escaped
  // [include]... the control characters (U+0000 through U+001F)".
  //
  // Currently, we accept \r and \n in JSON strings because they are widely used
  // and somewhat useful (especially when nesting JSON messages), but reject all
  // other control characters.
  {
    const char json[] = "\"a\rn\nc\"";
    auto root = JSONReader::Read(json, JSON_PARSE_CHROMIUM_EXTENSIONS);
    ASSERT_TRUE(root);
    ASSERT_TRUE(root->is_string());
    EXPECT_EQ(5u, root->GetString().length());
  }

  {
    // Replace the \r with a disallowed \f, and require parsing to fail:
    const char json[] = "\"a\fn\nc\"";
    auto root = JSONReader::ReadAndReturnValueWithError(
        json, JSON_PARSE_CHROMIUM_EXTENSIONS);
    EXPECT_FALSE(root.has_value());
    EXPECT_NE("", root.error().message);
  }
}

TEST(JSONReaderTest, MaxNesting) {
  std::string json(R"({"outer": { "inner": {"foo": true}}})");
  EXPECT_FALSE(JSONReader::Read(json, JSON_PARSE_RFC, 3));
  EXPECT_TRUE(JSONReader::Read(json, JSON_PARSE_RFC, 4));
}

TEST(JSONReaderTest, Decode4ByteUtf8Char) {
  // kUtf8Data contains a 4 byte unicode character (a smiley!) that JSONReader
  // should be able to handle. The UTF-8 encoding of U+1F607 SMILING FACE WITH
  // HALO is "\xF0\x9F\x98\x87".
  const char kUtf8Data[] = "[\"😇\",[],[],[],{\"google:suggesttype\":[]}]";
  std::optional<Value> root = JSONReader::Read(kUtf8Data, JSON_PARSE_RFC);
  ASSERT_TRUE(root);
  Value::List* list = root->GetIfList();
  ASSERT_TRUE(list);
  ASSERT_EQ(5u, list->size());
  ASSERT_TRUE((*list)[0].is_string());
  EXPECT_EQ("\xF0\x9F\x98\x87", (*list)[0].GetString());
}

TEST(JSONReaderTest, DecodeUnicodeNonCharacter) {
  // Tests Unicode code points (encoded as escaped UTF-16) that are not valid
  // characters.
  EXPECT_TRUE(JSONReader::Read("[\"\\uFDD0\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+FDD0
  EXPECT_TRUE(JSONReader::Read("[\"\\uFDDF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+FDDF
  EXPECT_TRUE(JSONReader::Read("[\"\\uFDEF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+FDEF
  EXPECT_TRUE(JSONReader::Read("[\"\\uFFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+FFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uFFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+FFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uD83F\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+01FFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uD83F\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+01FFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uD87F\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+02FFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uD87F\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+02FFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uD8BF\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+03FFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uD8BF\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+03FFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uD8FF\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+04FFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uD8FF\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+04FFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uD93F\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+05FFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uD93F\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+05FFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uD97F\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+06FFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uD97F\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+06FFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uD9BF\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+07FFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uD9BF\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+07FFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uD9FF\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+08FFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uD9FF\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+08FFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uDA3F\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+09FFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uDA3F\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+09FFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uDA7F\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+0AFFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uDA7F\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+0AFFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uDABF\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+0BFFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uDABF\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+0BFFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uDAFF\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+0CFFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uDAFF\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+0CFFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uDB3F\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+0DFFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uDB3F\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+0DFFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uDB7F\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+0EFFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uDB7F\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+0EFFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uDBBF\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+0FFFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uDBBF\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+0FFFFF
  EXPECT_TRUE(JSONReader::Read("[\"\\uDBFF\\uDFFE\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+10FFFE
  EXPECT_TRUE(JSONReader::Read("[\"\\uDBFF\\uDFFF\"]",
                               JSON_PARSE_CHROMIUM_EXTENSIONS));  // U+10FFFF
}

TEST(JSONReaderTest, DecodeNegativeEscapeSequence) {
  EXPECT_FALSE(JSONReader::Read("[\"\\x-A\"]", JSON_PARSE_CHROMIUM_EXTENSIONS));
  EXPECT_FALSE(
      JSONReader::Read("[\"\\u-00A\"]", JSON_PARSE_CHROMIUM_EXTENSIONS));
}

// Verifies invalid code points are replaced.
TEST(JSONReaderTest, ReplaceInvalidCharacters) {
  // U+D800 is a lone high surrogate.
  const std::string invalid_high = "\"\xED\xA0\x80\"";
  std::optional<Value> value =
      JSONReader::Read(invalid_high, JSON_REPLACE_INVALID_CHARACTERS);
  ASSERT_TRUE(value);
  ASSERT_TRUE(value->is_string());
  // Expect three U+FFFD (one for each UTF-8 byte in the invalid code point).
  EXPECT_EQ(U_FFFD U_FFFD U_FFFD, value->GetString());

  // U+DFFF is a lone low surrogate.
  const std::string invalid_low = "\"\xED\xBF\xBF\"";
  value = JSONReader::Read(invalid_low, JSON_REPLACE_INVALID_CHARACTERS);
  ASSERT_TRUE(value);
  ASSERT_TRUE(value->is_string());
  // Expect three U+FFFD (one for each UTF-8 byte in the invalid code point).
  EXPECT_EQ(U_FFFD U_FFFD U_FFFD, value->GetString());
}

TEST(JSONReaderTest, ReplaceInvalidUTF16EscapeSequence) {
  // U+D800 is a lone high surrogate.
  const std::string invalid_high = "\"_\\uD800_\"";
  std::optional<Value> value =
      JSONReader::Read(invalid_high, JSON_REPLACE_INVALID_CHARACTERS);
  ASSERT_TRUE(value);
  ASSERT_TRUE(value->is_string());
  EXPECT_EQ("_" U_FFFD "_", value->GetString());

  // U+DFFF is a lone low surrogate.
  const std::string invalid_low = "\"_\\uDFFF_\"";
  value = JSONReader::Read(invalid_low, JSON_REPLACE_INVALID_CHARACTERS);
  ASSERT_TRUE(value);
  ASSERT_TRUE(value->is_string());
  EXPECT_EQ("_" U_FFFD "_", value->GetString());
}

TEST(JSONReaderTest, InvalidUTF16HighSurrogates) {
  // U+dbaa is a high surrogate and expects a low surrogate, which U+001e is
  // not, so the entire surrogate pair should be replaced by
  // REPLACEMENT_CHARACTER.
  const std::string surrogate_and_dquote = R"("\udbaa\u001e")";
  std::optional<Value> value =
      JSONReader::Read(surrogate_and_dquote, JSON_REPLACE_INVALID_CHARACTERS);
  ASSERT_TRUE(value);
  ASSERT_TRUE(value->is_string());
  EXPECT_EQ("\xEF\xBF\xBD", value->GetString());

  // However, when not replacing invalid characters, the entire parse is
  // invalid.
  value =
      JSONReader::Read(surrogate_and_dquote, JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_FALSE(value);
}

TEST(JSONReaderTest, InvalidUTF16HighSurrogatesAndEscapes) {
  // U+dbaa is a lone high surrogate, and should be replaced with
  // REPLACEMENT_CHARACTER and not affect interpretation of the following `\`
  // character as a part of the escape sequence `\"`.
  const std::string surrogate_and_dquote = R"("\udbaa\"abc")";
  std::optional<Value> value =
      JSONReader::Read(surrogate_and_dquote, JSON_REPLACE_INVALID_CHARACTERS);
  ASSERT_TRUE(value);
  ASSERT_TRUE(value->is_string());
  EXPECT_EQ(U_FFFD "\"abc", value->GetString());

  // However, when not replacing invalid characters, the entire parse is
  // invalid.
  value =
      JSONReader::Read(surrogate_and_dquote, JSON_PARSE_CHROMIUM_EXTENSIONS);
  ASSERT_FALSE(value);
}

TEST(JSONReaderTest, ParseNumberErrors) {
  struct Cases {
    const char* input;
    bool parse_success;
    double value;
  };
  const auto kCases = std::to_array<Cases>({
      // clang-format off
      {"1", true, 1},
      {"2.", false, 0},
      {"42", true, 42},
      {"6e", false, 0},
      {"43e2", true, 4300},
      {"43e-", false, 0},
      {"9e-3", true, 0.009},
      {"2e+", false, 0},
      {"2e+2", true, 200},
      // clang-format on
  });

  for (unsigned int i = 0; i < std::size(kCases); ++i) {
    auto test_case = kCases[i];
    SCOPED_TRACE(StringPrintf("case %u: \"%s\"", i, test_case.input));

    HeapArray<char> input = MakeNotNullTerminatedInput(test_case.input);

    std::optional<Value> result =
        JSONReader::Read(as_string_view(input), JSON_PARSE_CHROMIUM_EXTENSIONS);
    EXPECT_EQ(test_case.parse_success, result.has_value());

    if (!result) {
      continue;
    }

    ASSERT_TRUE(result->is_double() || result->is_int());
    EXPECT_EQ(test_case.value, result->GetDouble());
  }
}

TEST(JSONReaderTest, UnterminatedInputs) {
  const auto kCases = std::to_array<const char*>({
      // clang-format off
      "/",
      "//",
      "/*",
      "\"xxxxxx",
      "\"",
      "{   ",
      "[\t",
      "tru",
      "fals",
      "nul",
      "\"\\x",
      "\"\\x2",
      "\"\\u123",
      "\"\\uD803\\u",
      "\"\\",
      "\"\\/",
      // clang-format on
  });

  for (unsigned int i = 0; i < std::size(kCases); ++i) {
    auto* test_case = kCases[i];
    SCOPED_TRACE(StringPrintf("case %u: \"%s\"", i, test_case));

    HeapArray<char> input = MakeNotNullTerminatedInput(test_case);

    EXPECT_FALSE(JSONReader::Read(as_string_view(input),
                                  JSON_PARSE_CHROMIUM_EXTENSIONS));
  }
}

TEST(JSONReaderTest, LineColumnCounting) {
  struct Cases {
    const char* input;
    int error_line;
    int error_column;
  };
  const auto kCases = std::to_array<Cases>({
      // For all but the "q_is_not_etc" case, the error (indicated by ^ in the
      // comments) is seeing a digit when expecting ',' or ']'.
      {
          // Line and column counts are 1-based, not 0-based.
          "q_is_not_the_start_of_any_valid_JSON_token",
          1,
          1,
      },
      {
          "[2,4,6 8",
          // -----^
          1,
          8,
      },
      {
          "[2,4,6\t8",
          // ------^
          1,
          8,
      },
      {
          "[2,4,6\n8",
          // ------^
          2,
          1,
      },
      {
          "[\n0,\n1,\n2,\n3,4,5,6 7,\n8,\n9\n]",
          // ---------------------^
          5,
          9,
      },
      {
          // Same as the previous example, but with "\r\n"s instead of "\n"s.
          "[\r\n0,\r\n1,\r\n2,\r\n3,4,5,6 7,\r\n8,\r\n9\r\n]",
          // -----------------------------^
          5,
          9,
      },
      // The JSON spec forbids unescaped ASCII control characters (including
      // line breaks) within a string, but our implementation is more lenient.
      {
          "[\"3\n1\" 4",
          // --------^
          2,
          4,
      },
      {
          "[\"3\r\n1\" 4",
          // ----------^
          2,
          4,
      },
  });

  for (unsigned int i = 0; i < std::size(kCases); ++i) {
    auto test_case = kCases[i];
    SCOPED_TRACE(StringPrintf("case %u: \"%s\"", i, test_case.input));

    auto root = JSONReader::ReadAndReturnValueWithError(
        test_case.input, JSON_PARSE_RFC | JSON_ALLOW_NEWLINES_IN_STRINGS);
    EXPECT_FALSE(root.has_value());
    EXPECT_EQ(test_case.error_line, root.error().line);
    EXPECT_EQ(test_case.error_column, root.error().column);
  }
}

TEST(JSONReaderTest, ChromiumExtensions) {
  // All of these cases should parse with JSON_PARSE_CHROMIUM_EXTENSIONS but
  // fail with JSON_PARSE_RFC.
  struct Cases {
    // The JSON input.
    const char* input;
    // What JSON_* option permits this extension.
    int option;
  };
  const auto kCases = std::to_array<Cases>({
      {"{ /* comment */ \"foo\": 3 }", JSON_ALLOW_COMMENTS},
      {"{ // comment\n \"foo\": 3 }", JSON_ALLOW_COMMENTS},
      {"[\"\\xAB\"]", JSON_ALLOW_X_ESCAPES},
      {"[\"\n\"]", JSON_ALLOW_NEWLINES_IN_STRINGS},
      {"[\"\r\"]", JSON_ALLOW_NEWLINES_IN_STRINGS},
  });

  for (size_t i = 0; i < std::size(kCases); ++i) {
    SCOPED_TRACE(testing::Message() << "case " << i);
    const auto& test_case = kCases[i];

    auto result = JSONReader::ReadAndReturnValueWithError(test_case.input,
                                                          JSON_PARSE_RFC);
    EXPECT_FALSE(result.has_value());

    result = JSONReader::ReadAndReturnValueWithError(
        test_case.input, JSON_PARSE_RFC | test_case.option);
    EXPECT_TRUE(result.has_value());

    result = JSONReader::ReadAndReturnValueWithError(
        test_case.input, JSON_PARSE_CHROMIUM_EXTENSIONS);
    EXPECT_TRUE(result.has_value());

    result = JSONReader::ReadAndReturnValueWithError(
        test_case.input, JSON_PARSE_CHROMIUM_EXTENSIONS & ~test_case.option);
    EXPECT_FALSE(result.has_value());
  }
}

// For every control character, place it unescaped in a string and ensure that:
// a) It doesn't parse with JSON_PARSE_RFC
// b) It doesn't parse with JSON_PARSE_CHROMIUM_EXTENSIONS
TEST(JSONReaderTest, UnescapedControls) {
  std::string input = "\"foo\"";
  // ECMA-404 (JSON standard) section 9: characters from 0x00 to 0x1f must be
  // escaped.
  for (char c = 0x00; c <= 0x1f; c++) {
    input[1] = c;

    auto result = JSONReader::Read(input, JSON_PARSE_RFC);
    EXPECT_FALSE(result.has_value());

    bool should_parse_with_extensions = (c == '\r' || c == '\n');
    result = JSONReader::Read(input, JSON_PARSE_CHROMIUM_EXTENSIONS);
    EXPECT_EQ(should_parse_with_extensions, result.has_value());
  }
}

TEST(JSONReaderTest, ReadingJsonIntoDictAndList) {
  {
    std::optional<base::Value::List> list =
        JSONReader::ReadList("[1, 2, 3]", JSON_PARSE_CHROMIUM_EXTENSIONS);
    ASSERT_TRUE(list);
  }

  {
    std::optional<base::Value::List> list =
        JSONReader::ReadList("{}", JSON_PARSE_CHROMIUM_EXTENSIONS);
    ASSERT_FALSE(list);
  }

  {
    std::optional<base::Value::Dict> dict =
        JSONReader::ReadDict("{}", JSON_PARSE_CHROMIUM_EXTENSIONS);
    ASSERT_TRUE(dict);
  }

  {
    std::optional<base::Value::Dict> dict =
        JSONReader::ReadDict("[1, 2, 3]", JSON_PARSE_CHROMIUM_EXTENSIONS);
    ASSERT_FALSE(dict);
  }
}

static void CanParseAnythingWithoutCrashing(std::string_view input,
                                            int options) {
  JSONReader::Read(input, options);
}

FUZZ_TEST(JSONReaderTest, CanParseAnythingWithoutCrashing);

}  // namespace base