From e191dd833f3e77a048930a87cad54ba02a52c0cd Mon Sep 17 00:00:00 2001
From: Niels Lohmann <mail@nlohmann.me>
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 <valarray>
-// 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: '\"<U+0009>'");
// 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: '\"<U+000A>'");
- 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: '\"<U+000D>'");
// 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: '\"<U+0008>'");
// 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<json::string_t>() == "\x01");
- CHECK(parse_string("\"\\u000a\"").parse().get<json::string_t>() == "\n");
- CHECK(parse_string("\"\\u00b0\"").parse().get<json::string_t>() == "°");
- CHECK(parse_string("\"\\u0c00\"").parse().get<json::string_t>() == "ఀ");
- CHECK(parse_string("\"\\ud000\"").parse().get<json::string_t>() == "퀀");
- CHECK(parse_string("\"\\u000E\"").parse().get<json::string_t>() == "\x0E");
- CHECK(parse_string("\"\\u00F0\"").parse().get<json::string_t>() == "ð");
- CHECK(parse_string("\"\\u0100\"").parse().get<json::string_t>() == "Ā");
- CHECK(parse_string("\"\\u2000\"").parse().get<json::string_t>() == " ");
- CHECK(parse_string("\"\\uFFFF\"").parse().get<json::string_t>() == "");
- CHECK(parse_string("\"\\u20AC\"").parse().get<json::string_t>() == "€");
- CHECK(parse_string("\"€\"").parse().get<json::string_t>() == "€");
- CHECK(parse_string("\"🎈\"").parse().get<json::string_t>() == "🎈");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0001\""))).parse().get<json::string_t>() == "\x01");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\u000a\""))).parse().get<json::string_t>() == "\n");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\u00b0\""))).parse().get<json::string_t>() == "°");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0c00\""))).parse().get<json::string_t>() == "ఀ");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud000\""))).parse().get<json::string_t>() == "퀀");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\u000E\""))).parse().get<json::string_t>() == "\x0E");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\u00F0\""))).parse().get<json::string_t>() == "ð");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0100\""))).parse().get<json::string_t>() == "Ā");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\u2000\""))).parse().get<json::string_t>() == " ");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\uFFFF\""))).parse().get<json::string_t>() == "");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\u20AC\""))).parse().get<json::string_t>() == "€");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"€\""))).parse().get<json::string_t>() == "€");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"🎈\""))).parse().get<json::string_t>() == "🎈");
- CHECK(parse_string("\"\\ud80c\\udc60\"").parse().get<json::string_t>() == u8"\U00013060");
- CHECK(parse_string("\"\\ud83c\\udf1e\"").parse().get<json::string_t>() == "🌞");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud80c\\udc60\""))).parse().get<json::string_t>() == u8"\U00013060");
+ CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud83c\\udf1e\""))).parse().get<json::string_t>() == "🌞");
}
}
@@ -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<int64_t>() == -9007199254740991);
+ CHECK(json::parser(json::input_adapter::create(std::string("-9007199254740991"))).parse().get<int64_t>() == -9007199254740991);
// (2**53)-1
- CHECK(parse_string("9007199254740991").parse().get<int64_t>() == 9007199254740991);
+ CHECK(json::parser(json::input_adapter::create(std::string("9007199254740991"))).parse().get<int64_t>() == 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<int64_t>() == -9223372036854775807 - 1);
+ CHECK(json::parser(json::input_adapter::create(std::string("-9223372036854775808"))).parse().get<int64_t>() == -9223372036854775807 - 1);
// (2**63)-1
- CHECK(parse_string("9223372036854775807").parse().get<int64_t>() == 9223372036854775807);
+ CHECK(json::parser(json::input_adapter::create(std::string("9223372036854775807"))).parse().get<int64_t>() == 9223372036854775807);
// (2**64)-1
- CHECK(parse_string("18446744073709551615").parse().get<uint64_t>() == 18446744073709551615u);
+ CHECK(json::parser(json::input_adapter::create(std::string("18446744073709551615"))).parse().get<uint64_t>() == 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<char>(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")