//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// Copyright (c) 2013-2022 Niels Lohmann <http://nlohmann.me>.
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT

#include "doctest_compatibility.h"

#include <nlohmann/json.hpp>
using nlohmann::json;
#ifdef JSON_TEST_NO_GLOBAL_UDLS
using namespace nlohmann::literals;  // NOLINT(google-build-using-namespace)
#endif

#include <iostream>
#include <iterator>
#include <sstream>
#include <valarray>

namespace
{
struct SaxEventLogger : public nlohmann::json_sax<json>
{
    bool null() override
    {
        events.emplace_back("null()");
        return true;
    }

    bool boolean(bool val) override
    {
        events.emplace_back(val ? "boolean(true)" : "boolean(false)");
        return true;
    }

    bool number_integer(json::number_integer_t val) override
    {
        events.push_back("number_integer(" + std::to_string(val) + ")");
        return true;
    }

    bool number_unsigned(json::number_unsigned_t val) override
    {
        events.push_back("number_unsigned(" + std::to_string(val) + ")");
        return true;
    }

    bool number_float(json::number_float_t /*val*/, const std::string& s) override
    {
        events.push_back("number_float(" + s + ")");
        return true;
    }

    bool string(std::string& val) override
    {
        events.push_back("string(" + val + ")");
        return true;
    }

    bool binary(json::binary_t& val) override
    {
        std::string binary_contents = "binary(";
        std::string comma_space;
        for (auto b : val)
        {
            binary_contents.append(comma_space);
            binary_contents.append(std::to_string(static_cast<int>(b)));
            comma_space = ", ";
        }
        binary_contents.append(")");
        events.push_back(binary_contents);
        return true;
    }

    bool start_object(std::size_t elements) override
    {
        if (elements == static_cast<std::size_t>(-1))
        {
            events.emplace_back("start_object()");
        }
        else
        {
            events.push_back("start_object(" + std::to_string(elements) + ")");
        }
        return true;
    }

    bool key(std::string& val) override
    {
        events.push_back("key(" + val + ")");
        return true;
    }

    bool end_object() override
    {
        events.emplace_back("end_object()");
        return true;
    }

    bool start_array(std::size_t elements) override
    {
        if (elements == static_cast<std::size_t>(-1))
        {
            events.emplace_back("start_array()");
        }
        else
        {
            events.push_back("start_array(" + std::to_string(elements) + ")");
        }
        return true;
    }

    bool end_array() override
    {
        events.emplace_back("end_array()");
        return true;
    }

    bool parse_error(std::size_t position, const std::string& /*last_token*/, const json::exception& /*ex*/) override
    {
        events.push_back("parse_error(" + std::to_string(position) + ")");
        return false;
    }

    std::vector<std::string> events{};
};

struct SaxEventLoggerExitAfterStartObject : public SaxEventLogger
{
    bool start_object(std::size_t elements) override
    {
        if (elements == static_cast<std::size_t>(-1))
        {
            events.emplace_back("start_object()");
        }
        else
        {
            events.push_back("start_object(" + std::to_string(elements) + ")");
        }
        return false;
    }
};

struct SaxEventLoggerExitAfterKey : public SaxEventLogger
{
    bool key(std::string& val) override
    {
        events.push_back("key(" + val + ")");
        return false;
    }
};

struct SaxEventLoggerExitAfterStartArray : public SaxEventLogger
{
    bool start_array(std::size_t elements) override
    {
        if (elements == static_cast<std::size_t>(-1))
        {
            events.emplace_back("start_array()");
        }
        else
        {
            events.push_back("start_array(" + std::to_string(elements) + ")");
        }
        return false;
    }
};

template<typename T>
class proxy_iterator
{
  public:
    using iterator = typename T::iterator;
    using value_type = typename std::iterator_traits<iterator>::value_type;
    using reference = typename std::iterator_traits<iterator>::reference;
    using pointer = typename std::iterator_traits<iterator>::pointer;
    using difference_type = typename std::iterator_traits<iterator>::difference_type;
    using iterator_category = std::input_iterator_tag;

    proxy_iterator() = default;
    explicit proxy_iterator(iterator& it)
      : m_it(std::addressof(it))
    {}

    proxy_iterator& operator++()
    {
        ++*m_it;
        return *this;
    }

    proxy_iterator& operator--()
    {
        --*m_it;
        return *this;
    }

    bool operator==(const proxy_iterator& rhs) const
    {
        return (m_it && rhs.m_it) ? (*m_it == *rhs.m_it) : (m_it == rhs.m_it);
    }

    bool operator!=(const proxy_iterator& rhs) const
    {
        return !(*this == rhs);
    }

    reference operator*() const
    {
        return **m_it;
    }

  private:
    iterator* m_it = nullptr;
};
}  // namespace

TEST_CASE("deserialization")
{
    SECTION("successful deserialization")
    {
        SECTION("stream")
        {
            std::stringstream ss1;
            std::stringstream ss2;
            std::stringstream ss3;
            ss1 << R"(["foo",1,2,3,false,{"one":1}])";
            ss2 << R"(["foo",1,2,3,false,{"one":1}])";
            ss3 << R"(["foo",1,2,3,false,{"one":1}])";
            json j = json::parse(ss1);
            CHECK(json::accept(ss2));
            CHECK(j == json({ "foo", 1, 2, 3, false, { { "one", 1 } } }));

            SaxEventLogger l;
            CHECK(json::sax_parse(ss3, &l));
            CHECK(l.events.size() == 11);
            CHECK(l.events == std::vector<std::string>({ "start_array()",
                                                         "string(foo)",
                                                         "number_unsigned(1)",
                                                         "number_unsigned(2)",
                                                         "number_unsigned(3)",
                                                         "boolean(false)",
                                                         "start_object()",
                                                         "key(one)",
                                                         "number_unsigned(1)",
                                                         "end_object()",
                                                         "end_array()" }));
        }

        SECTION("string literal")
        {
            const auto* s = R"(["foo",1,2,3,false,{"one":1}])";
            json j = json::parse(s);
            CHECK(json::accept(s));
            CHECK(j == json({ "foo", 1, 2, 3, false, { { "one", 1 } } }));

            SaxEventLogger l;
            CHECK(json::sax_parse(s, &l));
            CHECK(l.events.size() == 11);
            CHECK(l.events == std::vector<std::string>({ "start_array()",
                                                         "string(foo)",
                                                         "number_unsigned(1)",
                                                         "number_unsigned(2)",
                                                         "number_unsigned(3)",
                                                         "boolean(false)",
                                                         "start_object()",
                                                         "key(one)",
                                                         "number_unsigned(1)",
                                                         "end_object()",
                                                         "end_array()" }));
        }

        SECTION("string_t")
        {
            json::string_t const s = R"(["foo",1,2,3,false,{"one":1}])";
            json j = json::parse(s);
            CHECK(json::accept(s));
            CHECK(j == json({ "foo", 1, 2, 3, false, { { "one", 1 } } }));

            SaxEventLogger l;
            CHECK(json::sax_parse(s, &l));
            CHECK(l.events.size() == 11);
            CHECK(l.events == std::vector<std::string>({ "start_array()",
                                                         "string(foo)",
                                                         "number_unsigned(1)",
                                                         "number_unsigned(2)",
                                                         "number_unsigned(3)",
                                                         "boolean(false)",
                                                         "start_object()",
                                                         "key(one)",
                                                         "number_unsigned(1)",
                                                         "end_object()",
                                                         "end_array()" }));
        }

        SECTION("operator<<")
        {
            std::stringstream ss;
            ss << R"(["foo",1,2,3,false,{"one":1}])";
            json j;
            j << ss;
            CHECK(j == json({ "foo", 1, 2, 3, false, { { "one", 1 } } }));
        }

        SECTION("operator>>")
        {
            std::stringstream ss;
            ss << R"(["foo",1,2,3,false,{"one":1}])";
            json j;
            ss >> j;
            CHECK(j == json({ "foo", 1, 2, 3, false, { { "one", 1 } } }));
        }

        SECTION("user-defined string literal")
        {
            CHECK("[\"foo\",1,2,3,false,{\"one\":1}]"_json == json({ "foo", 1, 2, 3, false, { { "one", 1 } } }));
        }
    }

    SECTION("unsuccessful deserialization")
    {
        SECTION("stream")
        {
            std::stringstream ss1;
            std::stringstream ss3;
            std::stringstream ss4;
            std::stringstream ss5;
            ss1 << R"(["foo",1,2,3,false,{"one":1})";
            ss3 << R"(["foo",1,2,3,false,{"one":1})";
            ss4 << R"(["foo",1,2,3,false,{"one":1})";
            ss5 << R"(["foo",1,2,3,false,{"one":1})";

            json _;
            CHECK_THROWS_WITH_AS(
                _ = json::parse(ss1),
                "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'",
                json::parse_error&);
            CHECK(!json::accept(ss3));

            json j_error;
            CHECK_NOTHROW(j_error = json::parse(ss4, nullptr, false));
            CHECK(j_error.is_discarded());

            SaxEventLogger l;
            CHECK(!json::sax_parse(ss5, &l));
            CHECK(l.events.size() == 11);
            CHECK(l.events == std::vector<std::string>({ "start_array()",
                                                         "string(foo)",
                                                         "number_unsigned(1)",
                                                         "number_unsigned(2)",
                                                         "number_unsigned(3)",
                                                         "boolean(false)",
                                                         "start_object()",
                                                         "key(one)",
                                                         "number_unsigned(1)",
                                                         "end_object()",
                                                         "parse_error(29)" }));
        }

        SECTION("string")
        {
            json::string_t const s = R"(["foo",1,2,3,false,{"one":1})";
            json _;
            CHECK_THROWS_WITH_AS(
                _ = json::parse(s),
                "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'",
                json::parse_error&);
            CHECK(!json::accept(s));

            json j_error;
            CHECK_NOTHROW(j_error = json::parse(s, nullptr, false));
            CHECK(j_error.is_discarded());

            SaxEventLogger l;
            CHECK(!json::sax_parse(s, &l));
            CHECK(l.events.size() == 11);
            CHECK(l.events == std::vector<std::string>({ "start_array()",
                                                         "string(foo)",
                                                         "number_unsigned(1)",
                                                         "number_unsigned(2)",
                                                         "number_unsigned(3)",
                                                         "boolean(false)",
                                                         "start_object()",
                                                         "key(one)",
                                                         "number_unsigned(1)",
                                                         "end_object()",
                                                         "parse_error(29)" }));
        }

        SECTION("operator<<")
        {
            std::stringstream ss;
            ss << R"(["foo",1,2,3,false,{"one":1})";
            json j;
            CHECK_THROWS_WITH_AS(
                j << ss,
                "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'",
                json::parse_error&);
        }

        SECTION("operator>>")
        {
            std::stringstream ss;
            ss << R"(["foo",1,2,3,false,{"one":1})";
            json j;
            CHECK_THROWS_WITH_AS(
                ss >> j,
                "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'",
                json::parse_error&);
        }

        SECTION("user-defined string literal")
        {
            CHECK_THROWS_WITH_AS(
                "[\"foo\",1,2,3,false,{\"one\":1}"_json,
                "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'",
                json::parse_error&);
        }
    }

    SECTION("contiguous containers")
    {
        SECTION("directly")
        {
            SECTION("from std::vector")
            {
                std::vector<uint8_t> const v = { 't', 'r', 'u', 'e' };
                CHECK(json::parse(v) == json(true));
                CHECK(json::accept(v));

                SaxEventLogger l;
                CHECK(json::sax_parse(v, &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));
            }

            SECTION("from std::array")
            {
                std::array<uint8_t, 5> const v{ { 't', 'r', 'u', 'e' } };
                CHECK(json::parse(v) == json(true));
                CHECK(json::accept(v));

                SaxEventLogger l;
                CHECK(json::sax_parse(v, &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));
            }

            SECTION("from array")
            {
                uint8_t v[] = { 't', 'r', 'u', 'e' };  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
                CHECK(json::parse(v) == json(true));
                CHECK(json::accept(v));

                SaxEventLogger l;
                CHECK(json::sax_parse(v, &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));
            }

            SECTION("from chars")
            {
                auto* v = new uint8_t[5];  // NOLINT(cppcoreguidelines-owning-memory)
                v[0] = 't';
                v[1] = 'r';
                v[2] = 'u';
                v[3] = 'e';
                v[4] = '\0';
                CHECK(json::parse(v) == json(true));
                CHECK(json::accept(v));

                SaxEventLogger l;
                CHECK(json::sax_parse(v, &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));

                delete[] v;  // NOLINT(cppcoreguidelines-owning-memory)
            }

            SECTION("from std::string")
            {
                std::string const v = { 't', 'r', 'u', 'e' };
                CHECK(json::parse(v) == json(true));
                CHECK(json::accept(v));

                SaxEventLogger l;
                CHECK(json::sax_parse(v, &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));
            }

            SECTION("from std::initializer_list")
            {
                std::initializer_list<uint8_t> const v = { 't', 'r', 'u', 'e' };
                CHECK(json::parse(v) == json(true));
                CHECK(json::accept(v));

                SaxEventLogger l;
                CHECK(json::sax_parse(v, &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));
            }

            SECTION("empty container")
            {
                std::vector<uint8_t> const v;
                json _;
                CHECK_THROWS_AS(_ = json::parse(v), json::parse_error&);
                CHECK(!json::accept(v));

                SaxEventLogger l;
                CHECK(!json::sax_parse(v, &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(1)" }));
            }
        }

        SECTION("via iterator range")
        {
            SECTION("from std::vector")
            {
                std::vector<uint8_t> v = { 't', 'r', 'u', 'e' };
                CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
                CHECK(json::accept(std::begin(v), std::end(v)));

                SaxEventLogger l;
                CHECK(json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));
            }

            SECTION("from std::array")
            {
                std::array<uint8_t, 5> v{ { 't', 'r', 'u', 'e' } };
                CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
                CHECK(json::accept(std::begin(v), std::end(v)));

                SaxEventLogger l;
                CHECK(json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));
            }

            SECTION("from array")
            {
                uint8_t v[] = { 't', 'r', 'u', 'e' };  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
                CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
                CHECK(json::accept(std::begin(v), std::end(v)));

                SaxEventLogger l;
                CHECK(json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));
            }

            SECTION("from std::string")
            {
                std::string v = { 't', 'r', 'u', 'e' };
                CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
                CHECK(json::accept(std::begin(v), std::end(v)));

                SaxEventLogger l;
                CHECK(json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));
            }

            SECTION("from std::initializer_list")
            {
                std::initializer_list<uint8_t> const v = { 't', 'r', 'u', 'e' };
                CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
                CHECK(json::accept(std::begin(v), std::end(v)));

                SaxEventLogger l;
                CHECK(json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));
            }

            SECTION("from std::valarray")
            {
                std::valarray<uint8_t> v = { 't', 'r', 'u', 'e' };
                CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
                CHECK(json::accept(std::begin(v), std::end(v)));

                SaxEventLogger l;
                CHECK(json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));
            }

            SECTION("with empty range")
            {
                std::vector<uint8_t> v;
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(1)" }));
            }

            SECTION("iterator_input_adapter advances iterators correctly")
            {
                using nlohmann::json;
                using nlohmann::detail::input_format_t;
                using nlohmann::detail::json_sax_dom_parser;
                using proxy = proxy_iterator<std::string>;

                std::string str1 = "[1]";
                std::string str2 = "[2]";
                std::string str = str1 + str2;

                auto first = str.begin();
                auto last = str.end();
                json j;
                json_sax_dom_parser<json> sax(j, true);

                CHECK(json::sax_parse(proxy(first), proxy(last), &sax, input_format_t::json, false));
                CHECK(j.dump() == str1);
                CHECK(std::string(first, last) == str2);
            }
        }

        // these cases are required for 100% line coverage
        SECTION("error cases")
        {
            SECTION("case 1")
            {
                std::array<std::uint8_t, 9> v = { { '\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u' } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(10)" }));
            }

            SECTION("case 2")
            {
                std::array<std::uint8_t, 10> v = { { '\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u', '1' } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(11)" }));
            }

            SECTION("case 3")
            {
                std::array<std::uint8_t, 17> v = { { '\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u', '1', '1', '1', '1', '1', '1', '1', '1' } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(18)" }));
            }

            SECTION("case 4")
            {
                std::array<std::uint8_t, 17> v = { { '\"', 'a', 'a', 'a', 'a', 'a', 'a', 'u', '1', '1', '1', '1', '1', '1', '1', '1', '\\' } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(18)" }));
            }

            SECTION("case 5")
            {
                std::array<std::uint8_t, 3> v = { { '\"', 0x7F, 0xC1 } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(3)" }));
            }

            SECTION("case 6")
            {
                std::array<std::uint8_t, 4> v = { { '\"', 0x7F, 0xDF, 0x7F } };
                json _;
                CHECK_THROWS_WITH_AS(
                    _ = json::parse(std::begin(v), std::end(v)),
                    "[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing value - invalid string: ill-formed UTF-8 byte; last read: '\"\x7f\xdf\x7f'",
                    json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(4)" }));
            }

            SECTION("case 7")
            {
                std::array<std::uint8_t, 4> v = { { '\"', 0x7F, 0xDF, 0xC0 } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(4)" }));
            }

            SECTION("case 8")
            {
                std::array<std::uint8_t, 4> v = { { '\"', 0x7F, 0xE0, 0x9F } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(4)" }));
            }

            SECTION("case 9")
            {
                std::array<std::uint8_t, 4> v = { { '\"', 0x7F, 0xEF, 0xC0 } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(4)" }));
            }

            SECTION("case 10")
            {
                std::array<std::uint8_t, 4> v = { { '\"', 0x7F, 0xED, 0x7F } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(4)" }));
            }

            SECTION("case 11")
            {
                std::array<std::uint8_t, 4> v = { { '\"', 0x7F, 0xF0, 0x8F } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(4)" }));
            }

            SECTION("case 12")
            {
                std::array<std::uint8_t, 4> v = { { '\"', 0x7F, 0xF0, 0xC0 } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(4)" }));
            }

            SECTION("case 13")
            {
                std::array<std::uint8_t, 4> v = { { '\"', 0x7F, 0xF3, 0x7F } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(4)" }));
            }

            SECTION("case 14")
            {
                std::array<std::uint8_t, 4> v = { { '\"', 0x7F, 0xF3, 0xC0 } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(4)" }));
            }

            SECTION("case 15")
            {
                std::array<std::uint8_t, 4> v = { { '\"', 0x7F, 0xF4, 0x7F } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 1);
                CHECK(l.events == std::vector<std::string>({ "parse_error(4)" }));
            }

            SECTION("case 16")
            {
                std::array<std::uint8_t, 6> v = { { '{', '\"', '\"', ':', '1', '1' } };
                json _;
                CHECK_THROWS_AS(_ = json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(!json::accept(std::begin(v), std::end(v)));

                json j_error;
                CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
                CHECK(j_error.is_discarded());

                SaxEventLogger l;
                CHECK(!json::sax_parse(std::begin(v), std::end(v), &l));
                CHECK(l.events.size() == 4);
                CHECK(l.events == std::vector<std::string>({ "start_object()", "key()", "number_unsigned(11)", "parse_error(7)" }));
            }
        }
    }

    SECTION("ignoring byte-order marks")
    {
        std::string bom = "\xEF\xBB\xBF";

        SECTION("BOM only")
        {
            json _;
            CHECK_THROWS_WITH_AS(
                _ = json::parse(bom),
                "[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing value - unexpected end of input; expected '[', '{', or a literal",
                json::parse_error&);

            CHECK_THROWS_WITH_AS(
                _ = json::parse(std::istringstream(bom)),
                "[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing value - unexpected end of input; expected '[', '{', or a literal",
                json::parse_error&);

            SaxEventLogger l;
            CHECK(!json::sax_parse(bom, &l));
            CHECK(l.events.size() == 1);
            CHECK(l.events == std::vector<std::string>({ "parse_error(4)" }));
        }

        SECTION("BOM and content")
        {
            CHECK(json::parse(bom + "1") == 1);
            CHECK(json::parse(std::istringstream(bom + "1")) == 1);

            SaxEventLogger l1;
            SaxEventLogger l2;
            CHECK(json::sax_parse(std::istringstream(bom + "1"), &l1));
            CHECK(json::sax_parse(bom + "1", &l2));
            CHECK(l1.events.size() == 1);
            CHECK(l1.events == std::vector<std::string>({ "number_unsigned(1)" }));
            CHECK(l2.events.size() == 1);
            CHECK(l2.events == std::vector<std::string>({ "number_unsigned(1)" }));
        }

        SECTION("2 byte of BOM")
        {
            json _;
            CHECK_THROWS_WITH_AS(
                _ = json::parse(bom.substr(0, 2)),
                "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid BOM; must be 0xEF 0xBB 0xBF if given; last read: '\xEF\xBB'",
                json::parse_error&);

            CHECK_THROWS_WITH_AS(
                _ = json::parse(std::istringstream(bom.substr(0, 2))),
                "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid BOM; must be 0xEF 0xBB 0xBF if given; last read: '\xEF\xBB'",
                json::parse_error&);

            SaxEventLogger l1;
            SaxEventLogger l2;
            CHECK(!json::sax_parse(std::istringstream(bom.substr(0, 2)), &l1));
            CHECK(!json::sax_parse(bom.substr(0, 2), &l2));
            CHECK(l1.events.size() == 1);
            CHECK(l1.events == std::vector<std::string>({ "parse_error(3)" }));
            CHECK(l2.events.size() == 1);
            CHECK(l2.events == std::vector<std::string>({ "parse_error(3)" }));
        }

        SECTION("1 byte of BOM")
        {
            json _;
            CHECK_THROWS_WITH_AS(
                _ = json::parse(bom.substr(0, 1)),
                "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid BOM; must be 0xEF 0xBB 0xBF if given; last read: '\xEF'",
                json::parse_error&);

            CHECK_THROWS_WITH_AS(
                _ = json::parse(std::istringstream(bom.substr(0, 1))),
                "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid BOM; must be 0xEF 0xBB 0xBF if given; last read: '\xEF'",
                json::parse_error&);

            SaxEventLogger l1;
            SaxEventLogger l2;
            CHECK(!json::sax_parse(std::istringstream(bom.substr(0, 1)), &l1));
            CHECK(!json::sax_parse(bom.substr(0, 1), &l2));
            CHECK(l1.events.size() == 1);
            CHECK(l1.events == std::vector<std::string>({ "parse_error(2)" }));
            CHECK(l2.events.size() == 1);
            CHECK(l2.events == std::vector<std::string>({ "parse_error(2)" }));
        }

        SECTION("variations")
        {
            // calculate variations of each byte of the BOM to make sure
            // that the BOM and only the BOM is skipped
            for (int i0 = -1; i0 < 2; ++i0)
            {
                for (int i1 = -1; i1 < 2; ++i1)
                {
                    for (int i2 = -1; i2 < 2; ++i2)
                    {
                        // debug output for the variations
                        CAPTURE(i0)
                        CAPTURE(i1)
                        CAPTURE(i2)

                        std::string s;
                        s.push_back(static_cast<char>(bom[0] + i0));
                        s.push_back(static_cast<char>(bom[1] + i1));
                        s.push_back(static_cast<char>(bom[2] + i2));

                        if (i0 == 0 && i1 == 0 && i2 == 0)
                        {
                            // without any variation, we skip the BOM
                            CHECK(json::parse(s + "null") == json());
                            CHECK(json::parse(std::istringstream(s + "null")) == json());

                            SaxEventLogger l;
                            CHECK(json::sax_parse(s + "null", &l));
                            CHECK(l.events.size() == 1);
                            CHECK(l.events == std::vector<std::string>({ "null()" }));
                        }
                        else
                        {
                            // any variation is an error
                            json _;
                            CHECK_THROWS_AS(_ = json::parse(s + "null"), json::parse_error&);
                            CHECK_THROWS_AS(_ = json::parse(std::istringstream(s + "null")), json::parse_error&);

                            SaxEventLogger l;
                            CHECK(!json::sax_parse(s + "null", &l));
                            CHECK(l.events.size() == 1);

                            if (i0 != 0)
                            {
                                CHECK(l.events == std::vector<std::string>({ "parse_error(1)" }));
                            }
                            else if (i1 != 0)
                            {
                                CHECK(l.events == std::vector<std::string>({ "parse_error(2)" }));
                            }
                            else
                            {
                                CHECK(l.events == std::vector<std::string>({ "parse_error(3)" }));
                            }
                        }
                    }
                }
            }
        }

        SECTION("preserve state after parsing")
        {
            std::istringstream s(bom + "123 456");
            json j;
            j << s;
            CHECK(j == 123);
            j << s;
            CHECK(j == 456);
        }
    }

    SECTION("SAX and early abort")
    {
        std::string const s = R"([1, ["string", 43.12], null, {"key1": true, "key2": false}])";

        SaxEventLogger default_logger;
        SaxEventLoggerExitAfterStartObject exit_after_start_object;
        SaxEventLoggerExitAfterKey exit_after_key;
        SaxEventLoggerExitAfterStartArray exit_after_start_array;

        json::sax_parse(s, &default_logger);
        CHECK(default_logger.events.size() == 14);
        CHECK(default_logger.events == std::vector<std::string>({ "start_array()",
                                                                  "number_unsigned(1)",
                                                                  "start_array()",
                                                                  "string(string)",
                                                                  "number_float(43.12)",
                                                                  "end_array()",
                                                                  "null()",
                                                                  "start_object()",
                                                                  "key(key1)",
                                                                  "boolean(true)",
                                                                  "key(key2)",
                                                                  "boolean(false)",
                                                                  "end_object()",
                                                                  "end_array()" }));

        json::sax_parse(s, &exit_after_start_object);
        CHECK(exit_after_start_object.events.size() == 8);
        CHECK(exit_after_start_object.events == std::vector<std::string>({ "start_array()",
                                                                           "number_unsigned(1)",
                                                                           "start_array()",
                                                                           "string(string)",
                                                                           "number_float(43.12)",
                                                                           "end_array()",
                                                                           "null()",
                                                                           "start_object()" }));

        json::sax_parse(s, &exit_after_key);
        CHECK(exit_after_key.events.size() == 9);
        CHECK(exit_after_key.events == std::vector<std::string>({ "start_array()",
                                                                  "number_unsigned(1)",
                                                                  "start_array()",
                                                                  "string(string)",
                                                                  "number_float(43.12)",
                                                                  "end_array()",
                                                                  "null()",
                                                                  "start_object()",
                                                                  "key(key1)" }));

        json::sax_parse(s, &exit_after_start_array);
        CHECK(exit_after_start_array.events.size() == 1);
        CHECK(exit_after_start_array.events == std::vector<std::string>({ "start_array()" }));
    }

    SECTION("JSON Lines")
    {
        SECTION("Example file")
        {
            std::stringstream ss;
            ss << R"({"name": "Gilbert", "wins": [["straight", "7♣"], ["one pair", "10♥"]]}
                    {"name": "Alexa", "wins": [["two pair", "4♠"], ["two pair", "9♠"]]}
                    {"name": "May", "wins": []}
                    {"name": "Deloise", "wins": [["three of a kind", "5♣"]]}
)";

            std::string line;
            int object_count = 0;
            while (std::getline(ss, line))
            {
                ++object_count;
                CHECK(json::accept(line));
            }

            CHECK(object_count == 4);
        }

        SECTION("Example file without trailing newline")
        {
            std::stringstream ss;
            ss << R"({"name": "Gilbert", "wins": [["straight", "7♣"], ["one pair", "10♥"]]}
                    {"name": "Alexa", "wins": [["two pair", "4♠"], ["two pair", "9♠"]]}
                    {"name": "May", "wins": []}
                    {"name": "Deloise", "wins": [["three of a kind", "5♣"]]})";

            std::string line;
            int object_count = 0;
            while (std::getline(ss, line))
            {
                ++object_count;
                CHECK(json::accept(line));
            }

            CHECK(object_count == 4);
        }
    }
}

TEST_CASE_TEMPLATE("deserialization of different character types (ASCII)",
                   T,
                   char,
                   unsigned char,
                   signed char,
                   wchar_t,
                   char16_t,
                   char32_t,
                   std::uint8_t,
                   std::int8_t,
                   std::int16_t,
                   std::uint16_t,
                   std::int32_t,
                   std::uint32_t)
{
    std::vector<T> const v = { 't', 'r', 'u', 'e' };
    CHECK(json::parse(v) == json(true));
    CHECK(json::accept(v));

    SaxEventLogger l;
    CHECK(json::sax_parse(v, &l));
    CHECK(l.events.size() == 1);
    CHECK(l.events == std::vector<std::string>({ "boolean(true)" }));
}

TEST_CASE_TEMPLATE("deserialization of different character types (UTF-8)", T, char, unsigned char, std::uint8_t)
{
    // a star emoji
    std::vector<T> const v = {
        '"', static_cast<T>(0xe2u), static_cast<T>(0xadu), static_cast<T>(0x90u), static_cast<T>(0xefu), static_cast<T>(0xb8u), static_cast<T>(0x8fu), '"'
    };
    CHECK(json::parse(v).dump(-1, ' ', true) == "\"\\u2b50\\ufe0f\"");
    CHECK(json::accept(v));

    SaxEventLogger l;
    CHECK(json::sax_parse(v, &l));
    CHECK(l.events.size() == 1);
}

TEST_CASE_TEMPLATE("deserialization of different character types (UTF-16)", T, char16_t, std::uint16_t)
{
    // a star emoji
    std::vector<T> const v = { static_cast<T>('"'), static_cast<T>(0x2b50), static_cast<T>(0xfe0f), static_cast<T>('"') };
    CHECK(json::parse(v).dump(-1, ' ', true) == "\"\\u2b50\\ufe0f\"");
    CHECK(json::accept(v));

    SaxEventLogger l;
    CHECK(json::sax_parse(v, &l));
    CHECK(l.events.size() == 1);
}

TEST_CASE_TEMPLATE("deserialization of different character types (UTF-32)", T, char32_t, std::uint32_t)
{
    // a star emoji
    std::vector<T> const v = { static_cast<T>('"'), static_cast<T>(0x2b50), static_cast<T>(0xfe0f), static_cast<T>('"') };
    CHECK(json::parse(v).dump(-1, ' ', true) == "\"\\u2b50\\ufe0f\"");
    CHECK(json::accept(v));

    SaxEventLogger l;
    CHECK(json::sax_parse(v, &l));
    CHECK(l.events.size() == 1);
}