From e191dd833f3e77a048930a87cad54ba02a52c0cd Mon Sep 17 00:00:00 2001 From: Niels Lohmann Date: Tue, 20 Jun 2017 21:09:05 +0200 Subject: [PATCH] :hammer: fixed warning about pointer members --- src/json.hpp | 12 +- test/src/unit-class_parser.cpp | 909 ++++++++++++++++----------------- 2 files changed, 459 insertions(+), 462 deletions(-) diff --git a/src/json.hpp b/src/json.hpp index 13a31bda..596f7136 100644 --- a/src/json.hpp +++ b/src/json.hpp @@ -6807,10 +6807,6 @@ class basic_json */ class serializer { - private: - serializer(const serializer&) = delete; - serializer& operator=(const serializer&) = delete; - public: /*! @param[in] s output stream to serialize to @@ -6823,6 +6819,10 @@ class basic_json indent_char(ichar), indent_string(512, indent_char) {} + // delete because of pointer members + serializer(const serializer&) = delete; + serializer& operator=(const serializer&) = delete; + /*! @brief internal implementation of the serialization function @@ -11182,6 +11182,10 @@ class basic_json : ia(adapter), decimal_point_char(get_decimal_point()) {} + // delete because of pointer members + lexer(const lexer&) = delete; + lexer& operator=(lexer&) = delete; + private: ///////////////////// // locales diff --git a/test/src/unit-class_parser.cpp b/test/src/unit-class_parser.cpp index 3a71dfa4..a95d1642 100644 --- a/test/src/unit-class_parser.cpp +++ b/test/src/unit-class_parser.cpp @@ -34,43 +34,36 @@ using nlohmann::json; #include -// shortcut to parse a string literal -json::parser parse_string(const char* s); -json::parser parse_string(const char* s) -{ - return json::parser(json::input_adapter::create(s)); -} - TEST_CASE("parser class") { SECTION("parse") { SECTION("null") { - CHECK(parse_string("null").parse() == json(nullptr)); + CHECK(json::parser(json::input_adapter::create(std::string("null"))).parse() == json(nullptr)); } SECTION("true") { - CHECK(parse_string("true").parse() == json(true)); + CHECK(json::parser(json::input_adapter::create(std::string("true"))).parse() == json(true)); } SECTION("false") { - CHECK(parse_string("false").parse() == json(false)); + CHECK(json::parser(json::input_adapter::create(std::string("false"))).parse() == json(false)); } SECTION("array") { SECTION("empty array") { - CHECK(parse_string("[]").parse() == json(json::value_t::array)); - CHECK(parse_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(json::input_adapter::create(std::string("[ ]"))).parse() == json(json::value_t::array)); } SECTION("nonempty array") { - CHECK(parse_string("[true, false, null]").parse() == json({true, false, nullptr})); + CHECK(json::parser(json::input_adapter::create(std::string("[true, false, null]"))).parse() == json({true, false, nullptr})); } } @@ -78,113 +71,113 @@ TEST_CASE("parser class") { SECTION("empty object") { - CHECK(parse_string("{}").parse() == json(json::value_t::object)); - CHECK(parse_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(json::input_adapter::create(std::string("{ }"))).parse() == json(json::value_t::object)); } SECTION("nonempty object") { - CHECK(parse_string("{\"\": true, \"one\": 1, \"two\": null}").parse() == json({{"", true}, {"one", 1}, {"two", nullptr}})); + CHECK(json::parser(json::input_adapter::create(std::string("{\"\": true, \"one\": 1, \"two\": null}"))).parse() == json({{"", true}, {"one", 1}, {"two", nullptr}})); } } SECTION("string") { // empty string - CHECK(parse_string("\"\"").parse() == json(json::value_t::string)); + CHECK(json::parser(json::input_adapter::create(std::string("\"\""))).parse() == json(json::value_t::string)); SECTION("errors") { // error: tab in string - CHECK_THROWS_AS(parse_string("\"\t\"").parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("\"\t\"").parse(), + 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(), "[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(parse_string("\"\n\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\r\"").parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("\"\n\"").parse(), + 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(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid string: control character must be escaped; last read: '\"'"); - CHECK_THROWS_WITH(parse_string("\"\r\"").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("\"\b\"").parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("\"\b\"").parse(), + 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(), "[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(parse_string("\uFF01").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("[-4:1,]").parse(), json::parse_error); + 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); // unescaped control characters - CHECK_THROWS_AS(parse_string("\"\x00\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x01\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x02\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x03\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x04\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x05\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x06\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x07\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x08\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x09\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x0a\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x0b\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x0c\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x0d\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x0e\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x0f\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x10\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x11\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x12\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x13\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x14\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x15\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x16\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x17\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x18\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x19\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x1a\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x1b\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x1c\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x1d\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x1e\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\x1f\"").parse(), json::parse_error); + 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); } SECTION("escaped") { // quotation mark "\"" auto r1 = R"("\"")"_json; - CHECK(parse_string("\"\\\"\"").parse() == r1); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\\"\""))).parse() == r1); // reverse solidus "\\" auto r2 = R"("\\")"_json; - CHECK(parse_string("\"\\\\\"").parse() == r2); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\\\\""))).parse() == r2); // solidus - CHECK(parse_string("\"\\/\"").parse() == R"("/")"_json); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\/\""))).parse() == R"("/")"_json); // backspace - CHECK(parse_string("\"\\b\"").parse() == json("\b")); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\b\""))).parse() == json("\b")); // formfeed - CHECK(parse_string("\"\\f\"").parse() == json("\f")); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\f\""))).parse() == json("\f")); // newline - CHECK(parse_string("\"\\n\"").parse() == json("\n")); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\n\""))).parse() == json("\n")); // carriage return - CHECK(parse_string("\"\\r\"").parse() == json("\r")); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\r\""))).parse() == json("\r")); // horizontal tab - CHECK(parse_string("\"\\t\"").parse() == json("\t")); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\t\""))).parse() == json("\t")); - CHECK(parse_string("\"\\u0001\"").parse().get() == "\x01"); - CHECK(parse_string("\"\\u000a\"").parse().get() == "\n"); - CHECK(parse_string("\"\\u00b0\"").parse().get() == "°"); - CHECK(parse_string("\"\\u0c00\"").parse().get() == "ఀ"); - CHECK(parse_string("\"\\ud000\"").parse().get() == "퀀"); - CHECK(parse_string("\"\\u000E\"").parse().get() == "\x0E"); - CHECK(parse_string("\"\\u00F0\"").parse().get() == "ð"); - CHECK(parse_string("\"\\u0100\"").parse().get() == "Ā"); - CHECK(parse_string("\"\\u2000\"").parse().get() == " "); - CHECK(parse_string("\"\\uFFFF\"").parse().get() == "￿"); - CHECK(parse_string("\"\\u20AC\"").parse().get() == "€"); - CHECK(parse_string("\"€\"").parse().get() == "€"); - CHECK(parse_string("\"🎈\"").parse().get() == "🎈"); + 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(parse_string("\"\\ud80c\\udc60\"").parse().get() == u8"\U00013060"); - CHECK(parse_string("\"\\ud83c\\udf1e\"").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() == "🌞"); } } @@ -194,40 +187,40 @@ TEST_CASE("parser class") { SECTION("without exponent") { - CHECK(parse_string("-128").parse() == json(-128)); - CHECK(parse_string("-0").parse() == json(-0)); - CHECK(parse_string("0").parse() == json(0)); - CHECK(parse_string("128").parse() == json(128)); + 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)); } SECTION("with exponent") { - CHECK(parse_string("0e1").parse() == json(0e1)); - CHECK(parse_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("0E1"))).parse() == json(0e1)); - CHECK(parse_string("10000E-4").parse() == json(10000e-4)); - CHECK(parse_string("10000E-3").parse() == json(10000e-3)); - CHECK(parse_string("10000E-2").parse() == json(10000e-2)); - CHECK(parse_string("10000E-1").parse() == json(10000e-1)); - CHECK(parse_string("10000E0").parse() == json(10000e0)); - CHECK(parse_string("10000E1").parse() == json(10000e1)); - CHECK(parse_string("10000E2").parse() == json(10000e2)); - CHECK(parse_string("10000E3").parse() == json(10000e3)); - CHECK(parse_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(parse_string("10000e-4").parse() == json(10000e-4)); - CHECK(parse_string("10000e-3").parse() == json(10000e-3)); - CHECK(parse_string("10000e-2").parse() == json(10000e-2)); - CHECK(parse_string("10000e-1").parse() == json(10000e-1)); - CHECK(parse_string("10000e0").parse() == json(10000e0)); - CHECK(parse_string("10000e1").parse() == json(10000e1)); - CHECK(parse_string("10000e2").parse() == json(10000e2)); - CHECK(parse_string("10000e3").parse() == json(10000e3)); - CHECK(parse_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(parse_string("-0e1").parse() == json(-0e1)); - CHECK(parse_string("-0E1").parse() == json(-0e1)); - CHECK(parse_string("-0E123").parse() == json(-0e123)); + 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)); } SECTION("edge cases") @@ -239,9 +232,9 @@ TEST_CASE("parser class") // agree exactly on their numeric values. // -(2**53)+1 - CHECK(parse_string("-9007199254740991").parse().get() == -9007199254740991); + CHECK(json::parser(json::input_adapter::create(std::string("-9007199254740991"))).parse().get() == -9007199254740991); // (2**53)-1 - CHECK(parse_string("9007199254740991").parse().get() == 9007199254740991); + CHECK(json::parser(json::input_adapter::create(std::string("9007199254740991"))).parse().get() == 9007199254740991); } SECTION("over the edge cases") // issue #178 - Integer conversion to unsigned (incorrect handling of 64 bit integers) @@ -254,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(parse_string("-9223372036854775808").parse().get() == -9223372036854775807 - 1); + CHECK(json::parser(json::input_adapter::create(std::string("-9223372036854775808"))).parse().get() == -9223372036854775807 - 1); // (2**63)-1 - CHECK(parse_string("9223372036854775807").parse().get() == 9223372036854775807); + CHECK(json::parser(json::input_adapter::create(std::string("9223372036854775807"))).parse().get() == 9223372036854775807); // (2**64)-1 - CHECK(parse_string("18446744073709551615").parse().get() == 18446744073709551615u); + CHECK(json::parser(json::input_adapter::create(std::string("18446744073709551615"))).parse().get() == 18446744073709551615u); } } @@ -266,85 +259,85 @@ TEST_CASE("parser class") { SECTION("without exponent") { - CHECK(parse_string("-128.5").parse() == json(-128.5)); - CHECK(parse_string("0.999").parse() == json(0.999)); - CHECK(parse_string("128.5").parse() == json(128.5)); - CHECK(parse_string("-0.0").parse() == json(-0.0)); + 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)); } SECTION("with exponent") { - CHECK(parse_string("-128.5E3").parse() == json(-128.5E3)); - CHECK(parse_string("-128.5E-3").parse() == json(-128.5E-3)); - CHECK(parse_string("-0.0e1").parse() == json(-0.0e1)); - CHECK(parse_string("-0.0E1").parse() == json(-0.0e1)); + 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)); } } SECTION("overflow") { // overflows during parsing yield an exception - CHECK_THROWS_AS(parse_string("1.18973e+4932").parse() == json(), json::out_of_range); - CHECK_THROWS_WITH(parse_string("1.18973e+4932").parse() == json(), + 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(), "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'"); } SECTION("invalid numbers") { - CHECK_THROWS_AS(parse_string("01").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("--1").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("1.").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("1E").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("1E-").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("1.E1").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-1E").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-0E#").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-0E-#").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-0#").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-0.0:").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-0.0Z").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-0E123:").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-0e0-:").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-0e-:").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-0f").parse(), json::parse_error); + 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); // numbers must not begin with "+" - CHECK_THROWS_AS(parse_string("+1").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("+0").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("+0"))).parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("01").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-01").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("--1").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("1.").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("1E").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("1E-").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("1.E1").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-1E").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-0E#").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-0E-#").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-0#").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-0.0:").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-0.0Z").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-0E123:").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0E123:"))).parse(), "[json.exception.parse_error.101] parse error at 7: syntax error - unexpected ':'; expected end of input"); - CHECK_THROWS_WITH(parse_string("-0e0-:").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-0e-:").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-0f").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0f"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid literal; expected 'false'; last read: '-0f'; expected end of input"); } } @@ -354,30 +347,30 @@ TEST_CASE("parser class") { SECTION("null") { - CHECK(parse_string("null").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("null"))).accept()); } SECTION("true") { - CHECK(parse_string("true").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("true"))).accept()); } SECTION("false") { - CHECK(parse_string("false").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("false"))).accept()); } SECTION("array") { SECTION("empty array") { - CHECK(parse_string("[]").accept()); - CHECK(parse_string("[ ]").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("[]"))).accept()); + CHECK(json::parser(json::input_adapter::create(std::string("[ ]"))).accept()); } SECTION("nonempty array") { - CHECK(parse_string("[true, false, null]").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("[true, false, null]"))).accept()); } } @@ -385,105 +378,105 @@ TEST_CASE("parser class") { SECTION("empty object") { - CHECK(parse_string("{}").accept()); - CHECK(parse_string("{ }").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("{}"))).accept()); + CHECK(json::parser(json::input_adapter::create(std::string("{ }"))).accept()); } SECTION("nonempty object") { - CHECK(parse_string("{\"\": true, \"one\": 1, \"two\": null}").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("{\"\": true, \"one\": 1, \"two\": null}"))).accept()); } } SECTION("string") { // empty string - CHECK(parse_string("\"\"").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("\"\""))).accept()); SECTION("errors") { // error: tab in string - CHECK(parse_string("\"\t\"").accept() == false); + CHECK(json::parser(json::input_adapter::create(std::string("\"\t\""))).accept() == false); // error: newline in string - CHECK(parse_string("\"\n\"").accept() == false); - CHECK(parse_string("\"\r\"").accept() == false); + CHECK(json::parser(json::input_adapter::create(std::string("\"\n\""))).accept() == false); + CHECK(json::parser(json::input_adapter::create(std::string("\"\r\""))).accept() == false); // error: backspace in string - CHECK(parse_string("\"\b\"").accept() == false); + CHECK(json::parser(json::input_adapter::create(std::string("\"\b\""))).accept() == false); // improve code coverage - CHECK(parse_string("\uFF01").accept() == false); - CHECK(parse_string("[-4:1,]").accept() == false); + 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); // unescaped control characters - CHECK(parse_string("\"\x00\"").accept() == false); - CHECK(parse_string("\"\x01\"").accept() == false); - CHECK(parse_string("\"\x02\"").accept() == false); - CHECK(parse_string("\"\x03\"").accept() == false); - CHECK(parse_string("\"\x04\"").accept() == false); - CHECK(parse_string("\"\x05\"").accept() == false); - CHECK(parse_string("\"\x06\"").accept() == false); - CHECK(parse_string("\"\x07\"").accept() == false); - CHECK(parse_string("\"\x08\"").accept() == false); - CHECK(parse_string("\"\x09\"").accept() == false); - CHECK(parse_string("\"\x0a\"").accept() == false); - CHECK(parse_string("\"\x0b\"").accept() == false); - CHECK(parse_string("\"\x0c\"").accept() == false); - CHECK(parse_string("\"\x0d\"").accept() == false); - CHECK(parse_string("\"\x0e\"").accept() == false); - CHECK(parse_string("\"\x0f\"").accept() == false); - CHECK(parse_string("\"\x10\"").accept() == false); - CHECK(parse_string("\"\x11\"").accept() == false); - CHECK(parse_string("\"\x12\"").accept() == false); - CHECK(parse_string("\"\x13\"").accept() == false); - CHECK(parse_string("\"\x14\"").accept() == false); - CHECK(parse_string("\"\x15\"").accept() == false); - CHECK(parse_string("\"\x16\"").accept() == false); - CHECK(parse_string("\"\x17\"").accept() == false); - CHECK(parse_string("\"\x18\"").accept() == false); - CHECK(parse_string("\"\x19\"").accept() == false); - CHECK(parse_string("\"\x1a\"").accept() == false); - CHECK(parse_string("\"\x1b\"").accept() == false); - CHECK(parse_string("\"\x1c\"").accept() == false); - CHECK(parse_string("\"\x1d\"").accept() == false); - CHECK(parse_string("\"\x1e\"").accept() == false); - CHECK(parse_string("\"\x1f\"").accept() == false); + 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); } SECTION("escaped") { // quotation mark "\"" auto r1 = R"("\"")"_json; - CHECK(parse_string("\"\\\"\"").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\\"\""))).accept()); // reverse solidus "\\" auto r2 = R"("\\")"_json; - CHECK(parse_string("\"\\\\\"").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\\\\""))).accept()); // solidus - CHECK(parse_string("\"\\/\"").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\/\""))).accept()); // backspace - CHECK(parse_string("\"\\b\"").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\b\""))).accept()); // formfeed - CHECK(parse_string("\"\\f\"").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\f\""))).accept()); // newline - CHECK(parse_string("\"\\n\"").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\n\""))).accept()); // carriage return - CHECK(parse_string("\"\\r\"").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\r\""))).accept()); // horizontal tab - CHECK(parse_string("\"\\t\"").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\t\""))).accept()); - CHECK(parse_string("\"\\u0001\"").accept()); - CHECK(parse_string("\"\\u000a\"").accept()); - CHECK(parse_string("\"\\u00b0\"").accept()); - CHECK(parse_string("\"\\u0c00\"").accept()); - CHECK(parse_string("\"\\ud000\"").accept()); - CHECK(parse_string("\"\\u000E\"").accept()); - CHECK(parse_string("\"\\u00F0\"").accept()); - CHECK(parse_string("\"\\u0100\"").accept()); - CHECK(parse_string("\"\\u2000\"").accept()); - CHECK(parse_string("\"\\uFFFF\"").accept()); - CHECK(parse_string("\"\\u20AC\"").accept()); - CHECK(parse_string("\"€\"").accept()); - CHECK(parse_string("\"🎈\"").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(parse_string("\"\\ud80c\\udc60\"").accept()); - CHECK(parse_string("\"\\ud83c\\udf1e\"").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()); } } @@ -493,40 +486,40 @@ TEST_CASE("parser class") { SECTION("without exponent") { - CHECK(parse_string("-128").accept()); - CHECK(parse_string("-0").accept()); - CHECK(parse_string("0").accept()); - CHECK(parse_string("128").accept()); + 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()); } SECTION("with exponent") { - CHECK(parse_string("0e1").accept()); - CHECK(parse_string("0E1").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("0e1"))).accept()); + CHECK(json::parser(json::input_adapter::create(std::string("0E1"))).accept()); - CHECK(parse_string("10000E-4").accept()); - CHECK(parse_string("10000E-3").accept()); - CHECK(parse_string("10000E-2").accept()); - CHECK(parse_string("10000E-1").accept()); - CHECK(parse_string("10000E0").accept()); - CHECK(parse_string("10000E1").accept()); - CHECK(parse_string("10000E2").accept()); - CHECK(parse_string("10000E3").accept()); - CHECK(parse_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(parse_string("10000e-4").accept()); - CHECK(parse_string("10000e-3").accept()); - CHECK(parse_string("10000e-2").accept()); - CHECK(parse_string("10000e-1").accept()); - CHECK(parse_string("10000e0").accept()); - CHECK(parse_string("10000e1").accept()); - CHECK(parse_string("10000e2").accept()); - CHECK(parse_string("10000e3").accept()); - CHECK(parse_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(parse_string("-0e1").accept()); - CHECK(parse_string("-0E1").accept()); - CHECK(parse_string("-0E123").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()); } SECTION("edge cases") @@ -538,9 +531,9 @@ TEST_CASE("parser class") // agree exactly on their numeric values. // -(2**53)+1 - CHECK(parse_string("-9007199254740991").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("-9007199254740991"))).accept()); // (2**53)-1 - CHECK(parse_string("9007199254740991").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("9007199254740991"))).accept()); } SECTION("over the edge cases") // issue #178 - Integer conversion to unsigned (incorrect handling of 64 bit integers) @@ -553,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(parse_string("-9223372036854775808").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("-9223372036854775808"))).accept()); // (2**63)-1 - CHECK(parse_string("9223372036854775807").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("9223372036854775807"))).accept()); // (2**64)-1 - CHECK(parse_string("18446744073709551615").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("18446744073709551615"))).accept()); } } @@ -565,49 +558,49 @@ TEST_CASE("parser class") { SECTION("without exponent") { - CHECK(parse_string("-128.5").accept()); - CHECK(parse_string("0.999").accept()); - CHECK(parse_string("128.5").accept()); - CHECK(parse_string("-0.0").accept()); + 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()); } SECTION("with exponent") { - CHECK(parse_string("-128.5E3").accept()); - CHECK(parse_string("-128.5E-3").accept()); - CHECK(parse_string("-0.0e1").accept()); - CHECK(parse_string("-0.0E1").accept()); + 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()); } } SECTION("overflow") { // overflows during parsing yield an exception, but is accepted anyway - CHECK(parse_string("1.18973e+4932").accept()); + CHECK(json::parser(json::input_adapter::create(std::string("1.18973e+4932"))).accept()); } SECTION("invalid numbers") { - CHECK(parse_string("01").accept() == false); - CHECK(parse_string("--1").accept() == false); - CHECK(parse_string("1.").accept() == false); - CHECK(parse_string("1E").accept() == false); - CHECK(parse_string("1E-").accept() == false); - CHECK(parse_string("1.E1").accept() == false); - CHECK(parse_string("-1E").accept() == false); - CHECK(parse_string("-0E#").accept() == false); - CHECK(parse_string("-0E-#").accept() == false); - CHECK(parse_string("-0#").accept() == false); - CHECK(parse_string("-0.0:").accept() == false); - CHECK(parse_string("-0.0Z").accept() == false); - CHECK(parse_string("-0E123:").accept() == false); - CHECK(parse_string("-0e0-:").accept() == false); - CHECK(parse_string("-0e-:").accept() == false); - CHECK(parse_string("-0f").accept() == false); + 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); // numbers must not begin with "+" - CHECK(parse_string("+1").accept() == false); - CHECK(parse_string("+0").accept() == false); + CHECK(json::parser(json::input_adapter::create(std::string("+1"))).accept() == false); + CHECK(json::parser(json::input_adapter::create(std::string("+0"))).accept() == false); } } } @@ -615,152 +608,152 @@ TEST_CASE("parser class") SECTION("parse errors") { // unexpected end of number - CHECK_THROWS_AS(parse_string("0.").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("--").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-0.").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-.").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("-:").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("0.:").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("e.").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("1e.").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("1e/").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("1e:").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("1E.").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("1E/").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("1E:").parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("0.").parse(), + 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(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected digit after '.'; last read: '0.'"); - CHECK_THROWS_WITH(parse_string("-").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("--").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-0.").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-.").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("-:").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("0.:").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("e.").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("e."))).parse(), "[json.exception.parse_error.101] parse error at 1: syntax error - invalid literal; last read: 'e'"); - CHECK_THROWS_WITH(parse_string("1e.").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("1e/").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("1e:").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("1E.").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("1E/").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("1E:").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("n").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("nu").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("nul").parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("n").parse(), + 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(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid literal; expected 'null'; last read: 'n'"); - CHECK_THROWS_WITH(parse_string("nu").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("nu"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid literal; expected 'null'; last read: 'nu'"); - CHECK_THROWS_WITH(parse_string("nul").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("nul"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid literal; expected 'null'; last read: 'nul'"); // unexpected end of true - CHECK_THROWS_AS(parse_string("t").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("tr").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("tru").parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("t").parse(), + 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(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid literal; expected 'true'; last read: 't'"); - CHECK_THROWS_WITH(parse_string("tr").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("tr"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid literal; expected 'true'; last read: 'tr'"); - CHECK_THROWS_WITH(parse_string("tru").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("tru"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid literal; expected 'true'; last read: 'tru'"); // unexpected end of false - CHECK_THROWS_AS(parse_string("f").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("fa").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("fal").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("fals").parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("f").parse(), + 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(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid literal; expected 'false'; last read: 'f'"); - CHECK_THROWS_WITH(parse_string("fa").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("fa"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - invalid literal; expected 'false'; last read: 'fa'"); - CHECK_THROWS_WITH(parse_string("fal").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("fal"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - invalid literal; expected 'false'; last read: 'fal'"); - CHECK_THROWS_WITH(parse_string("fals").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("fals"))).parse(), "[json.exception.parse_error.101] parse error at 5: syntax error - invalid literal; expected 'false'; last read: 'fals'"); // missing/unexpected end of array - CHECK_THROWS_AS(parse_string("[").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("[1").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("[1,").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("[1,]").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("]").parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("[").parse(), + 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(), "[json.exception.parse_error.101] parse error at 2: syntax error - unexpected end of input"); - CHECK_THROWS_WITH(parse_string("[1").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("[1"))).parse(), "[json.exception.parse_error.101] parse error at 3: syntax error - unexpected end of input; expected ']'"); - CHECK_THROWS_WITH(parse_string("[1,").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("[1,"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - unexpected end of input"); - CHECK_THROWS_WITH(parse_string("[1,]").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("[1,]"))).parse(), "[json.exception.parse_error.101] parse error at 4: syntax error - unexpected ']'"); - CHECK_THROWS_WITH(parse_string("]").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("]"))).parse(), "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected ']'"); // missing/unexpected end of object - CHECK_THROWS_AS(parse_string("{").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("{\"foo\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("{\"foo\":").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("{\"foo\":}").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("{\"foo\":1,}").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("}").parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("{").parse(), + 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(), "[json.exception.parse_error.101] parse error at 2: syntax error - unexpected end of input; expected string literal"); - CHECK_THROWS_WITH(parse_string("{\"foo\"").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{\"foo\""))).parse(), "[json.exception.parse_error.101] parse error at 7: syntax error - unexpected end of input; expected ':'"); - CHECK_THROWS_WITH(parse_string("{\"foo\":").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{\"foo\":"))).parse(), "[json.exception.parse_error.101] parse error at 8: syntax error - unexpected end of input"); - CHECK_THROWS_WITH(parse_string("{\"foo\":}").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{\"foo\":}"))).parse(), "[json.exception.parse_error.101] parse error at 8: syntax error - unexpected '}'"); - CHECK_THROWS_WITH(parse_string("{\"foo\":1,}").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{\"foo\":1,}"))).parse(), "[json.exception.parse_error.101] parse error at 10: syntax error - unexpected '}'; expected string literal"); - CHECK_THROWS_WITH(parse_string("}").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("}"))).parse(), "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected '}'"); // missing/unexpected end of string - CHECK_THROWS_AS(parse_string("\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\\\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\\u\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\\u0\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\\u01\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\\u012\"").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\\u").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\\u0").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\\u01").parse(), json::parse_error); - CHECK_THROWS_AS(parse_string("\"\\u012").parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("\"").parse(), + 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(), "[json.exception.parse_error.101] parse error at 2: syntax error - invalid string: missing closing quote; last read: '\"'"); - CHECK_THROWS_WITH(parse_string("\"\\\"").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("\"\\u\"").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("\"\\u0\"").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("\"\\u01\"").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("\"\\u012\"").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("\"\\u").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("\"\\u0").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("\"\\u01").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string("\"\\u012").parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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 @@ -780,7 +773,7 @@ TEST_CASE("parser class") case ('r'): case ('t'): { - CHECK_NOTHROW(parse_string(s.c_str()).parse()); + CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s.c_str()))).parse()); break; } @@ -793,11 +786,11 @@ TEST_CASE("parser class") // any other combination of backslash and character is invalid default: { - CHECK_THROWS_AS(parse_string(s.c_str()).parse(), json::parse_error); + CHECK_THROWS_AS(json::parser(json::input_adapter::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(parse_string(s.c_str()).parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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; @@ -858,49 +851,49 @@ TEST_CASE("parser class") if (valid(c)) { CAPTURE(s1); - CHECK_NOTHROW(parse_string(s1.c_str()).parse()); + CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s1.c_str()))).parse()); CAPTURE(s2); - CHECK_NOTHROW(parse_string(s2.c_str()).parse()); + CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s2.c_str()))).parse()); CAPTURE(s3); - CHECK_NOTHROW(parse_string(s3.c_str()).parse()); + CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s3.c_str()))).parse()); CAPTURE(s4); - CHECK_NOTHROW(parse_string(s4.c_str()).parse()); + CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s4.c_str()))).parse()); } else { CAPTURE(s1); - CHECK_THROWS_AS(parse_string(s1.c_str()).parse(), json::parse_error); + CHECK_THROWS_AS(json::parser(json::input_adapter::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(parse_string(s1.c_str()).parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string(s2.c_str()).parse(), json::parse_error); + CHECK_THROWS_AS(json::parser(json::input_adapter::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(parse_string(s2.c_str()).parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string(s3.c_str()).parse(), json::parse_error); + CHECK_THROWS_AS(json::parser(json::input_adapter::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(parse_string(s3.c_str()).parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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(parse_string(s4.c_str()).parse(), json::parse_error); + CHECK_THROWS_AS(json::parser(json::input_adapter::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(parse_string(s4.c_str()).parse(), + CHECK_THROWS_WITH(json::parser(json::input_adapter::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) + "'"); } } @@ -926,63 +919,63 @@ TEST_CASE("parser class") SECTION("parse errors (accept)") { // unexpected end of number - CHECK(parse_string("0.").accept() == false); - CHECK(parse_string("-").accept() == false); - CHECK(parse_string("--").accept() == false); - CHECK(parse_string("-0.").accept() == false); - CHECK(parse_string("-.").accept() == false); - CHECK(parse_string("-:").accept() == false); - CHECK(parse_string("0.:").accept() == false); - CHECK(parse_string("e.").accept() == false); - CHECK(parse_string("1e.").accept() == false); - CHECK(parse_string("1e/").accept() == false); - CHECK(parse_string("1e:").accept() == false); - CHECK(parse_string("1E.").accept() == false); - CHECK(parse_string("1E/").accept() == false); - CHECK(parse_string("1E:").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("-."))).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); // unexpected end of null - CHECK(parse_string("n").accept() == false); - CHECK(parse_string("nu").accept() == false); - CHECK(parse_string("nul").accept() == false); + 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); // unexpected end of true - CHECK(parse_string("t").accept() == false); - CHECK(parse_string("tr").accept() == false); - CHECK(parse_string("tru").accept() == false); + 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); // unexpected end of false - CHECK(parse_string("f").accept() == false); - CHECK(parse_string("fa").accept() == false); - CHECK(parse_string("fal").accept() == false); - CHECK(parse_string("fals").accept() == 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); // missing/unexpected end of array - CHECK(parse_string("[").accept() == false); - CHECK(parse_string("[1").accept() == false); - CHECK(parse_string("[1,").accept() == false); - CHECK(parse_string("[1,]").accept() == false); - CHECK(parse_string("]").accept() == false); + 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); // missing/unexpected end of object - CHECK(parse_string("{").accept() == false); - CHECK(parse_string("{\"foo\"").accept() == false); - CHECK(parse_string("{\"foo\":").accept() == false); - CHECK(parse_string("{\"foo\":}").accept() == false); - CHECK(parse_string("{\"foo\":1,}").accept() == false); - CHECK(parse_string("}").accept() == false); + 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); // missing/unexpected end of string - CHECK(parse_string("\"").accept() == false); - CHECK(parse_string("\"\\\"").accept() == false); - CHECK(parse_string("\"\\u\"").accept() == false); - CHECK(parse_string("\"\\u0\"").accept() == false); - CHECK(parse_string("\"\\u01\"").accept() == false); - CHECK(parse_string("\"\\u012\"").accept() == false); - CHECK(parse_string("\"\\u").accept() == false); - CHECK(parse_string("\"\\u0").accept() == false); - CHECK(parse_string("\"\\u01").accept() == false); - CHECK(parse_string("\"\\u012").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("\"\\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); // invalid escapes for (int c = 1; c < 128; ++c) @@ -1001,7 +994,7 @@ TEST_CASE("parser class") case ('r'): case ('t'): { - CHECK(parse_string(s.c_str()).accept()); + CHECK(json::parser(json::input_adapter::create(std::string(s.c_str()))).accept()); break; } @@ -1014,7 +1007,7 @@ TEST_CASE("parser class") // any other combination of backslash and character is invalid default: { - CHECK(parse_string(s.c_str()).accept() == false); + CHECK(json::parser(json::input_adapter::create(std::string(s.c_str()))).accept() == false); break; } } @@ -1073,48 +1066,48 @@ TEST_CASE("parser class") if (valid(c)) { CAPTURE(s1); - CHECK(parse_string(s1.c_str()).accept()); + CHECK(json::parser(json::input_adapter::create(std::string(s1.c_str()))).accept()); CAPTURE(s2); - CHECK(parse_string(s2.c_str()).accept()); + CHECK(json::parser(json::input_adapter::create(std::string(s2.c_str()))).accept()); CAPTURE(s3); - CHECK(parse_string(s3.c_str()).accept()); + CHECK(json::parser(json::input_adapter::create(std::string(s3.c_str()))).accept()); CAPTURE(s4); - CHECK(parse_string(s4.c_str()).accept()); + CHECK(json::parser(json::input_adapter::create(std::string(s4.c_str()))).accept()); } else { CAPTURE(s1); - CHECK(parse_string(s1.c_str()).accept() == false); + CHECK(json::parser(json::input_adapter::create(std::string(s1.c_str()))).accept() == false); CAPTURE(s2); - CHECK(parse_string(s2.c_str()).accept() == false); + CHECK(json::parser(json::input_adapter::create(std::string(s2.c_str()))).accept() == false); CAPTURE(s3); - CHECK(parse_string(s3.c_str()).accept() == false); + CHECK(json::parser(json::input_adapter::create(std::string(s3.c_str()))).accept() == false); CAPTURE(s4); - CHECK(parse_string(s4.c_str()).accept() == false); + CHECK(json::parser(json::input_adapter::create(std::string(s4.c_str()))).accept() == false); } } } // missing part of a surrogate pair - CHECK(parse_string("\"\\uD80C\"").accept() == false); + CHECK(json::parser(json::input_adapter::create(std::string("\"\\uD80C\""))).accept() == false); // invalid surrogate pair - CHECK(parse_string("\"\\uD80C\\uD80C\"").accept() == false); - CHECK(parse_string("\"\\uD80C\\u0000\"").accept() == false); - CHECK(parse_string("\"\\uD80C\\uFFFF\"").accept() == false); + 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); } SECTION("tests found by mutate++") { // test case to make sure no comma preceeds the first key - CHECK_THROWS_AS(parse_string("{,\"key\": false}").parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("{,\"key\": false}").parse(), + 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(), "[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(parse_string("[{\"key\": false true]").parse(), json::parse_error); - CHECK_THROWS_WITH(parse_string("[{\"key\": false true]").parse(), + 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(), "[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 @@ -1319,7 +1312,7 @@ TEST_CASE("parser class") SECTION("from char literal") { - CHECK(parse_string("true").parse() == json(true)); + CHECK(json::parser(json::input_adapter::create(std::string("true"))).parse() == json(true)); } SECTION("from std::string")