diff --git a/src/json.hpp b/src/json.hpp index 2df26ae0..fd63fe13 100644 --- a/src/json.hpp +++ b/src/json.hpp @@ -1265,6 +1265,270 @@ struct static_const template constexpr T static_const::value; + +//////////////////// +// input adapters // +//////////////////// + +/// abstract input adapter interface +struct input_adapter +{ + virtual int get_character() = 0; + virtual std::string read(size_t offset, size_t length) = 0; + virtual ~input_adapter() {} +}; + +/// a type to simplify interfaces +using input_adapter_t = std::shared_ptr; + +/// input adapter for cached stream input +template +class cached_input_stream_adapter : public input_adapter +{ + public: + cached_input_stream_adapter(std::istream& i) + : is(i), start_position(is.tellg()) + { + fill_buffer(); + + // skip byte order mark + if (fill_size >= 3 and buffer[0] == '\xEF' and buffer[1] == '\xBB' and buffer[2] == '\xBF') + { + buffer_pos += 3; + processed_chars += 3; + } + } + + ~cached_input_stream_adapter() override + { + // clear stream flags + is.clear(); + // We initially read a lot of characters into the buffer, and we + // may not have processed all of them. Therefore, we need to + // "rewind" the stream after the last processed char. + is.seekg(start_position); + is.ignore(static_cast(processed_chars)); + // clear stream flags + is.clear(); + } + + int get_character() override + { + // check if refilling is necessary and possible + if (buffer_pos == fill_size and not eof) + { + fill_buffer(); + + // check and remember that filling did not yield new input + if (fill_size == 0) + { + eof = true; + return std::char_traits::eof(); + } + + // the buffer is ready + buffer_pos = 0; + } + + ++processed_chars; + assert(buffer_pos < buffer.size()); + return buffer[buffer_pos++] & 0xFF; + } + + std::string read(size_t offset, size_t length) override + { + // create buffer + std::string result(length, '\0'); + + // save stream position + const auto current_pos = is.tellg(); + // save stream flags + const auto flags = is.rdstate(); + + // clear stream flags + is.clear(); + // set stream position + is.seekg(static_cast(offset)); + // read bytes + is.read(&result[0], static_cast(length)); + + // reset stream position + is.seekg(current_pos); + // reset stream flags + is.setstate(flags); + + return result; + } + + private: + void fill_buffer() + { + // fill + is.read(buffer.data(), static_cast(buffer.size())); + // store number of bytes in the buffer + fill_size = static_cast(is.gcount()); + } + + /// the associated input stream + std::istream& is; + + /// chars returned via get_character() + size_t processed_chars = 0; + /// chars processed in the current buffer + size_t buffer_pos = 0; + + /// whether stream reached eof + bool eof = false; + /// how many chars have been copied to the buffer by last (re)fill + size_t fill_size = 0; + + /// position of the stream when we started + const std::streampos start_position; + + /// internal buffer + std::array buffer{{}}; +}; + +/// input adapter for buffer input +class input_buffer_adapter : public input_adapter +{ + public: + input_buffer_adapter(const char* b, size_t l) + : input_adapter(), cursor(b), limit(b + l), start(b) + { + // skip byte order mark + if (l >= 3 and b[0] == '\xEF' and b[1] == '\xBB' and b[2] == '\xBF') + { + cursor += 3; + } + } + + // delete because of pointer members + input_buffer_adapter(const input_buffer_adapter&) = delete; + input_buffer_adapter& operator=(input_buffer_adapter&) = delete; + + int get_character() noexcept override + { + if (JSON_LIKELY(cursor < limit)) + { + return *(cursor++) & 0xFF; + } + else + { + return std::char_traits::eof(); + } + } + + std::string read(size_t offset, size_t length) override + { + // avoid reading too many characters + const size_t max_length = static_cast(limit - start); + return std::string(start + offset, (std::min)(length, max_length - offset)); + } + + private: + /// pointer to the current character + const char* cursor; + /// pointer past the last character + const char* limit; + /// pointer to the first character + const char* start; +}; + +struct input_adapter_factory +{ + // native support + + /// input adapter for input stream + static std::shared_ptr create(std::istream& i) + { + return std::make_shared> (i); + } + + /// input adapter for input stream + static std::shared_ptr create(std::istream&& i) + { + return std::make_shared>(i); + } + + /// input adapter for buffer + static std::shared_ptr create(const char* b, size_t l) + { + return std::make_shared(b, l); + } + + // derived support + + /// input adapter for string literal + template ::value and + std::is_integral< + typename std::remove_pointer::type>::value and + sizeof(typename std::remove_pointer::type) == 1, + int>::type = 0> + static std::shared_ptr create(CharT b) + { + return create(reinterpret_cast(b), + std::strlen(reinterpret_cast(b))); + } + + /// input adapter for iterator range with contiguous storage + template ::iterator_category, + std::random_access_iterator_tag>::value, + int>::type = 0> + static std::shared_ptr create(IteratorType first, + IteratorType last) + { + // assertion to check that the iterator range is indeed contiguous, + // see http://stackoverflow.com/a/35008842/266378 for more discussion + assert(std::accumulate( + first, last, std::pair(true, 0), + [&first](std::pair res, decltype(*first) val) + { + res.first &= + (val == + *(std::next(std::addressof(*first), res.second++))); + return res; + }) + .first); + + // assertion to check that each element is 1 byte long + static_assert( + sizeof(typename std::iterator_traits::value_type) == 1, "each element in the iterator range must have the size of 1 byte"); + + return create(reinterpret_cast(&(*first)), + static_cast(std::distance(first, last))); + } + + /// input adapter for array + template + static std::shared_ptr create(T (&array)[N]) + { + // delegate the call to the iterator-range overload + return create(std::begin(array), std::end(array)); + } + + /// input adapter for contiguous container + template < + class ContiguousContainer, + typename std::enable_if < + not std::is_pointer::value and + std::is_base_of()))>:: + iterator_category>::value, + int >::type = 0 > + static std::shared_ptr create(const ContiguousContainer& c) + { + // delegate the call to the iterator-range overload + return create(std::begin(c), std::end(c)); + } +}; + } // namespace detail @@ -7822,7 +8086,7 @@ class basic_json static basic_json parse(const CharT s, const parser_callback_t cb = nullptr) { - return parser(input_adapter::create(s), cb).parse(true); + return parser(detail::input_adapter_factory::create(s), cb).parse(true); } template::type) == 1, int>::type = 0> static bool accept(const CharT s) { - return parser(input_adapter::create(s)).accept(true); + return parser(detail::input_adapter_factory::create(s)).accept(true); } /*! @@ -7865,12 +8129,12 @@ class basic_json static basic_json parse(std::istream& i, const parser_callback_t cb = nullptr) { - return parser(input_adapter::create(i), cb).parse(true); + return parser(detail::input_adapter_factory::create(i), cb).parse(true); } static bool accept(std::istream& i) { - return parser(input_adapter::create(i)).accept(true); + return parser(detail::input_adapter_factory::create(i)).accept(true); } /*! @@ -7879,12 +8143,12 @@ class basic_json static basic_json parse(std::istream&& i, const parser_callback_t cb = nullptr) { - return parser(input_adapter::create(i), cb).parse(true); + return parser(detail::input_adapter_factory::create(i), cb).parse(true); } static bool accept(std::istream&& i) { - return parser(input_adapter::create(i)).accept(true); + return parser(detail::input_adapter_factory::create(i)).accept(true); } /*! @@ -7939,7 +8203,7 @@ class basic_json static basic_json parse(IteratorType first, IteratorType last, const parser_callback_t cb = nullptr) { - return parser(input_adapter::create(first, last), cb).parse(true); + return parser(detail::input_adapter_factory::create(first, last), cb).parse(true); } template::iterator_category>::value, int>::type = 0> static bool accept(IteratorType first, IteratorType last) { - return parser(input_adapter::create(first, last)).accept(true); + return parser(detail::input_adapter_factory::create(first, last)).accept(true); } /*! @@ -8030,7 +8294,7 @@ class basic_json JSON_DEPRECATED friend std::istream& operator<<(basic_json& j, std::istream& i) { - j = parser(input_adapter::create(i)).parse(false); + j = parser(detail::input_adapter_factory::create(i)).parse(false); return i; } @@ -8061,7 +8325,7 @@ class basic_json */ friend std::istream& operator>>(std::istream& i, basic_json& j) { - j = parser(input_adapter::create(i)).parse(false); + j = parser(detail::input_adapter_factory::create(i)).parse(false); return i; } @@ -9100,263 +9364,6 @@ class basic_json private: - //////////////////// - // input adapters // - //////////////////// - - /// abstract input adapter interface - class input_adapter - { - public: - virtual int get_character() = 0; - virtual std::string read(size_t offset, size_t length) = 0; - virtual ~input_adapter() {} - - // native support - - /// input adapter for input stream - static std::shared_ptr create(std::istream& i) - { - return std::make_shared> (i); - } - - /// input adapter for input stream - static std::shared_ptr create(std::istream&& i) - { - return std::make_shared>(i); - } - - /// input adapter for buffer - static std::shared_ptr create(const char* b, size_t l) - { - return std::make_shared(b, l); - } - - // derived support - - /// input adapter for string literal - template::value and - std::is_integral::type>::value and - sizeof(typename std::remove_pointer::type) == 1, int>::type = 0> - static std::shared_ptr create(CharT b) - { - return create(reinterpret_cast(b), - std::strlen(reinterpret_cast(b))); - } - - /// input adapter for iterator range with contiguous storage - template::iterator_category, std::random_access_iterator_tag>::value - , int>::type - = 0> - static std::shared_ptr create(IteratorType first, IteratorType last) - { - // assertion to check that the iterator range is indeed contiguous, - // see http://stackoverflow.com/a/35008842/266378 for more discussion - assert(std::accumulate(first, last, std::pair(true, 0), - [&first](std::pair res, decltype(*first) val) - { - res.first &= (val == *(std::next(std::addressof(*first), res.second++))); - return res; - }).first); - - // assertion to check that each element is 1 byte long - static_assert(sizeof(typename std::iterator_traits::value_type) == 1, - "each element in the iterator range must have the size of 1 byte"); - - const auto len = static_cast(std::distance(first, last)); - if (JSON_LIKELY(len > 0)) - { - // there is at least one element: use the address of first - return create(reinterpret_cast(&(*first)), len); - } - else - { - // the address of first cannot be used - use nullptr - return create(nullptr, len); - } - } - - /// input adapter for array - template - static std::shared_ptr create(T (&array)[N]) - { - // delegate the call to the iterator-range overload - return create(std::begin(array), std::end(array)); - } - - /// input adapter for contiguous container - template::value and - std::is_base_of< - std::random_access_iterator_tag, - typename std::iterator_traits()))>::iterator_category>::value - , int>::type = 0> - static std::shared_ptr create(const ContiguousContainer& c) - { - // delegate the call to the iterator-range overload - return create(std::begin(c), std::end(c)); - } - }; - - /// a type to simplify interfaces - using input_adapter_t = std::shared_ptr; - - /// input adapter for cached stream input - template - class cached_input_stream_adapter : public input_adapter - { - public: - cached_input_stream_adapter(std::istream& i) - : is(i), start_position(is.tellg()) - { - fill_buffer(); - - // skip byte order mark - if (fill_size >= 3 and buffer[0] == '\xEF' and buffer[1] == '\xBB' and buffer[2] == '\xBF') - { - buffer_pos += 3; - processed_chars += 3; - } - } - - ~cached_input_stream_adapter() override - { - // clear stream flags - is.clear(); - // We initially read a lot of characters into the buffer, and we - // may not have processed all of them. Therefore, we need to - // "rewind" the stream after the last processed char. - is.seekg(start_position); - is.ignore(static_cast(processed_chars)); - // clear stream flags - is.clear(); - } - - int get_character() override - { - // check if refilling is necessary and possible - if (buffer_pos == fill_size and not eof) - { - fill_buffer(); - - // check and remember that filling did not yield new input - if (fill_size == 0) - { - eof = true; - return std::char_traits::eof(); - } - - // the buffer is ready - buffer_pos = 0; - } - - ++processed_chars; - assert(buffer_pos < buffer.size()); - return buffer[buffer_pos++] & 0xFF; - } - - std::string read(size_t offset, size_t length) override - { - // create buffer - std::string result(length, '\0'); - - // save stream position - const auto current_pos = is.tellg(); - // save stream flags - const auto flags = is.rdstate(); - - // clear stream flags - is.clear(); - // set stream position - is.seekg(static_cast(offset)); - // read bytes - is.read(&result[0], static_cast(length)); - - // reset stream position - is.seekg(current_pos); - // reset stream flags - is.setstate(flags); - - return result; - } - - private: - void fill_buffer() - { - // fill - is.read(buffer.data(), static_cast(buffer.size())); - // store number of bytes in the buffer - fill_size = static_cast(is.gcount()); - } - - /// the associated input stream - std::istream& is; - - /// chars returned via get_character() - size_t processed_chars = 0; - /// chars processed in the current buffer - size_t buffer_pos = 0; - - /// whether stream reached eof - bool eof = false; - /// how many chars have been copied to the buffer by last (re)fill - size_t fill_size = 0; - - /// position of the stream when we started - const std::streampos start_position; - - /// internal buffer - std::array buffer{{}}; - }; - - /// input adapter for buffer input - class input_buffer_adapter : public input_adapter - { - public: - input_buffer_adapter(const char* b, size_t l) - : input_adapter(), cursor(b), limit(b + l), start(b) - { - // skip byte order mark - if (l >= 3 and b[0] == '\xEF' and b[1] == '\xBB' and b[2] == '\xBF') - { - cursor += 3; - } - } - - // delete because of pointer members - input_buffer_adapter(const input_buffer_adapter&) = delete; - input_buffer_adapter& operator=(input_buffer_adapter&) = delete; - - int get_character() noexcept override - { - if (JSON_LIKELY(cursor < limit)) - { - return *(cursor++) & 0xFF; - } - else - { - return std::char_traits::eof(); - } - } - - std::string read(size_t offset, size_t length) override - { - // avoid reading too many characters - const size_t max_length = static_cast(limit - start); - return std::string(start + offset, (std::min)(length, max_length - offset)); - } - - private: - /// pointer to the current character - const char* cursor; - /// pointer past the last character - const char* limit; - /// pointer to the first character - const char* start; - }; - ////////////////////////////////////////// // binary serialization/deserialization // ////////////////////////////////////////// @@ -9364,7 +9371,6 @@ class basic_json /// @name binary serialization/deserialization support /// @{ - private: /*! @brief deserialization of CBOR and MessagePack values */ @@ -9376,7 +9382,7 @@ class basic_json @param[in] adapter input adapter to read from */ - explicit binary_reader(input_adapter_t adapter) + explicit binary_reader(detail::input_adapter_t adapter) : ia(adapter), is_little_endian(little_endianess()) { assert(ia); @@ -10489,7 +10495,7 @@ class basic_json private: /// input adapter - input_adapter_t ia = nullptr; + detail::input_adapter_t ia = nullptr; /// the current character int current = std::char_traits::eof(); @@ -11299,7 +11305,7 @@ class basic_json static basic_json from_cbor(const std::vector& v, const size_t start_index = 0) { - binary_reader br(input_adapter::create(v.begin() + static_cast(start_index), v.end())); + binary_reader br(detail::input_adapter_factory::create(v.begin() + static_cast(start_index), v.end())); return br.parse_cbor(); } @@ -11374,7 +11380,7 @@ class basic_json static basic_json from_msgpack(const std::vector& v, const size_t start_index = 0) { - binary_reader br(input_adapter::create(v.begin() + static_cast(start_index), v.end())); + binary_reader br(detail::input_adapter_factory::create(v.begin() + static_cast(start_index), v.end())); return br.parse_msgpack(); } @@ -11460,7 +11466,7 @@ class basic_json } } - explicit lexer(input_adapter_t adapter) + explicit lexer(detail::input_adapter_t adapter) : ia(adapter), decimal_point_char(get_decimal_point()) {} @@ -12864,7 +12870,7 @@ scan_number_done: private: /// input adapter - input_adapter_t ia = nullptr; + detail::input_adapter_t ia = nullptr; /// the current character int current = std::char_traits::eof(); @@ -12903,7 +12909,7 @@ scan_number_done: { public: /// a parser reading from an input adapter - explicit parser(input_adapter_t adapter, + explicit parser(detail::input_adapter_t adapter, const parser_callback_t cb = nullptr) : callback(cb), m_lexer(adapter) {} diff --git a/test/src/unit-class_lexer.cpp b/test/src/unit-class_lexer.cpp index 071337b5..794feb4e 100644 --- a/test/src/unit-class_lexer.cpp +++ b/test/src/unit-class_lexer.cpp @@ -36,7 +36,7 @@ using nlohmann::json; json::lexer::token_type scan_string(const char* s); json::lexer::token_type scan_string(const char* s) { - return json::lexer(json::input_adapter::create(s)).scan(); + return json::lexer(nlohmann::detail::input_adapter_factory::create(s)).scan(); } TEST_CASE("lexer class") diff --git a/test/src/unit-class_parser.cpp b/test/src/unit-class_parser.cpp index 7a8378a7..59765eda 100644 --- a/test/src/unit-class_parser.cpp +++ b/test/src/unit-class_parser.cpp @@ -40,30 +40,30 @@ TEST_CASE("parser class") { SECTION("null") { - CHECK(json::parser(json::input_adapter::create(std::string("null"))).parse() == json(nullptr)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("null"))).parse() == json(nullptr)); } SECTION("true") { - CHECK(json::parser(json::input_adapter::create(std::string("true"))).parse() == json(true)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("true"))).parse() == json(true)); } SECTION("false") { - CHECK(json::parser(json::input_adapter::create(std::string("false"))).parse() == json(false)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("false"))).parse() == json(false)); } SECTION("array") { SECTION("empty array") { - CHECK(json::parser(json::input_adapter::create(std::string("[]"))).parse() == json(json::value_t::array)); - CHECK(json::parser(json::input_adapter::create(std::string("[ ]"))).parse() == json(json::value_t::array)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[]"))).parse() == json(json::value_t::array)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[ ]"))).parse() == json(json::value_t::array)); } SECTION("nonempty array") { - CHECK(json::parser(json::input_adapter::create(std::string("[true, false, null]"))).parse() == json({true, false, nullptr})); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[true, false, null]"))).parse() == json({true, false, nullptr})); } } @@ -71,113 +71,113 @@ TEST_CASE("parser class") { SECTION("empty object") { - CHECK(json::parser(json::input_adapter::create(std::string("{}"))).parse() == json(json::value_t::object)); - CHECK(json::parser(json::input_adapter::create(std::string("{ }"))).parse() == json(json::value_t::object)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{}"))).parse() == json(json::value_t::object)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{ }"))).parse() == json(json::value_t::object)); } SECTION("nonempty object") { - CHECK(json::parser(json::input_adapter::create(std::string("{\"\": true, \"one\": 1, \"two\": null}"))).parse() == json({{"", true}, {"one", 1}, {"two", nullptr}})); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"\": true, \"one\": 1, \"two\": null}"))).parse() == json({{"", true}, {"one", 1}, {"two", nullptr}})); } } SECTION("string") { // empty string - CHECK(json::parser(json::input_adapter::create(std::string("\"\""))).parse() == json(json::value_t::string)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\""))).parse() == json(json::value_t::string)); SECTION("errors") { // error: tab in string - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\t\""))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\t\""))).parse(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\t\""))).parse(), json::parse_error&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\t\""))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid string: control character must be escaped; last read: '\"'"); // error: newline in string - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\n\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\r\""))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\n\""))).parse(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\n\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\r\""))).parse(), json::parse_error&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\n\""))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid string: control character must be escaped; last read: '\"'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\r\""))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\r\""))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid string: control character must be escaped; last read: '\"'"); // error: backspace in string - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\b\""))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\b\""))).parse(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\b\""))).parse(), json::parse_error&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\b\""))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid string: control character must be escaped; last read: '\"'"); // improve code coverage - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\uFF01"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("[-4:1,]"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\uFF01"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[-4:1,]"))).parse(), json::parse_error&); // unescaped control characters - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x00\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x01\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x02\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x03\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x04\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x05\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x06\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x07\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x08\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x09\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x0a\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x0b\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x0c\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x0d\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x0e\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x0f\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x10\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x11\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x12\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x13\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x14\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x15\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x16\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x17\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x18\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x19\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x1a\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x1b\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x1c\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x1d\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x1e\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x1f\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x00\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x01\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x02\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x03\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x04\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x05\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x06\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x07\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x08\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x09\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0a\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0b\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0c\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0d\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0e\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0f\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x10\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x11\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x12\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x13\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x14\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x15\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x16\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x17\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x18\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x19\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1a\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1b\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1c\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1d\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1e\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1f\""))).parse(), json::parse_error&); } SECTION("escaped") { // quotation mark "\"" auto r1 = R"("\"")"_json; - CHECK(json::parser(json::input_adapter::create(std::string("\"\\\"\""))).parse() == r1); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\"\""))).parse() == r1); // reverse solidus "\\" auto r2 = R"("\\")"_json; - CHECK(json::parser(json::input_adapter::create(std::string("\"\\\\\""))).parse() == r2); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\\\""))).parse() == r2); // solidus - CHECK(json::parser(json::input_adapter::create(std::string("\"\\/\""))).parse() == R"("/")"_json); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\/\""))).parse() == R"("/")"_json); // backspace - CHECK(json::parser(json::input_adapter::create(std::string("\"\\b\""))).parse() == json("\b")); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\b\""))).parse() == json("\b")); // formfeed - CHECK(json::parser(json::input_adapter::create(std::string("\"\\f\""))).parse() == json("\f")); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\f\""))).parse() == json("\f")); // newline - CHECK(json::parser(json::input_adapter::create(std::string("\"\\n\""))).parse() == json("\n")); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\n\""))).parse() == json("\n")); // carriage return - CHECK(json::parser(json::input_adapter::create(std::string("\"\\r\""))).parse() == json("\r")); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\r\""))).parse() == json("\r")); // horizontal tab - CHECK(json::parser(json::input_adapter::create(std::string("\"\\t\""))).parse() == json("\t")); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\t\""))).parse() == json("\t")); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0001\""))).parse().get() == "\x01"); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u000a\""))).parse().get() == "\n"); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u00b0\""))).parse().get() == "°"); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0c00\""))).parse().get() == "ఀ"); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud000\""))).parse().get() == "퀀"); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u000E\""))).parse().get() == "\x0E"); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u00F0\""))).parse().get() == "ð"); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0100\""))).parse().get() == "Ā"); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u2000\""))).parse().get() == " "); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\uFFFF\""))).parse().get() == "￿"); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u20AC\""))).parse().get() == "€"); - CHECK(json::parser(json::input_adapter::create(std::string("\"€\""))).parse().get() == "€"); - CHECK(json::parser(json::input_adapter::create(std::string("\"🎈\""))).parse().get() == "🎈"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0001\""))).parse().get() == "\x01"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u000a\""))).parse().get() == "\n"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u00b0\""))).parse().get() == "°"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0c00\""))).parse().get() == "ఀ"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\ud000\""))).parse().get() == "퀀"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u000E\""))).parse().get() == "\x0E"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u00F0\""))).parse().get() == "ð"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0100\""))).parse().get() == "Ā"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u2000\""))).parse().get() == " "); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\uFFFF\""))).parse().get() == "￿"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u20AC\""))).parse().get() == "€"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"€\""))).parse().get() == "€"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"🎈\""))).parse().get() == "🎈"); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud80c\\udc60\""))).parse().get() == u8"\U00013060"); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud83c\\udf1e\""))).parse().get() == "🌞"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\ud80c\\udc60\""))).parse().get() == u8"\U00013060"); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\ud83c\\udf1e\""))).parse().get() == "🌞"); } } @@ -187,40 +187,40 @@ TEST_CASE("parser class") { SECTION("without exponent") { - CHECK(json::parser(json::input_adapter::create(std::string("-128"))).parse() == json(-128)); - CHECK(json::parser(json::input_adapter::create(std::string("-0"))).parse() == json(-0)); - CHECK(json::parser(json::input_adapter::create(std::string("0"))).parse() == json(0)); - CHECK(json::parser(json::input_adapter::create(std::string("128"))).parse() == json(128)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128"))).parse() == json(-128)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0"))).parse() == json(-0)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0"))).parse() == json(0)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("128"))).parse() == json(128)); } SECTION("with exponent") { - CHECK(json::parser(json::input_adapter::create(std::string("0e1"))).parse() == json(0e1)); - CHECK(json::parser(json::input_adapter::create(std::string("0E1"))).parse() == json(0e1)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0e1"))).parse() == json(0e1)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0E1"))).parse() == json(0e1)); - CHECK(json::parser(json::input_adapter::create(std::string("10000E-4"))).parse() == json(10000e-4)); - CHECK(json::parser(json::input_adapter::create(std::string("10000E-3"))).parse() == json(10000e-3)); - CHECK(json::parser(json::input_adapter::create(std::string("10000E-2"))).parse() == json(10000e-2)); - CHECK(json::parser(json::input_adapter::create(std::string("10000E-1"))).parse() == json(10000e-1)); - CHECK(json::parser(json::input_adapter::create(std::string("10000E0"))).parse() == json(10000e0)); - CHECK(json::parser(json::input_adapter::create(std::string("10000E1"))).parse() == json(10000e1)); - CHECK(json::parser(json::input_adapter::create(std::string("10000E2"))).parse() == json(10000e2)); - CHECK(json::parser(json::input_adapter::create(std::string("10000E3"))).parse() == json(10000e3)); - CHECK(json::parser(json::input_adapter::create(std::string("10000E4"))).parse() == json(10000e4)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-4"))).parse() == json(10000e-4)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-3"))).parse() == json(10000e-3)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-2"))).parse() == json(10000e-2)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-1"))).parse() == json(10000e-1)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E0"))).parse() == json(10000e0)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E1"))).parse() == json(10000e1)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E2"))).parse() == json(10000e2)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E3"))).parse() == json(10000e3)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E4"))).parse() == json(10000e4)); - CHECK(json::parser(json::input_adapter::create(std::string("10000e-4"))).parse() == json(10000e-4)); - CHECK(json::parser(json::input_adapter::create(std::string("10000e-3"))).parse() == json(10000e-3)); - CHECK(json::parser(json::input_adapter::create(std::string("10000e-2"))).parse() == json(10000e-2)); - CHECK(json::parser(json::input_adapter::create(std::string("10000e-1"))).parse() == json(10000e-1)); - CHECK(json::parser(json::input_adapter::create(std::string("10000e0"))).parse() == json(10000e0)); - CHECK(json::parser(json::input_adapter::create(std::string("10000e1"))).parse() == json(10000e1)); - CHECK(json::parser(json::input_adapter::create(std::string("10000e2"))).parse() == json(10000e2)); - CHECK(json::parser(json::input_adapter::create(std::string("10000e3"))).parse() == json(10000e3)); - CHECK(json::parser(json::input_adapter::create(std::string("10000e4"))).parse() == json(10000e4)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-4"))).parse() == json(10000e-4)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-3"))).parse() == json(10000e-3)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-2"))).parse() == json(10000e-2)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-1"))).parse() == json(10000e-1)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e0"))).parse() == json(10000e0)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e1"))).parse() == json(10000e1)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e2"))).parse() == json(10000e2)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e3"))).parse() == json(10000e3)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e4"))).parse() == json(10000e4)); - CHECK(json::parser(json::input_adapter::create(std::string("-0e1"))).parse() == json(-0e1)); - CHECK(json::parser(json::input_adapter::create(std::string("-0E1"))).parse() == json(-0e1)); - CHECK(json::parser(json::input_adapter::create(std::string("-0E123"))).parse() == json(-0e123)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e1"))).parse() == json(-0e1)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E1"))).parse() == json(-0e1)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E123"))).parse() == json(-0e123)); } SECTION("edge cases") @@ -232,9 +232,9 @@ TEST_CASE("parser class") // agree exactly on their numeric values. // -(2**53)+1 - CHECK(json::parser(json::input_adapter::create(std::string("-9007199254740991"))).parse().get() == -9007199254740991); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-9007199254740991"))).parse().get() == -9007199254740991); // (2**53)-1 - CHECK(json::parser(json::input_adapter::create(std::string("9007199254740991"))).parse().get() == 9007199254740991); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("9007199254740991"))).parse().get() == 9007199254740991); } SECTION("over the edge cases") // issue #178 - Integer conversion to unsigned (incorrect handling of 64 bit integers) @@ -247,11 +247,11 @@ TEST_CASE("parser class") // i.e. -(2**63) -> (2**64)-1. // -(2**63) ** Note: compilers see negative literals as negated positive numbers (hence the -1)) - CHECK(json::parser(json::input_adapter::create(std::string("-9223372036854775808"))).parse().get() == -9223372036854775807 - 1); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-9223372036854775808"))).parse().get() == -9223372036854775807 - 1); // (2**63)-1 - CHECK(json::parser(json::input_adapter::create(std::string("9223372036854775807"))).parse().get() == 9223372036854775807); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("9223372036854775807"))).parse().get() == 9223372036854775807); // (2**64)-1 - CHECK(json::parser(json::input_adapter::create(std::string("18446744073709551615"))).parse().get() == 18446744073709551615u); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("18446744073709551615"))).parse().get() == 18446744073709551615u); } } @@ -259,85 +259,85 @@ TEST_CASE("parser class") { SECTION("without exponent") { - CHECK(json::parser(json::input_adapter::create(std::string("-128.5"))).parse() == json(-128.5)); - CHECK(json::parser(json::input_adapter::create(std::string("0.999"))).parse() == json(0.999)); - CHECK(json::parser(json::input_adapter::create(std::string("128.5"))).parse() == json(128.5)); - CHECK(json::parser(json::input_adapter::create(std::string("-0.0"))).parse() == json(-0.0)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128.5"))).parse() == json(-128.5)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0.999"))).parse() == json(0.999)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("128.5"))).parse() == json(128.5)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0"))).parse() == json(-0.0)); } SECTION("with exponent") { - CHECK(json::parser(json::input_adapter::create(std::string("-128.5E3"))).parse() == json(-128.5E3)); - CHECK(json::parser(json::input_adapter::create(std::string("-128.5E-3"))).parse() == json(-128.5E-3)); - CHECK(json::parser(json::input_adapter::create(std::string("-0.0e1"))).parse() == json(-0.0e1)); - CHECK(json::parser(json::input_adapter::create(std::string("-0.0E1"))).parse() == json(-0.0e1)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128.5E3"))).parse() == json(-128.5E3)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128.5E-3"))).parse() == json(-128.5E-3)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0e1"))).parse() == json(-0.0e1)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0E1"))).parse() == json(-0.0e1)); } } SECTION("overflow") { // overflows during parsing yield an exception - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1.18973e+4932"))).parse() == json(), json::out_of_range&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1.18973e+4932"))).parse() == json(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1.18973e+4932"))).parse() == json(), json::out_of_range&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1.18973e+4932"))).parse() == json(), "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'"); } SECTION("invalid numbers") { - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("01"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("--1"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1."))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1E"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1E-"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1.E1"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-1E"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0E#"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0E-#"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0#"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0.0:"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0.0Z"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0E123:"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0e0-:"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0e-:"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0f"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("01"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("--1"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1."))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E-"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1.E1"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-1E"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E#"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E-#"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0#"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0:"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0Z"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E123:"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e0-:"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e-:"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0f"))).parse(), json::parse_error&); // numbers must not begin with "+" - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("+1"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("+0"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("+1"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("+0"))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("01"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("01"))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - unexpected number literal; expected end of input"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-01"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-01"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - unexpected number literal; expected end of input"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("--1"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("--1"))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid number; expected digit after '-'; last read: '--'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1."))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1."))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected digit after '.'; last read: '1.'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1E"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1E'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1E-"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E-"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid number; expected digit after exponent sign; last read: '1E-'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1.E1"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1.E1"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected digit after '.'; last read: '1.E'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-1E"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-1E"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '-1E'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0E#"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E#"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '-0E#'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0E-#"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E-#"))).parse(), "[json.exception.parse_error.101] parse error at 5: syntax error - invalid number; expected digit after exponent sign; last read: '-0E-#'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0#"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0#"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid literal; last read: '-0#'; expected end of input"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0.0:"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0:"))).parse(), "[json.exception.parse_error.101] parse error at 5: syntax error - unexpected ':'; expected end of input"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0.0Z"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0Z"))).parse(), "[json.exception.parse_error.101] parse error at 5: syntax error - invalid literal; last read: '-0.0Z'; expected end of input"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0E123:"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E123:"))).parse(), "[json.exception.parse_error.101] parse error at 7: syntax error - unexpected ':'; expected end of input"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0e0-:"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e0-:"))).parse(), "[json.exception.parse_error.101] parse error at 6: syntax error - invalid number; expected digit after '-'; last read: '-:'; expected end of input"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0e-:"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e-:"))).parse(), "[json.exception.parse_error.101] parse error at 5: syntax error - invalid number; expected digit after exponent sign; last read: '-0e-:'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0f"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0f"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid literal; last read: '-0f'; expected end of input"); } } @@ -347,30 +347,30 @@ TEST_CASE("parser class") { SECTION("null") { - CHECK(json::parser(json::input_adapter::create(std::string("null"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("null"))).accept()); } SECTION("true") { - CHECK(json::parser(json::input_adapter::create(std::string("true"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("true"))).accept()); } SECTION("false") { - CHECK(json::parser(json::input_adapter::create(std::string("false"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("false"))).accept()); } SECTION("array") { SECTION("empty array") { - CHECK(json::parser(json::input_adapter::create(std::string("[]"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("[ ]"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[]"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[ ]"))).accept()); } SECTION("nonempty array") { - CHECK(json::parser(json::input_adapter::create(std::string("[true, false, null]"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[true, false, null]"))).accept()); } } @@ -378,105 +378,105 @@ TEST_CASE("parser class") { SECTION("empty object") { - CHECK(json::parser(json::input_adapter::create(std::string("{}"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("{ }"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{}"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{ }"))).accept()); } SECTION("nonempty object") { - CHECK(json::parser(json::input_adapter::create(std::string("{\"\": true, \"one\": 1, \"two\": null}"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"\": true, \"one\": 1, \"two\": null}"))).accept()); } } SECTION("string") { // empty string - CHECK(json::parser(json::input_adapter::create(std::string("\"\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\""))).accept()); SECTION("errors") { // error: tab in string - CHECK(json::parser(json::input_adapter::create(std::string("\"\t\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\t\""))).accept() == false); // error: newline in string - CHECK(json::parser(json::input_adapter::create(std::string("\"\n\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\r\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\n\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\r\""))).accept() == false); // error: backspace in string - CHECK(json::parser(json::input_adapter::create(std::string("\"\b\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\b\""))).accept() == false); // improve code coverage - CHECK(json::parser(json::input_adapter::create(std::string("\uFF01"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("[-4:1,]"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\uFF01"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[-4:1,]"))).accept() == false); // unescaped control characters - CHECK(json::parser(json::input_adapter::create(std::string("\"\x00\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x01\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x02\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x03\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x04\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x05\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x06\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x07\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x08\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x09\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x0a\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x0b\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x0c\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x0d\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x0e\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x0f\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x10\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x11\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x12\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x13\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x14\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x15\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x16\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x17\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x18\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x19\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x1a\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x1b\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x1c\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x1d\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x1e\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\x1f\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x00\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x01\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x02\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x03\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x04\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x05\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x06\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x07\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x08\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x09\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0a\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0b\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0c\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0d\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0e\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0f\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x10\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x11\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x12\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x13\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x14\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x15\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x16\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x17\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x18\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x19\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1a\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1b\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1c\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1d\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1e\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1f\""))).accept() == false); } SECTION("escaped") { // quotation mark "\"" auto r1 = R"("\"")"_json; - CHECK(json::parser(json::input_adapter::create(std::string("\"\\\"\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\"\""))).accept()); // reverse solidus "\\" auto r2 = R"("\\")"_json; - CHECK(json::parser(json::input_adapter::create(std::string("\"\\\\\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\\\""))).accept()); // solidus - CHECK(json::parser(json::input_adapter::create(std::string("\"\\/\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\/\""))).accept()); // backspace - CHECK(json::parser(json::input_adapter::create(std::string("\"\\b\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\b\""))).accept()); // formfeed - CHECK(json::parser(json::input_adapter::create(std::string("\"\\f\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\f\""))).accept()); // newline - CHECK(json::parser(json::input_adapter::create(std::string("\"\\n\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\n\""))).accept()); // carriage return - CHECK(json::parser(json::input_adapter::create(std::string("\"\\r\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\r\""))).accept()); // horizontal tab - CHECK(json::parser(json::input_adapter::create(std::string("\"\\t\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\t\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0001\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u000a\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u00b0\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0c00\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud000\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u000E\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u00F0\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0100\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u2000\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\uFFFF\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u20AC\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"€\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"🎈\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0001\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u000a\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u00b0\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0c00\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\ud000\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u000E\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u00F0\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0100\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u2000\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\uFFFF\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u20AC\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"€\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"🎈\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud80c\\udc60\""))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud83c\\udf1e\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\ud80c\\udc60\""))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\ud83c\\udf1e\""))).accept()); } } @@ -486,40 +486,40 @@ TEST_CASE("parser class") { SECTION("without exponent") { - CHECK(json::parser(json::input_adapter::create(std::string("-128"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("-0"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("0"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("128"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("128"))).accept()); } SECTION("with exponent") { - CHECK(json::parser(json::input_adapter::create(std::string("0e1"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("0E1"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0e1"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0E1"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000E-4"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000E-3"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000E-2"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000E-1"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000E0"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000E1"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000E2"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000E3"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000E4"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-4"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-3"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-2"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-1"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E0"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E1"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E2"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E3"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E4"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000e-4"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000e-3"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000e-2"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000e-1"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000e0"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000e1"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000e2"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000e3"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("10000e4"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-4"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-3"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-2"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-1"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e0"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e1"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e2"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e3"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e4"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("-0e1"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("-0E1"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("-0E123"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e1"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E1"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E123"))).accept()); } SECTION("edge cases") @@ -531,9 +531,9 @@ TEST_CASE("parser class") // agree exactly on their numeric values. // -(2**53)+1 - CHECK(json::parser(json::input_adapter::create(std::string("-9007199254740991"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-9007199254740991"))).accept()); // (2**53)-1 - CHECK(json::parser(json::input_adapter::create(std::string("9007199254740991"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("9007199254740991"))).accept()); } SECTION("over the edge cases") // issue #178 - Integer conversion to unsigned (incorrect handling of 64 bit integers) @@ -546,11 +546,11 @@ TEST_CASE("parser class") // i.e. -(2**63) -> (2**64)-1. // -(2**63) ** Note: compilers see negative literals as negated positive numbers (hence the -1)) - CHECK(json::parser(json::input_adapter::create(std::string("-9223372036854775808"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-9223372036854775808"))).accept()); // (2**63)-1 - CHECK(json::parser(json::input_adapter::create(std::string("9223372036854775807"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("9223372036854775807"))).accept()); // (2**64)-1 - CHECK(json::parser(json::input_adapter::create(std::string("18446744073709551615"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("18446744073709551615"))).accept()); } } @@ -558,49 +558,49 @@ TEST_CASE("parser class") { SECTION("without exponent") { - CHECK(json::parser(json::input_adapter::create(std::string("-128.5"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("0.999"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("128.5"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("-0.0"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128.5"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0.999"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("128.5"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0"))).accept()); } SECTION("with exponent") { - CHECK(json::parser(json::input_adapter::create(std::string("-128.5E3"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("-128.5E-3"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("-0.0e1"))).accept()); - CHECK(json::parser(json::input_adapter::create(std::string("-0.0E1"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128.5E3"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128.5E-3"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0e1"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0E1"))).accept()); } } SECTION("overflow") { // overflows during parsing yield an exception, but is accepted anyway - CHECK(json::parser(json::input_adapter::create(std::string("1.18973e+4932"))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1.18973e+4932"))).accept()); } SECTION("invalid numbers") { - CHECK(json::parser(json::input_adapter::create(std::string("01"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("--1"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("1."))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("1E"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("1E-"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("1.E1"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-1E"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-0E#"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-0E-#"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-0#"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-0.0:"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-0.0Z"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-0E123:"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-0e0-:"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-0e-:"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-0f"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("01"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("--1"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1."))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E-"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1.E1"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-1E"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E#"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E-#"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0#"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0:"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0Z"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E123:"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e0-:"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e-:"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0f"))).accept() == false); // numbers must not begin with "+" - CHECK(json::parser(json::input_adapter::create(std::string("+1"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("+0"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("+1"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("+0"))).accept() == false); } } } @@ -608,152 +608,152 @@ TEST_CASE("parser class") SECTION("parse errors") { // unexpected end of number - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("0."))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("--"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0."))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-."))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-:"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("0.:"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("e."))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1e."))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1e/"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1e:"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1E."))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1E/"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1E:"))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("0."))).parse(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0."))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("--"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0."))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-."))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-:"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0.:"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("e."))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e."))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e/"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e:"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E."))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E/"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E:"))).parse(), json::parse_error&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0."))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected digit after '.'; last read: '0.'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-"))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid number; expected digit after '-'; last read: '-'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("--"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("--"))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid number; expected digit after '-'; last read: '--'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0."))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0."))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid number; expected digit after '.'; last read: '-0.'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-."))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-."))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid number; expected digit after '-'; last read: '-.'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-:"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-:"))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid number; expected digit after '-'; last read: '-:'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("0.:"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0.:"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected digit after '.'; last read: '0.:'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("e."))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("e."))).parse(), "[json.exception.parse_error.101] parse error at 1: syntax error - invalid literal; last read: 'e'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1e."))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e."))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1e.'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1e/"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e/"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1e/'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1e:"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e:"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1e:'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1E."))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E."))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1E.'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1E/"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E/"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1E/'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1E:"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E:"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1E:'"); // unexpected end of null - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("n"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("nu"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("nul"))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("n"))).parse(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("n"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("nu"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("nul"))).parse(), json::parse_error&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("n"))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid literal; last read: 'n'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("nu"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("nu"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid literal; last read: 'nu'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("nul"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("nul"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid literal; last read: 'nul'"); // unexpected end of true - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("t"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("tr"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("tru"))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("t"))).parse(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("t"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("tr"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("tru"))).parse(), json::parse_error&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("t"))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid literal; last read: 't'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("tr"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("tr"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid literal; last read: 'tr'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("tru"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("tru"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid literal; last read: 'tru'"); // unexpected end of false - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("f"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("fa"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("fal"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("fals"))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("f"))).parse(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("f"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fa"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fal"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fals"))).parse(), json::parse_error&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("f"))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid literal; last read: 'f'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("fa"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fa"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid literal; last read: 'fa'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("fal"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fal"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid literal; last read: 'fal'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("fals"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fals"))).parse(), "[json.exception.parse_error.101] parse error at 5: syntax error - invalid literal; last read: 'fals'"); // missing/unexpected end of array - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("["))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("[1"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("[1,"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("[1,]"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("]"))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("["))).parse(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("["))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1,"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1,]"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("]"))).parse(), json::parse_error&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("["))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - unexpected end of input; expected '[', '{', or a literal"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("[1"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - unexpected end of input; expected ']'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("[1,"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1,"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - unexpected end of input; expected '[', '{', or a literal"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("[1,]"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1,]"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - unexpected ']'; expected '[', '{', or a literal"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("]"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("]"))).parse(), "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected ']'; expected '[', '{', or a literal"); // missing/unexpected end of object - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("{"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("{\"foo\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("{\"foo\":"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("{\"foo\":}"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("{\"foo\":1,}"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("}"))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{"))).parse(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":}"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":1,}"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("}"))).parse(), json::parse_error&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{"))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - unexpected end of input; expected string literal"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{\"foo\""))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\""))).parse(), "[json.exception.parse_error.101] parse error at 7: syntax error - unexpected end of input; expected ':'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{\"foo\":"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":"))).parse(), "[json.exception.parse_error.101] parse error at 8: syntax error - unexpected end of input; expected '[', '{', or a literal"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{\"foo\":}"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":}"))).parse(), "[json.exception.parse_error.101] parse error at 8: syntax error - unexpected '}'; expected '[', '{', or a literal"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{\"foo\":1,}"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":1,}"))).parse(), "[json.exception.parse_error.101] parse error at 10: syntax error - unexpected '}'; expected string literal"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("}"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("}"))).parse(), "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected '}'; expected '[', '{', or a literal"); // missing/unexpected end of string - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u0\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u01\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u012\""))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u0"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u01"))).parse(), json::parse_error&); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u012"))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\""))).parse(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u01\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u012\""))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u01"))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u012"))).parse(), json::parse_error&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\""))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid string: missing closing quote; last read: '\"'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\\""))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\""))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid string: missing closing quote; last read: '\"\\\"'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u\""))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u\""))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u\"'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u0\""))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0\""))).parse(), "[json.exception.parse_error.101] parse error at 5: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u0\"'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u01\""))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u01\""))).parse(), "[json.exception.parse_error.101] parse error at 6: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u01\"'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u012\""))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u012\""))).parse(), "[json.exception.parse_error.101] parse error at 7: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u012\"'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u0"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0"))).parse(), "[json.exception.parse_error.101] parse error at 5: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u0'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u01"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u01"))).parse(), "[json.exception.parse_error.101] parse error at 6: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u01'"); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u012"))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u012"))).parse(), "[json.exception.parse_error.101] parse error at 7: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u012'"); // invalid escapes @@ -773,7 +773,7 @@ TEST_CASE("parser class") case ('r'): case ('t'): { - CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s.c_str()))).parse()); + CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s.c_str()))).parse()); break; } @@ -786,11 +786,11 @@ TEST_CASE("parser class") // any other combination of backslash and character is invalid default: { - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string(s.c_str()))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s.c_str()))).parse(), json::parse_error&); // only check error message if c is not a control character if (c > 0x1f) { - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string(s.c_str()))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s.c_str()))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid string: forbidden character after backslash; last read: '\"\\" + std::string(1, static_cast(c)) + "'"); } break; @@ -851,49 +851,49 @@ TEST_CASE("parser class") if (valid(c)) { CAPTURE(s1); - CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s1.c_str()))).parse()); + CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s1.c_str()))).parse()); CAPTURE(s2); - CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s2.c_str()))).parse()); + CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s2.c_str()))).parse()); CAPTURE(s3); - CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s3.c_str()))).parse()); + CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s3.c_str()))).parse()); CAPTURE(s4); - CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s4.c_str()))).parse()); + CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s4.c_str()))).parse()); } else { CAPTURE(s1); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string(s1.c_str()))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s1.c_str()))).parse(), json::parse_error&); // only check error message if c is not a control character if (c > 0x1f) { - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string(s1.c_str()))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s1.c_str()))).parse(), "[json.exception.parse_error.101] parse error at 7: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '" + s1.substr(0, 7) + "'"); } CAPTURE(s2); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string(s2.c_str()))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s2.c_str()))).parse(), json::parse_error&); // only check error message if c is not a control character if (c > 0x1f) { - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string(s2.c_str()))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s2.c_str()))).parse(), "[json.exception.parse_error.101] parse error at 6: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '" + s2.substr(0, 6) + "'"); } CAPTURE(s3); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string(s3.c_str()))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s3.c_str()))).parse(), json::parse_error&); // only check error message if c is not a control character if (c > 0x1f) { - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string(s3.c_str()))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s3.c_str()))).parse(), "[json.exception.parse_error.101] parse error at 5: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '" + s3.substr(0, 5) + "'"); } CAPTURE(s4); - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string(s4.c_str()))).parse(), json::parse_error&); + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s4.c_str()))).parse(), json::parse_error&); // only check error message if c is not a control character if (c > 0x1f) { - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string(s4.c_str()))).parse(), + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s4.c_str()))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '" + s4.substr(0, 4) + "'"); } } @@ -919,63 +919,63 @@ TEST_CASE("parser class") SECTION("parse errors (accept)") { // unexpected end of number - CHECK(json::parser(json::input_adapter::create(std::string("0."))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("--"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-0."))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-."))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("-:"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("0.:"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("e."))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("1e."))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("1e/"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("1e:"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("1E."))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("1E/"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("1E:"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0."))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("--"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0."))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-."))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-:"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0.:"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("e."))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e."))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e/"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e:"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E."))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E/"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E:"))).accept() == false); // unexpected end of null - CHECK(json::parser(json::input_adapter::create(std::string("n"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("nu"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("nul"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("n"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("nu"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("nul"))).accept() == false); // unexpected end of true - CHECK(json::parser(json::input_adapter::create(std::string("t"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("tr"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("tru"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("t"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("tr"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("tru"))).accept() == false); // unexpected end of false - CHECK(json::parser(json::input_adapter::create(std::string("f"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("fa"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("fal"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("fals"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("f"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fa"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fal"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fals"))).accept() == false); // missing/unexpected end of array - CHECK(json::parser(json::input_adapter::create(std::string("["))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("[1"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("[1,"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("[1,]"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("]"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("["))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1,"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1,]"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("]"))).accept() == false); // missing/unexpected end of object - CHECK(json::parser(json::input_adapter::create(std::string("{"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("{\"foo\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("{\"foo\":"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("{\"foo\":}"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("{\"foo\":1,}"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("}"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":}"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":1,}"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("}"))).accept() == false); // missing/unexpected end of string - CHECK(json::parser(json::input_adapter::create(std::string("\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u01\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u012\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u01"))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\u012"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u01\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u012\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u01"))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u012"))).accept() == false); // invalid escapes for (int c = 1; c < 128; ++c) @@ -994,7 +994,7 @@ TEST_CASE("parser class") case ('r'): case ('t'): { - CHECK(json::parser(json::input_adapter::create(std::string(s.c_str()))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s.c_str()))).accept()); break; } @@ -1007,7 +1007,7 @@ TEST_CASE("parser class") // any other combination of backslash and character is invalid default: { - CHECK(json::parser(json::input_adapter::create(std::string(s.c_str()))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s.c_str()))).accept() == false); break; } } @@ -1066,48 +1066,48 @@ TEST_CASE("parser class") if (valid(c)) { CAPTURE(s1); - CHECK(json::parser(json::input_adapter::create(std::string(s1.c_str()))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s1.c_str()))).accept()); CAPTURE(s2); - CHECK(json::parser(json::input_adapter::create(std::string(s2.c_str()))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s2.c_str()))).accept()); CAPTURE(s3); - CHECK(json::parser(json::input_adapter::create(std::string(s3.c_str()))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s3.c_str()))).accept()); CAPTURE(s4); - CHECK(json::parser(json::input_adapter::create(std::string(s4.c_str()))).accept()); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s4.c_str()))).accept()); } else { CAPTURE(s1); - CHECK(json::parser(json::input_adapter::create(std::string(s1.c_str()))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s1.c_str()))).accept() == false); CAPTURE(s2); - CHECK(json::parser(json::input_adapter::create(std::string(s2.c_str()))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s2.c_str()))).accept() == false); CAPTURE(s3); - CHECK(json::parser(json::input_adapter::create(std::string(s3.c_str()))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s3.c_str()))).accept() == false); CAPTURE(s4); - CHECK(json::parser(json::input_adapter::create(std::string(s4.c_str()))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s4.c_str()))).accept() == false); } } } // missing part of a surrogate pair - CHECK(json::parser(json::input_adapter::create(std::string("\"\\uD80C\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\uD80C\""))).accept() == false); // invalid surrogate pair - CHECK(json::parser(json::input_adapter::create(std::string("\"\\uD80C\\uD80C\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\uD80C\\u0000\""))).accept() == false); - CHECK(json::parser(json::input_adapter::create(std::string("\"\\uD80C\\uFFFF\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\uD80C\\uD80C\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\uD80C\\u0000\""))).accept() == false); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\uD80C\\uFFFF\""))).accept() == false); } SECTION("tests found by mutate++") { // test case to make sure no comma preceeds the first key - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("{,\"key\": false}"))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{,\"key\": false}"))).parse(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{,\"key\": false}"))).parse(), json::parse_error&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{,\"key\": false}"))).parse(), "[json.exception.parse_error.101] parse error at 2: syntax error - unexpected ','; expected string literal"); // test case to make sure an object is properly closed - CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("[{\"key\": false true]"))).parse(), json::parse_error&); - CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("[{\"key\": false true]"))).parse(), + CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[{\"key\": false true]"))).parse(), json::parse_error&); + CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[{\"key\": false true]"))).parse(), "[json.exception.parse_error.101] parse error at 19: syntax error - unexpected true literal; expected '}'"); // test case to make sure the callback is properly evaluated after reading a key @@ -1295,42 +1295,42 @@ TEST_CASE("parser class") SECTION("from std::vector") { std::vector v = {'t', 'r', 'u', 'e'}; - CHECK(json::parser(json::input_adapter::create(std::begin(v), std::end(v))).parse() == json(true)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::begin(v), std::end(v))).parse() == json(true)); } SECTION("from std::array") { std::array v { {'t', 'r', 'u', 'e'} }; - CHECK(json::parser(json::input_adapter::create(std::begin(v), std::end(v))).parse() == json(true)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::begin(v), std::end(v))).parse() == json(true)); } SECTION("from array") { uint8_t v[] = {'t', 'r', 'u', 'e'}; - CHECK(json::parser(json::input_adapter::create(std::begin(v), std::end(v))).parse() == json(true)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::begin(v), std::end(v))).parse() == json(true)); } SECTION("from char literal") { - CHECK(json::parser(json::input_adapter::create(std::string("true"))).parse() == json(true)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("true"))).parse() == json(true)); } SECTION("from std::string") { std::string v = {'t', 'r', 'u', 'e'}; - CHECK(json::parser(json::input_adapter::create(std::begin(v), std::end(v))).parse() == json(true)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::begin(v), std::end(v))).parse() == json(true)); } SECTION("from std::initializer_list") { std::initializer_list v = {'t', 'r', 'u', 'e'}; - CHECK(json::parser(json::input_adapter::create(std::begin(v), std::end(v))).parse() == json(true)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::begin(v), std::end(v))).parse() == json(true)); } SECTION("from std::valarray") { std::valarray v = {'t', 'r', 'u', 'e'}; - CHECK(json::parser(json::input_adapter::create(std::begin(v), std::end(v))).parse() == json(true)); + CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::begin(v), std::end(v))).parse() == json(true)); } } }