/*
    __ _____ _____ _____
 __|  |   __|     |   | |  JSON for Modern C++ (test suite)
|  |  |__   |  |  | | | |  version 3.1.1
|_____|_____|_____|_|___|  https://github.com/nlohmann/json

Licensed under the MIT License <http://opensource.org/licenses/MIT>.
Copyright (c) 2013-2018 Niels Lohmann <http://nlohmann.me>.

Permission is hereby  granted, free of charge, to any  person obtaining a copy
of this software and associated  documentation files (the "Software"), to deal
in the Software  without restriction, including without  limitation the rights
to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

#include "catch.hpp"

#include <nlohmann/json.hpp>
using nlohmann::json;

#include <iostream>
#include <valarray>

// HACK to get the tests running if exceptions are disabled on the command line
// using the "-e/--nothrow" flag. In this case the expressions in CHECK_THROWS
// and similar macros is never executed and subsequent checks relying on the
// side effects of the expression may or may not fail.
#define IF_EXCEPTIONS_ENABLED_THEN_CHECK(expr)                                                  \
    {                                                                                           \
        bool _exceptions_enabled_ = false;                                                      \
        /* The next line sets the `_exceptions_enabled_` flag to true, iff the expression in */ \
        /* the CHECK_THROWS macro actually gets ever evaluated. It's not if the "-e" flag    */ \
        /* has been specified on the command line.                                           */ \
        CHECK_THROWS([&](){ _exceptions_enabled_ = true; throw std::runtime_error("ok"); }());  \
        if (_exceptions_enabled_)                                                               \
        {                                                                                       \
            CHECK(expr);                                                                        \
        }                                                                                       \
    }                                                                                           \
    /**/

namespace
{
    // A stringbuf which only ever has a get-area of exactly one character.
    // I.e. multiple successive calls to sungetc will fail.
    // Note that sgetc and sbumpc both update the get-area and count as a "read" operation.
    // (sbumpc is the equivalent to sgetc + gbump(1).)
    class unget_fails_stringbuf : public std::streambuf
    {
        const char* last;

      public:
        explicit unget_fails_stringbuf(char const* str, size_t len)
            : last(str + len)
        {
            char* first = const_cast<char*>(str);
            this->setg(first, first, first);
        }

      protected:
        virtual traits_type::int_type underflow() override
        {
            char* pos = this->gptr();
            if (pos == last)
            {
                this->setg(pos, pos, pos); // empty. and invalid.
                return traits_type::eof();
            }
            this->setg(pos, pos, pos + 1);
            return traits_type::to_int_type(*pos);
        }
    };
}

TEST_CASE("deserialization")
{
    SECTION("successful deserialization")
    {
        SECTION("stream")
        {
            std::stringstream ss1, ss2;
            ss1 << "[\"foo\",1,2,3,false,{\"one\":1}]";
            ss2 << "[\"foo\",1,2,3,false,{\"one\":1}]";
            json j = json::parse(ss1);
            CHECK(!ss1.fail());
            CHECK(!ss1.bad());
            CHECK(ss1.eof()); // Strict parsing.
            CHECK(json::accept(ss2));
            CHECK(j == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
        }

        SECTION("string literal")
        {
            auto s = "[\"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}}}));
        }

        SECTION("string_t")
        {
            json::string_t s = "[\"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}}}));
        }

        SECTION("operator<<")
        {
            std::stringstream ss;
            ss << "[\"foo\",1,2,3,false,{\"one\":1}]";
            json j;
            j << ss;
            CHECK(!ss.fail());
            CHECK(!ss.bad());
            // operator>> uses non-strict parsing.
            // We have read the closing ']' and we're done. The parser should
            // not have read the EOF marker.
            CHECK(!ss.eof());
            CHECK(j == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
        }

        SECTION("operator>>")
        {
            std::stringstream ss;
            ss << "[\"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("null streambuf")
        {
            std::streambuf* sb = nullptr;
            std::istream iss(sb);
            CHECK(iss.bad());
            CHECK_THROWS_WITH(json::parse(iss),
                              "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(iss.fail()); // Tests the badbit too.
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(iss.bad());
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(!iss.eof());
        }

        SECTION("stream")
        {
            std::stringstream ss1, ss2, ss3, ss4;
            ss1 << "[\"foo\",1,2,3,false,{\"one\":1}";
            ss2 << "[\"foo\",1,2,3,false,{\"one\":1}";
            ss3 << "[\"foo\",1,2,3,false,{\"one\":1}";
            ss4 << "[\"foo\",1,2,3,false,{\"one\":1}";
            CHECK_THROWS_AS(json::parse(ss1), json::parse_error&);
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(!ss1.fail());
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(!ss1.bad());
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(ss1.eof());
            CHECK_THROWS_WITH(json::parse(ss2),
                              "[json.exception.parse_error.101] parse error at 29: syntax error - unexpected end of input; expected ']'");
            CHECK(not json::accept(ss3));

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

        SECTION("string")
        {
            json::string_t s = "[\"foo\",1,2,3,false,{\"one\":1}";
            CHECK_THROWS_AS(json::parse(s), json::parse_error&);
            CHECK_THROWS_WITH(json::parse(s),
                              "[json.exception.parse_error.101] parse error at 29: syntax error - unexpected end of input; expected ']'");
            CHECK(not json::accept(s));

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

        SECTION("operator<<")
        {
            std::stringstream ss1, ss2;
            ss1 << "[\"foo\",1,2,3,false,{\"one\":1}";
            ss2 << "[\"foo\",1,2,3,false,{\"one\":1}";
            json j;
            CHECK_THROWS_AS(j << ss1, json::parse_error&);
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(!ss1.fail());
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(!ss1.bad());
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(ss1.eof());
            CHECK_THROWS_WITH(j << ss2,
                              "[json.exception.parse_error.101] parse error at 29: syntax error - unexpected end of input; expected ']'");
        }

        SECTION("operator>>")
        {
            std::stringstream ss1, ss2;
            ss1 << "[\"foo\",1,2,3,false,{\"one\":1}";
            ss2 << "[\"foo\",1,2,3,false,{\"one\":1}";
            json j;
            CHECK_THROWS_AS(ss1 >> j, json::parse_error&);
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(!ss1.fail());
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(!ss1.bad());
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(ss1.eof());
            CHECK_THROWS_WITH(ss2 >> j,
                              "[json.exception.parse_error.101] parse error at 29: syntax error - unexpected end of input; expected ']'");
        }

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

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

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

            SECTION("from array")
            {
                uint8_t v[] = {'t', 'r', 'u', 'e'};
                CHECK(json::parse(v) == json(true));
                CHECK(json::accept(v));
            }

            SECTION("from chars")
            {
                uint8_t* v = new uint8_t[5];
                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));
                delete[] v;
            }

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

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

            SECTION("empty container")
            {
                std::vector<uint8_t> v;
                CHECK_THROWS_AS(json::parse(v), json::parse_error&);
                CHECK(not json::accept(v));
            }
        }

        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)));
            }

            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)));
            }

            SECTION("from array")
            {
                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)));
            }

            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)));
            }

            SECTION("from std::initializer_list")
            {
                std::initializer_list<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)));
            }

            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)));
            }

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

        // these cases are required for 100% line coverage
        SECTION("error cases")
        {
            SECTION("case 1")
            {
                uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u'};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 2")
            {
                uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u', '1'};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 3")
            {
                uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u', '1', '1', '1', '1', '1', '1', '1', '1'};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 4")
            {
                uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', 'u', '1', '1', '1', '1', '1', '1', '1', '1', '\\'};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 5")
            {
                uint8_t v[] = {'\"', 0x7F, 0xC1};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 6")
            {
                uint8_t v[] = {'\"', 0x7F, 0xDF, 0x7F};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK_THROWS_WITH(json::parse(std::begin(v), std::end(v)),
                                  "[json.exception.parse_error.101] parse error at 4: syntax error - invalid string: ill-formed UTF-8 byte; last read: '\"\x7f\xdf\x7f'");
                CHECK(not 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());
            }

            SECTION("case 7")
            {
                uint8_t v[] = {'\"', 0x7F, 0xDF, 0xC0};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 8")
            {
                uint8_t v[] = {'\"', 0x7F, 0xE0, 0x9F};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 9")
            {
                uint8_t v[] = {'\"', 0x7F, 0xEF, 0xC0};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 10")
            {
                uint8_t v[] = {'\"', 0x7F, 0xED, 0x7F};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 11")
            {
                uint8_t v[] = {'\"', 0x7F, 0xF0, 0x8F};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 12")
            {
                uint8_t v[] = {'\"', 0x7F, 0xF0, 0xC0};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 13")
            {
                uint8_t v[] = {'\"', 0x7F, 0xF3, 0x7F};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 14")
            {
                uint8_t v[] = {'\"', 0x7F, 0xF3, 0xC0};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 15")
            {
                uint8_t v[] = {'\"', 0x7F, 0xF4, 0x7F};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }

            SECTION("case 16")
            {
                uint8_t v[] = {'{', '\"', '\"', ':', '1', '1'};
                CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
                CHECK(not 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());
            }
        }
    }

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

        SECTION("BOM only")
        {
            CHECK_THROWS_AS(json::parse(bom), json::parse_error&);
            CHECK_THROWS_WITH(json::parse(bom),
                              "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");

            std::istringstream iss(bom);
            CHECK_THROWS_AS(json::parse(iss), json::parse_error&);
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(!iss.fail());
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(!iss.bad());
            IF_EXCEPTIONS_ENABLED_THEN_CHECK(iss.eof());
            CHECK_THROWS_WITH(json::parse(std::istringstream(bom)),
                              "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");
        }

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

            std::istringstream iss(bom + "1");
            CHECK(json::parse(iss) == 1);
            CHECK(!iss.bad());
            CHECK(!iss.fail());
            // Strict parsing: stream should be at EOF now.
            CHECK(iss.eof());

            iss.str(bom + "1");
            iss.clear();
            json j;
            CHECK_NOTHROW(iss >> j);
            CHECK(j == 1);
            CHECK(!iss.fail());
            CHECK(!iss.bad());
            // Non-strict parsing:
            // EOF bit is set only if we tried to read a character past the end of the file.
            // In this case: parsing the complete number requires reading past the end of the file.
            CHECK(iss.eof());

            iss.str(bom + "\"1\"");
            iss.clear();
            CHECK(json::parse(iss) == "1");
            CHECK(!iss.fail());
            CHECK(!iss.bad());
            CHECK(iss.eof()); // Strict...

            iss.str(bom + "\"1\"");
            iss.clear();
            CHECK_NOTHROW(iss >> j);
            CHECK(j == "1");
            CHECK(!iss.fail());
            CHECK(!iss.bad());
            CHECK(!iss.eof()); // Non-strict...
        }

        SECTION("2 byte of BOM")
        {
            const std::string bom2 = bom.substr(0, 2);

            CHECK_THROWS_AS(json::parse(bom2), json::parse_error&);
            CHECK_THROWS_WITH(json::parse(bom2),
                              "[json.exception.parse_error.101] parse error at 1: syntax error - invalid literal; last read: '\xEF'");

            std::istringstream iss(bom2);
            CHECK_THROWS_AS(json::parse(iss), json::parse_error&);
            CHECK(!iss.fail());
            CHECK(!iss.bad());
            CHECK(!iss.eof()); // EOF bit is set only if we tried to read a character past the end of the file.
            CHECK(iss.good());
            CHECK_THROWS_WITH(json::parse(std::istringstream(bom2)),
                              "[json.exception.parse_error.101] parse error at 1: syntax error - invalid literal; last read: '\xEF'");
        }

        SECTION("2 byte of BOM - incomplete")
        {
            {
                unget_fails_stringbuf sb("\xEF\xBB ", 3);
                std::istream is(&sb);

                json j;
                CHECK_THROWS_WITH(is >> j,
                                "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");
                IF_EXCEPTIONS_ENABLED_THEN_CHECK(is.fail()); // Tests the badbit too
                IF_EXCEPTIONS_ENABLED_THEN_CHECK(is.bad());
                // Do not check the eofbit.
                // Some implementations keep the eofbit if is.unget() fails, some do not.
            }
            {
                unget_fails_stringbuf sb("\xEF\xBB", 2);
                std::istream is(&sb);

                json j;
                CHECK_THROWS_WITH(is >> j,
                                "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");
                IF_EXCEPTIONS_ENABLED_THEN_CHECK(is.fail()); // Tests the badbit too
                IF_EXCEPTIONS_ENABLED_THEN_CHECK(is.bad());
                // Do not check the eofbit.
                // Some implementations keep the eofbit if is.unget() fails, some do not.
            }
        }

        SECTION("1 byte of BOM")
        {
            const std::string bom1 = bom.substr(0, 1);

            CHECK_THROWS_AS(json::parse(bom1), json::parse_error&);
            CHECK_THROWS_WITH(json::parse(bom1),
                              "[json.exception.parse_error.101] parse error at 1: syntax error - invalid literal; last read: '\xEF'");

            std::istringstream iss(bom1);
            CHECK_THROWS_AS(json::parse(iss), json::parse_error&);
            CHECK(!iss.fail());
            CHECK(!iss.bad());
            CHECK(!iss.eof()); // EOF bit is set only if we tried to read a character past the end of the file.
            CHECK(iss.good());
            CHECK_THROWS_WITH(json::parse(std::istringstream(bom1)),
                              "[json.exception.parse_error.101] parse error at 1: syntax error - invalid literal; last read: '\xEF'");
        }

        SECTION("1 byte of BOM - incomplete")
        {
            {
                unget_fails_stringbuf sb("\xEF  ", 3);
                std::istream is(&sb);

                json j;
                CHECK_THROWS_WITH(is >> j,
                                "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");
                IF_EXCEPTIONS_ENABLED_THEN_CHECK(is.fail()); // Tests the badbit too
                IF_EXCEPTIONS_ENABLED_THEN_CHECK(is.bad());
                // Do not check the eofbit.
                // Some implementations keep the eofbit if is.unget() fails, some do not.
            }
            {
                unget_fails_stringbuf sb("\xEF", 1);
                std::istream is(&sb);

                json j;
                CHECK_THROWS_WITH(is >> j,
                                "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");
                IF_EXCEPTIONS_ENABLED_THEN_CHECK(is.fail()); // Tests the badbit too
                IF_EXCEPTIONS_ENABLED_THEN_CHECK(is.bad());
                // Do not check the eofbit.
                // Some implementations keep the eofbit if is.unget() fails, some do not.
            }
        }

        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 and i1 == 0 and i2 == 0)
                        {
                            // without any variation, we skip the BOM
                            CHECK(json::parse(s + "null") == json());
                            CHECK(json::parse(std::istringstream(s + "null")) == json());
                        }
                        else
                        {
                            // any variation is an error
                            CHECK_THROWS_AS(json::parse(s + "null"), json::parse_error&);
                            CHECK_THROWS_AS(json::parse(std::istringstream(s + "null")), json::parse_error&);
                        }
                    }
                }
            }
        }

        SECTION("preserve state after parsing - strings")
        {
            std::istringstream s(bom + "\"123\" \"456\"");
            json j;
            s >> j;
            CHECK(j == "123");
            CHECK(s.good());
            s >> j;
            CHECK(j == "456");
            CHECK(s.good());
            s.peek();
            CHECK(s.eof());
        }

        SECTION("preserve state after parsing - numbers (ref)")
        {
            std::istringstream s("123 456");
            int j;
            s >> j;
            CHECK(j == 123);
            CHECK(s.good());
            s >> j;
            CHECK(j == 456);
            CHECK(!s.good());
            CHECK(!s.fail());
            CHECK(!s.bad());
            // The stream now has the eofbit set (since to determine whether the number has completely
            // parsed, the lexer needs to read past the end of the file).
            CHECK(s.eof());
        }
        SECTION("preserve state after parsing - numbers")
        {
            std::istringstream s(bom + "123 456");
            json j;
            s >> j;
            CHECK(j == 123);
            CHECK(s.good());
            s >> j;
            CHECK(j == 456);
            CHECK(!s.good());
            CHECK(!s.fail());
            CHECK(!s.bad());
            // The stream now has the eofbit set (since to determine whether the number has completely
            // parsed, the lexer needs to read past the end of the file).
            CHECK(s.eof());
        }

        SECTION("preserve state after parsing - numbers (trailing space) (ref)")
        {
            std::istringstream s("123 456 ");
            int j;
            s >> j;
            CHECK(j == 123);
            CHECK(s.good());
            s >> j;
            CHECK(j == 456);
            // The trailing space at the end is the end of the number.
            // The stream should not have the eofbit set.
            CHECK(s.good());
            CHECK(s.peek() == static_cast<unsigned char>(' '));
        }
        SECTION("preserve state after parsing - numbers (trailing space)")
        {
            std::istringstream s(bom + "123 456 ");
            json j;
            s >> j;
            CHECK(j == 123);
            CHECK(s.good());
            s >> j;
            CHECK(j == 456);
            // The trailing space at the end is the end of the number.
            // The stream should not have the eofbit set.
            CHECK(s.good());
            CHECK(s.peek() == static_cast<unsigned char>(' '));
        }
    }
}