diff --git a/include/nlohmann/json.hpp b/include/nlohmann/json.hpp index 225100270..639885e3d 100644 --- a/include/nlohmann/json.hpp +++ b/include/nlohmann/json.hpp @@ -3496,7 +3496,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template < class KeyT, typename std::enable_if < !std::is_same::type, json_pointer>::value&& ( #if defined(JSON_HAS_CPP_17) - std::is_same::value || + std::is_same::type, std::string_view>::value || #endif std::is_convertible::value), int >::type = 0 > reference at(KeyT && key) @@ -3549,7 +3549,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template < class KeyT, typename std::enable_if < !std::is_same::type, json_pointer>::value&& ( #if defined(JSON_HAS_CPP_17) - std::is_same::value || + std::is_same::type, std::string_view>::value || #endif std::is_convertible::value), int >::type = 0 > const_reference at(KeyT && key) const @@ -3688,7 +3688,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template < class KeyT, typename std::enable_if < !std::is_same::type, json_pointer>::value&& ( #if defined(JSON_HAS_CPP_17) - std::is_same::value || + std::is_same::type, std::string_view>::value || #endif std::is_convertible::value), int >::type = 0 > reference operator[](KeyT && key) @@ -3744,7 +3744,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template < class KeyT, typename std::enable_if < !std::is_same::type, json_pointer>::value&& ( #if defined(JSON_HAS_CPP_17) - std::is_same::value || + std::is_same::type, std::string_view>::value || #endif std::is_convertible::value), int >::type = 0 > const_reference operator[](KeyT && key) const @@ -4363,7 +4363,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec */ template < class KeyT, typename std::enable_if < #if defined(JSON_HAS_CPP_17) - std::is_same::value || + !std::is_same::type, std::string_view>::value&& #endif std::is_convertible::value, int >::type = 0 > size_type erase(KeyT && key) @@ -4377,6 +4377,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this)); } +#if defined(JSON_HAS_CPP_17) + size_type erase(std::string_view key) + { + return erase(typename object_t::key_type(key.data(), key.size())); + } +#endif + /*! @brief remove element from a JSON array given an index diff --git a/single_include/nlohmann/json.hpp b/single_include/nlohmann/json.hpp index 2a2206d53..3b2e7840d 100644 --- a/single_include/nlohmann/json.hpp +++ b/single_include/nlohmann/json.hpp @@ -20385,7 +20385,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template < class KeyT, typename std::enable_if < !std::is_same::type, json_pointer>::value&& ( #if defined(JSON_HAS_CPP_17) - std::is_same::value || + std::is_same::type, std::string_view>::value || #endif std::is_convertible::value), int >::type = 0 > reference at(KeyT && key) @@ -20438,7 +20438,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template < class KeyT, typename std::enable_if < !std::is_same::type, json_pointer>::value&& ( #if defined(JSON_HAS_CPP_17) - std::is_same::value || + std::is_same::type, std::string_view>::value || #endif std::is_convertible::value), int >::type = 0 > const_reference at(KeyT && key) const @@ -20577,7 +20577,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template < class KeyT, typename std::enable_if < !std::is_same::type, json_pointer>::value&& ( #if defined(JSON_HAS_CPP_17) - std::is_same::value || + std::is_same::type, std::string_view>::value || #endif std::is_convertible::value), int >::type = 0 > reference operator[](KeyT && key) @@ -20633,7 +20633,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec template < class KeyT, typename std::enable_if < !std::is_same::type, json_pointer>::value&& ( #if defined(JSON_HAS_CPP_17) - std::is_same::value || + std::is_same::type, std::string_view>::value || #endif std::is_convertible::value), int >::type = 0 > const_reference operator[](KeyT && key) const @@ -21252,7 +21252,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec */ template < class KeyT, typename std::enable_if < #if defined(JSON_HAS_CPP_17) - std::is_same::value || + !std::is_same::type, std::string_view>::value&& #endif std::is_convertible::value, int >::type = 0 > size_type erase(KeyT && key) @@ -21266,6 +21266,13 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this)); } +#if defined(JSON_HAS_CPP_17) + size_type erase(std::string_view key) + { + return erase(typename object_t::key_type(key.data(), key.size())); + } +#endif + /*! @brief remove element from a JSON array given an index diff --git a/test/src/unit-element_access2.cpp b/test/src/unit-element_access2.cpp index 2ae9dfe6a..9eb4c8824 100644 --- a/test/src/unit-element_access2.cpp +++ b/test/src/unit-element_access2.cpp @@ -65,7 +65,7 @@ TEST_CASE("element access 2") CHECK(j_const.at("object") == json::object()); CHECK(j_const.at("array") == json({1, 2, 3})); -#if defined(JSON_HAS_CPP_17) +#ifdef JSON_HAS_CPP_17 CHECK(j.at(std::string_view("integer")) == json(1)); CHECK(j.at(std::string_view("unsigned")) == json(1u)); CHECK(j.at(std::string_view("boolean")) == json(true)); @@ -94,6 +94,15 @@ TEST_CASE("element access 2") "[json.exception.out_of_range.403] key 'foo' not found"); CHECK_THROWS_WITH(j_const.at("foo"), "[json.exception.out_of_range.403] key 'foo' not found"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j.at(std::string_view("foo")), json::out_of_range&); + CHECK_THROWS_AS(j_const.at(std::string_view("foo")), json::out_of_range&); + CHECK_THROWS_WITH(j.at(std::string_view("foo")), + "[json.exception.out_of_range.403] key 'foo' not found"); + CHECK_THROWS_WITH(j_const.at(std::string_view("foo")), + "[json.exception.out_of_range.403] key 'foo' not found"); +#endif } SECTION("access on non-object type") @@ -102,70 +111,126 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::null); const json j_nonobject_const(j_nonobject); + CHECK_THROWS_AS(j_nonobject.at("foo"), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.at("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.at("foo"), "[json.exception.type_error.304] cannot use at() with null"); CHECK_THROWS_WITH(j_nonobject_const.at("foo"), "[json.exception.type_error.304] cannot use at() with null"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.at(std::string_view(std::string_view("foo"))), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.at(std::string_view(std::string_view("foo"))), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.at(std::string_view(std::string_view("foo"))), "[json.exception.type_error.304] cannot use at() with null"); + CHECK_THROWS_WITH(j_nonobject_const.at(std::string_view(std::string_view("foo"))), "[json.exception.type_error.304] cannot use at() with null"); +#endif } SECTION("boolean") { json j_nonobject(json::value_t::boolean); const json j_nonobject_const(j_nonobject); + CHECK_THROWS_AS(j_nonobject.at("foo"), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.at("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.at("foo"), "[json.exception.type_error.304] cannot use at() with boolean"); CHECK_THROWS_WITH(j_nonobject_const.at("foo"), "[json.exception.type_error.304] cannot use at() with boolean"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.at(std::string_view("foo")), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.at(std::string_view("foo")), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.at(std::string_view("foo")), "[json.exception.type_error.304] cannot use at() with boolean"); + CHECK_THROWS_WITH(j_nonobject_const.at(std::string_view("foo")), "[json.exception.type_error.304] cannot use at() with boolean"); +#endif } SECTION("string") { json j_nonobject(json::value_t::string); const json j_nonobject_const(j_nonobject); + CHECK_THROWS_AS(j_nonobject.at("foo"), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.at("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.at("foo"), "[json.exception.type_error.304] cannot use at() with string"); CHECK_THROWS_WITH(j_nonobject_const.at("foo"), "[json.exception.type_error.304] cannot use at() with string"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.at(std::string_view("foo")), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.at(std::string_view("foo")), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.at(std::string_view("foo")), "[json.exception.type_error.304] cannot use at() with string"); + CHECK_THROWS_WITH(j_nonobject_const.at(std::string_view("foo")), "[json.exception.type_error.304] cannot use at() with string"); +#endif } SECTION("array") { json j_nonobject(json::value_t::array); const json j_nonobject_const(j_nonobject); + CHECK_THROWS_AS(j_nonobject.at("foo"), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.at("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.at("foo"), "[json.exception.type_error.304] cannot use at() with array"); CHECK_THROWS_WITH(j_nonobject_const.at("foo"), "[json.exception.type_error.304] cannot use at() with array"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.at(std::string_view("foo")), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.at(std::string_view("foo")), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.at(std::string_view("foo")), "[json.exception.type_error.304] cannot use at() with array"); + CHECK_THROWS_WITH(j_nonobject_const.at(std::string_view("foo")), "[json.exception.type_error.304] cannot use at() with array"); +#endif } SECTION("number (integer)") { json j_nonobject(json::value_t::number_integer); const json j_nonobject_const(j_nonobject); + CHECK_THROWS_AS(j_nonobject.at("foo"), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.at("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.at("foo"), "[json.exception.type_error.304] cannot use at() with number"); CHECK_THROWS_WITH(j_nonobject_const.at("foo"), "[json.exception.type_error.304] cannot use at() with number"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.at(std::string_view("foo")), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.at(std::string_view("foo")), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.at(std::string_view("foo")), "[json.exception.type_error.304] cannot use at() with number"); + CHECK_THROWS_WITH(j_nonobject_const.at(std::string_view("foo")), "[json.exception.type_error.304] cannot use at() with number"); +#endif } SECTION("number (unsigned)") { json j_nonobject(json::value_t::number_unsigned); const json j_nonobject_const(j_nonobject); + CHECK_THROWS_AS(j_nonobject.at("foo"), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.at("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.at("foo"), "[json.exception.type_error.304] cannot use at() with number"); CHECK_THROWS_WITH(j_nonobject_const.at("foo"), "[json.exception.type_error.304] cannot use at() with number"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.at(std::string_view("foo")), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.at(std::string_view("foo")), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.at(std::string_view("foo")), "[json.exception.type_error.304] cannot use at() with number"); + CHECK_THROWS_WITH(j_nonobject_const.at(std::string_view("foo")), "[json.exception.type_error.304] cannot use at() with number"); +#endif } SECTION("number (floating-point)") { json j_nonobject(json::value_t::number_float); const json j_nonobject_const(j_nonobject); + CHECK_THROWS_AS(j_nonobject.at("foo"), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.at("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.at("foo"), "[json.exception.type_error.304] cannot use at() with number"); CHECK_THROWS_WITH(j_nonobject_const.at("foo"), "[json.exception.type_error.304] cannot use at() with number"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.at(std::string_view("foo")), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.at(std::string_view("foo")), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.at(std::string_view("foo")), "[json.exception.type_error.304] cannot use at() with number"); + CHECK_THROWS_WITH(j_nonobject_const.at(std::string_view("foo")), "[json.exception.type_error.304] cannot use at() with number"); +#endif } } } @@ -200,6 +265,33 @@ TEST_CASE("element access 2") CHECK(j_const.value("floating", 12) == 42); CHECK(j_const.value("object", json({{"foo", "bar"}})) == json::object()); CHECK(j_const.value("array", json({10, 100})) == json({1, 2, 3})); + +#ifdef JSON_HAS_CPP_17 + CHECK(j.value(std::string_view("integer"), 2) == 1); + CHECK(j.value(std::string_view("integer"), 1.0) == Approx(1)); + CHECK(j.value(std::string_view("unsigned"), 2) == 1u); + CHECK(j.value(std::string_view("unsigned"), 1.0) == Approx(1u)); + CHECK(j.value(std::string_view("null"), json(1)) == json()); + CHECK(j.value(std::string_view("boolean"), false) == true); + CHECK(j.value(std::string_view("string"), "bar") == "hello world"); + CHECK(j.value(std::string_view("string"), std::string("bar")) == "hello world"); + CHECK(j.value(std::string_view("floating"), 12.34) == Approx(42.23)); + CHECK(j.value(std::string_view("floating"), 12) == 42); + CHECK(j.value(std::string_view("object"), json({{"foo", "bar"}})) == json::object()); + CHECK(j.value(std::string_view("array"), json({10, 100})) == json({1, 2, 3})); + + CHECK(j_const.value(std::string_view("integer"), 2) == 1); + CHECK(j_const.value(std::string_view("integer"), 1.0) == Approx(1)); + CHECK(j_const.value(std::string_view("unsigned"), 2) == 1u); + CHECK(j_const.value(std::string_view("unsigned"), 1.0) == Approx(1u)); + CHECK(j_const.value(std::string_view("boolean"), false) == true); + CHECK(j_const.value(std::string_view("string"), "bar") == "hello world"); + CHECK(j_const.value(std::string_view("string"), std::string("bar")) == "hello world"); + CHECK(j_const.value(std::string_view("floating"), 12.34) == Approx(42.23)); + CHECK(j_const.value(std::string_view("floating"), 12) == 42); + CHECK(j_const.value(std::string_view("object"), json({{"foo", "bar"}})) == json::object()); + CHECK(j_const.value(std::string_view("array"), json({10, 100})) == json({1, 2, 3})); +#endif } SECTION("access non-existing value") @@ -219,6 +311,24 @@ TEST_CASE("element access 2") CHECK(j_const.value("_", 12.34) == Approx(12.34)); CHECK(j_const.value("_", json({{"foo", "bar"}})) == json({{"foo", "bar"}})); CHECK(j_const.value("_", json({10, 100})) == json({10, 100})); + +#ifdef JSON_HAS_CPP_17 + CHECK(j.value(std::string_view("_"), 2) == 2); + CHECK(j.value(std::string_view("_"), 2u) == 2u); + CHECK(j.value(std::string_view("_"), false) == false); + CHECK(j.value(std::string_view("_"), "bar") == "bar"); + CHECK(j.value(std::string_view("_"), 12.34) == Approx(12.34)); + CHECK(j.value(std::string_view("_"), json({{"foo", "bar"}})) == json({{"foo", "bar"}})); + CHECK(j.value(std::string_view("_"), json({10, 100})) == json({10, 100})); + + CHECK(j_const.value(std::string_view("_"), 2) == 2); + CHECK(j_const.value(std::string_view("_"), 2u) == 2u); + CHECK(j_const.value(std::string_view("_"), false) == false); + CHECK(j_const.value(std::string_view("_"), "bar") == "bar"); + CHECK(j_const.value(std::string_view("_"), 12.34) == Approx(12.34)); + CHECK(j_const.value(std::string_view("_"), json({{"foo", "bar"}})) == json({{"foo", "bar"}})); + CHECK(j_const.value(std::string_view("_"), json({10, 100})) == json({10, 100})); +#endif } SECTION("access on non-object type") @@ -227,84 +337,154 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::null); const json j_nonobject_const(json::value_t::null); + CHECK_THROWS_AS(j_nonobject.value("foo", 1), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.value("foo", 1), json::type_error&); CHECK_THROWS_WITH(j_nonobject.value("foo", 1), "[json.exception.type_error.306] cannot use value() with null"); CHECK_THROWS_WITH(j_nonobject_const.value("foo", 1), "[json.exception.type_error.306] cannot use value() with null"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with null"); + CHECK_THROWS_WITH(j_nonobject_const.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with null"); +#endif } SECTION("boolean") { json j_nonobject(json::value_t::boolean); const json j_nonobject_const(json::value_t::boolean); + CHECK_THROWS_AS(j_nonobject.value("foo", 1), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.value("foo", 1), json::type_error&); CHECK_THROWS_WITH(j_nonobject.value("foo", 1), "[json.exception.type_error.306] cannot use value() with boolean"); CHECK_THROWS_WITH(j_nonobject_const.value("foo", 1), "[json.exception.type_error.306] cannot use value() with boolean"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with boolean"); + CHECK_THROWS_WITH(j_nonobject_const.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with boolean"); +#endif } SECTION("string") { json j_nonobject(json::value_t::string); const json j_nonobject_const(json::value_t::string); + CHECK_THROWS_AS(j_nonobject.value("foo", 1), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.value("foo", 1), json::type_error&); CHECK_THROWS_WITH(j_nonobject.value("foo", 1), "[json.exception.type_error.306] cannot use value() with string"); CHECK_THROWS_WITH(j_nonobject_const.value("foo", 1), "[json.exception.type_error.306] cannot use value() with string"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with string"); + CHECK_THROWS_WITH(j_nonobject_const.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with string"); +#endif } SECTION("array") { json j_nonobject(json::value_t::array); const json j_nonobject_const(json::value_t::array); + CHECK_THROWS_AS(j_nonobject.value("foo", 1), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.value("foo", 1), json::type_error&); CHECK_THROWS_WITH(j_nonobject.value("foo", 1), "[json.exception.type_error.306] cannot use value() with array"); CHECK_THROWS_WITH(j_nonobject_const.value("foo", 1), "[json.exception.type_error.306] cannot use value() with array"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with array"); + CHECK_THROWS_WITH(j_nonobject_const.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with array"); +#endif } SECTION("number (integer)") { json j_nonobject(json::value_t::number_integer); const json j_nonobject_const(json::value_t::number_integer); + CHECK_THROWS_AS(j_nonobject.value("foo", 1), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.value("foo", 1), json::type_error&); CHECK_THROWS_WITH(j_nonobject.value("foo", 1), "[json.exception.type_error.306] cannot use value() with number"); CHECK_THROWS_WITH(j_nonobject_const.value("foo", 1), "[json.exception.type_error.306] cannot use value() with number"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with number"); + CHECK_THROWS_WITH(j_nonobject_const.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with number"); +#endif } SECTION("number (unsigned)") { json j_nonobject(json::value_t::number_unsigned); const json j_nonobject_const(json::value_t::number_unsigned); + CHECK_THROWS_AS(j_nonobject.value("foo", 1), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.value("foo", 1), json::type_error&); CHECK_THROWS_WITH(j_nonobject.value("foo", 1), "[json.exception.type_error.306] cannot use value() with number"); CHECK_THROWS_WITH(j_nonobject_const.value("foo", 1), "[json.exception.type_error.306] cannot use value() with number"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with number"); + CHECK_THROWS_WITH(j_nonobject_const.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with number"); +#endif } SECTION("number (floating-point)") { json j_nonobject(json::value_t::number_float); const json j_nonobject_const(json::value_t::number_float); + CHECK_THROWS_AS(j_nonobject.value("foo", 1), json::type_error&); CHECK_THROWS_AS(j_nonobject_const.value("foo", 1), json::type_error&); CHECK_THROWS_WITH(j_nonobject.value("foo", 1), "[json.exception.type_error.306] cannot use value() with number"); CHECK_THROWS_WITH(j_nonobject_const.value("foo", 1), "[json.exception.type_error.306] cannot use value() with number"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_AS(j_nonobject_const.value(std::string_view("foo"), 1), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with number"); + CHECK_THROWS_WITH(j_nonobject_const.value(std::string_view("foo"), 1), + "[json.exception.type_error.306] cannot use value() with number"); +#endif } } } @@ -495,6 +675,7 @@ TEST_CASE("element access 2") json j_nonobject(json::value_t::null); json j_nonobject2(json::value_t::null); const json j_const_nonobject(j_nonobject); + CHECK_NOTHROW(j_nonobject["foo"]); CHECK_NOTHROW(j_nonobject2[json::object_t::key_type("foo")]); CHECK_THROWS_AS(j_const_nonobject["foo"], json::type_error&); @@ -508,6 +689,7 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::boolean); const json j_const_nonobject(j_nonobject); + CHECK_THROWS_AS(j_nonobject["foo"], json::type_error&); CHECK_THROWS_AS(j_nonobject[json::object_t::key_type("foo")], json::type_error&); CHECK_THROWS_AS(j_const_nonobject["foo"], json::type_error&); @@ -526,6 +708,7 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::string); const json j_const_nonobject(j_nonobject); + CHECK_THROWS_AS(j_nonobject["foo"], json::type_error&); CHECK_THROWS_AS(j_nonobject[json::object_t::key_type("foo")], json::type_error&); CHECK_THROWS_AS(j_const_nonobject["foo"], json::type_error&); @@ -544,6 +727,7 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::array); const json j_const_nonobject(j_nonobject); + CHECK_THROWS_AS(j_nonobject["foo"], json::type_error&); CHECK_THROWS_AS(j_nonobject[json::object_t::key_type("foo")], json::type_error&); CHECK_THROWS_AS(j_const_nonobject["foo"], json::type_error&); @@ -561,6 +745,7 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::number_integer); const json j_const_nonobject(j_nonobject); + CHECK_THROWS_AS(j_nonobject["foo"], json::type_error&); CHECK_THROWS_AS(j_nonobject[json::object_t::key_type("foo")], json::type_error&); CHECK_THROWS_AS(j_const_nonobject["foo"], json::type_error&); @@ -579,6 +764,7 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::number_unsigned); const json j_const_nonobject(j_nonobject); + CHECK_THROWS_AS(j_nonobject["foo"], json::type_error&); CHECK_THROWS_AS(j_nonobject[json::object_t::key_type("foo")], json::type_error&); CHECK_THROWS_AS(j_const_nonobject["foo"], json::type_error&); @@ -597,6 +783,7 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::number_float); const json j_const_nonobject(j_nonobject); + CHECK_THROWS_AS(j_nonobject["foo"], json::type_error&); CHECK_THROWS_AS(j_nonobject[json::object_t::key_type("foo")], json::type_error&); CHECK_THROWS_AS(j_const_nonobject["foo"], json::type_error&); @@ -658,6 +845,51 @@ TEST_CASE("element access 2") CHECK(j.erase("array") == 0); } +#ifdef JSON_HAS_CPP_17 + SECTION("remove element by key (string_view)") + { + CHECK(j.find(std::string_view("integer")) != j.end()); + CHECK(j.erase(std::string_view("integer")) == 1); + CHECK(j.find(std::string_view("integer")) == j.end()); + CHECK(j.erase(std::string_view("integer")) == 0); + + CHECK(j.find(std::string_view("unsigned")) != j.end()); + CHECK(j.erase(std::string_view("unsigned")) == 1); + CHECK(j.find(std::string_view("unsigned")) == j.end()); + CHECK(j.erase(std::string_view("unsigned")) == 0); + + CHECK(j.find(std::string_view("boolean")) != j.end()); + CHECK(j.erase(std::string_view("boolean")) == 1); + CHECK(j.find(std::string_view("boolean")) == j.end()); + CHECK(j.erase(std::string_view("boolean")) == 0); + + CHECK(j.find(std::string_view("null")) != j.end()); + CHECK(j.erase(std::string_view("null")) == 1); + CHECK(j.find(std::string_view("null")) == j.end()); + CHECK(j.erase(std::string_view("null")) == 0); + + CHECK(j.find(std::string_view("string")) != j.end()); + CHECK(j.erase(std::string_view("string")) == 1); + CHECK(j.find(std::string_view("string")) == j.end()); + CHECK(j.erase(std::string_view("string")) == 0); + + CHECK(j.find(std::string_view("floating")) != j.end()); + CHECK(j.erase(std::string_view("floating")) == 1); + CHECK(j.find(std::string_view("floating")) == j.end()); + CHECK(j.erase(std::string_view("floating")) == 0); + + CHECK(j.find(std::string_view("object")) != j.end()); + CHECK(j.erase(std::string_view("object")) == 1); + CHECK(j.find(std::string_view("object")) == j.end()); + CHECK(j.erase(std::string_view("object")) == 0); + + CHECK(j.find(std::string_view("array")) != j.end()); + CHECK(j.erase(std::string_view("array")) == 1); + CHECK(j.find(std::string_view("array")) == j.end()); + CHECK(j.erase(std::string_view("array")) == 0); + } +#endif + SECTION("remove element by iterator") { SECTION("erase(begin())") @@ -784,49 +1016,91 @@ TEST_CASE("element access 2") SECTION("null") { json j_nonobject(json::value_t::null); + CHECK_THROWS_AS(j_nonobject.erase("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.erase("foo"), "[json.exception.type_error.307] cannot use erase() with null"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.erase(std::string_view("foo")), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.erase(std::string_view("foo")), + "[json.exception.type_error.307] cannot use erase() with null"); +#endif } SECTION("boolean") { json j_nonobject(json::value_t::boolean); + CHECK_THROWS_AS(j_nonobject.erase("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.erase("foo"), "[json.exception.type_error.307] cannot use erase() with boolean"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.erase(std::string_view("foo")), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.erase(std::string_view("foo")), + "[json.exception.type_error.307] cannot use erase() with boolean"); +#endif } SECTION("string") { json j_nonobject(json::value_t::string); + CHECK_THROWS_AS(j_nonobject.erase("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.erase("foo"), "[json.exception.type_error.307] cannot use erase() with string"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.erase(std::string_view("foo")), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.erase(std::string_view("foo")), + "[json.exception.type_error.307] cannot use erase() with string"); +#endif } SECTION("array") { json j_nonobject(json::value_t::array); + CHECK_THROWS_AS(j_nonobject.erase("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.erase("foo"), "[json.exception.type_error.307] cannot use erase() with array"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.erase(std::string_view("foo")), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.erase(std::string_view("foo")), + "[json.exception.type_error.307] cannot use erase() with array"); +#endif } SECTION("number (integer)") { json j_nonobject(json::value_t::number_integer); + CHECK_THROWS_AS(j_nonobject.erase("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.erase("foo"), "[json.exception.type_error.307] cannot use erase() with number"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.erase(std::string_view("foo")), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.erase(std::string_view("foo")), + "[json.exception.type_error.307] cannot use erase() with number"); +#endif } SECTION("number (floating-point)") { json j_nonobject(json::value_t::number_float); + CHECK_THROWS_AS(j_nonobject.erase("foo"), json::type_error&); CHECK_THROWS_WITH(j_nonobject.erase("foo"), "[json.exception.type_error.307] cannot use erase() with number"); + +#ifdef JSON_HAS_CPP_17 + CHECK_THROWS_AS(j_nonobject.erase(std::string_view("foo")), json::type_error&); + CHECK_THROWS_WITH(j_nonobject.erase(std::string_view("foo")), + "[json.exception.type_error.307] cannot use erase() with number"); +#endif } } } @@ -844,12 +1118,28 @@ TEST_CASE("element access 2") CHECK(j_const.find(key) != j_const.end()); CHECK(*j_const.find(key) == j_const.at(key)); } +#ifdef JSON_HAS_CPP_17 + for (const std::string_view key : + {"integer", "unsigned", "floating", "null", "string", "boolean", "object", "array" + }) + { + CHECK(j.find(key) != j.end()); + CHECK(*j.find(key) == j.at(key)); + CHECK(j_const.find(key) != j_const.end()); + CHECK(*j_const.find(key) == j_const.at(key)); + } +#endif } SECTION("nonexisting element") { CHECK(j.find("foo") == j.end()); CHECK(j_const.find("foo") == j_const.end()); + +#ifdef JSON_HAS_CPP_17 + CHECK(j.find(std::string_view("foo")) == j.end()); + CHECK(j_const.find(std::string_view("foo")) == j_const.end()); +#endif } SECTION("all types") @@ -858,64 +1148,112 @@ TEST_CASE("element access 2") { json j_nonarray(json::value_t::null); const json j_nonarray_const(j_nonarray); + CHECK(j_nonarray.find("foo") == j_nonarray.end()); CHECK(j_nonarray_const.find("foo") == j_nonarray_const.end()); + +#ifdef JSON_HAS_CPP_17 + CHECK(j_nonarray.find(std::string_view("foo")) == j_nonarray.end()); + CHECK(j_nonarray_const.find(std::string_view("foo")) == j_nonarray_const.end()); +#endif } SECTION("string") { json j_nonarray(json::value_t::string); const json j_nonarray_const(j_nonarray); + CHECK(j_nonarray.find("foo") == j_nonarray.end()); CHECK(j_nonarray_const.find("foo") == j_nonarray_const.end()); + +#ifdef JSON_HAS_CPP_17 + CHECK(j_nonarray.find(std::string_view("foo")) == j_nonarray.end()); + CHECK(j_nonarray_const.find(std::string_view("foo")) == j_nonarray_const.end()); +#endif } SECTION("object") { json j_nonarray(json::value_t::object); const json j_nonarray_const(j_nonarray); + CHECK(j_nonarray.find("foo") == j_nonarray.end()); CHECK(j_nonarray_const.find("foo") == j_nonarray_const.end()); + +#ifdef JSON_HAS_CPP_17 + CHECK(j_nonarray.find(std::string_view("foo")) == j_nonarray.end()); + CHECK(j_nonarray_const.find(std::string_view("foo")) == j_nonarray_const.end()); +#endif } SECTION("array") { json j_nonarray(json::value_t::array); const json j_nonarray_const(j_nonarray); + CHECK(j_nonarray.find("foo") == j_nonarray.end()); CHECK(j_nonarray_const.find("foo") == j_nonarray_const.end()); + +#ifdef JSON_HAS_CPP_17 + CHECK(j_nonarray.find(std::string_view("foo")) == j_nonarray.end()); + CHECK(j_nonarray_const.find(std::string_view("foo")) == j_nonarray_const.end()); +#endif } SECTION("boolean") { json j_nonarray(json::value_t::boolean); const json j_nonarray_const(j_nonarray); + CHECK(j_nonarray.find("foo") == j_nonarray.end()); CHECK(j_nonarray_const.find("foo") == j_nonarray_const.end()); + +#ifdef JSON_HAS_CPP_17 + CHECK(j_nonarray.find(std::string_view("foo")) == j_nonarray.end()); + CHECK(j_nonarray_const.find(std::string_view("foo")) == j_nonarray_const.end()); +#endif } SECTION("number (integer)") { json j_nonarray(json::value_t::number_integer); const json j_nonarray_const(j_nonarray); + CHECK(j_nonarray.find("foo") == j_nonarray.end()); CHECK(j_nonarray_const.find("foo") == j_nonarray_const.end()); + +#ifdef JSON_HAS_CPP_17 + CHECK(j_nonarray.find(std::string_view("foo")) == j_nonarray.end()); + CHECK(j_nonarray_const.find(std::string_view("foo")) == j_nonarray_const.end()); +#endif } SECTION("number (unsigned)") { json j_nonarray(json::value_t::number_unsigned); const json j_nonarray_const(j_nonarray); + CHECK(j_nonarray.find("foo") == j_nonarray.end()); CHECK(j_nonarray_const.find("foo") == j_nonarray_const.end()); + +#ifdef JSON_HAS_CPP_17 + CHECK(j_nonarray.find(std::string_view("foo")) == j_nonarray.end()); + CHECK(j_nonarray_const.find(std::string_view("foo")) == j_nonarray_const.end()); +#endif } SECTION("number (floating-point)") { json j_nonarray(json::value_t::number_float); const json j_nonarray_const(j_nonarray); + CHECK(j_nonarray.find("foo") == j_nonarray.end()); CHECK(j_nonarray_const.find("foo") == j_nonarray_const.end()); + +#ifdef JSON_HAS_CPP_17 + CHECK(j_nonarray.find(std::string_view("foo")) == j_nonarray.end()); + CHECK(j_nonarray_const.find(std::string_view("foo")) == j_nonarray_const.end()); +#endif } } } @@ -931,7 +1269,7 @@ TEST_CASE("element access 2") CHECK(j.count(key) == 1); CHECK(j_const.count(key) == 1); } -#if defined(JSON_HAS_CPP_17) +#ifdef JSON_HAS_CPP_17 for (const std::string_view key : {"integer", "unsigned", "floating", "null", "string", "boolean", "object", "array" }) @@ -946,7 +1284,8 @@ TEST_CASE("element access 2") { CHECK(j.count("foo") == 0); CHECK(j_const.count("foo") == 0); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j.count(std::string_view("foo")) == 0); CHECK(j_const.count(std::string_view("foo")) == 0); #endif @@ -958,9 +1297,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::null); const json j_nonobject_const(json::value_t::null); + CHECK(j_nonobject.count("foo") == 0); CHECK(j_nonobject_const.count("foo") == 0); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j.count(std::string_view("foo")) == 0); CHECK(j_const.count(std::string_view("foo")) == 0); #endif @@ -970,9 +1311,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::string); const json j_nonobject_const(json::value_t::string); + CHECK(j_nonobject.count("foo") == 0); CHECK(j_nonobject_const.count("foo") == 0); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j.count(std::string_view("foo")) == 0); CHECK(j_const.count(std::string_view("foo")) == 0); #endif @@ -982,9 +1325,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::object); const json j_nonobject_const(json::value_t::object); + CHECK(j_nonobject.count("foo") == 0); CHECK(j_nonobject_const.count("foo") == 0); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j.count(std::string_view("foo")) == 0); CHECK(j_const.count(std::string_view("foo")) == 0); #endif @@ -994,9 +1339,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::array); const json j_nonobject_const(json::value_t::array); + CHECK(j_nonobject.count("foo") == 0); CHECK(j_nonobject_const.count("foo") == 0); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j.count(std::string_view("foo")) == 0); CHECK(j_const.count(std::string_view("foo")) == 0); #endif @@ -1006,9 +1353,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::boolean); const json j_nonobject_const(json::value_t::boolean); + CHECK(j_nonobject.count("foo") == 0); CHECK(j_nonobject_const.count("foo") == 0); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j.count(std::string_view("foo")) == 0); CHECK(j_const.count(std::string_view("foo")) == 0); #endif @@ -1018,9 +1367,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::number_integer); const json j_nonobject_const(json::value_t::number_integer); + CHECK(j_nonobject.count("foo") == 0); CHECK(j_nonobject_const.count("foo") == 0); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j.count(std::string_view("foo")) == 0); CHECK(j_const.count(std::string_view("foo")) == 0); #endif @@ -1030,9 +1381,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::number_unsigned); const json j_nonobject_const(json::value_t::number_unsigned); + CHECK(j_nonobject.count("foo") == 0); CHECK(j_nonobject_const.count("foo") == 0); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j.count(std::string_view("foo")) == 0); CHECK(j_const.count(std::string_view("foo")) == 0); #endif @@ -1042,9 +1395,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::number_float); const json j_nonobject_const(json::value_t::number_float); + CHECK(j_nonobject.count("foo") == 0); CHECK(j_nonobject_const.count("foo") == 0); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j.count(std::string_view("foo")) == 0); CHECK(j_const.count(std::string_view("foo")) == 0); #endif @@ -1064,7 +1419,7 @@ TEST_CASE("element access 2") CHECK(j_const.contains(key) == true); } -#if defined(JSON_HAS_CPP_17) +#ifdef JSON_HAS_CPP_17 for (const std::string_view key : {"integer", "unsigned", "floating", "null", "string", "boolean", "object", "array" }) @@ -1079,7 +1434,8 @@ TEST_CASE("element access 2") { CHECK(j.contains("foo") == false); CHECK(j_const.contains("foo") == false); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j.contains(std::string_view("foo")) == false); CHECK(j_const.contains(std::string_view("foo")) == false); #endif @@ -1091,9 +1447,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::null); const json j_nonobject_const(json::value_t::null); + CHECK(j_nonobject.contains("foo") == false); CHECK(j_nonobject_const.contains("foo") == false); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j_nonobject.contains(std::string_view("foo")) == false); CHECK(j_nonobject_const.contains(std::string_view("foo")) == false); #endif @@ -1103,9 +1461,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::string); const json j_nonobject_const(json::value_t::string); + CHECK(j_nonobject.contains("foo") == false); CHECK(j_nonobject_const.contains("foo") == false); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j_nonobject.contains(std::string_view("foo")) == false); CHECK(j_nonobject_const.contains(std::string_view("foo")) == false); #endif @@ -1115,9 +1475,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::object); const json j_nonobject_const(json::value_t::object); + CHECK(j_nonobject.contains("foo") == false); CHECK(j_nonobject_const.contains("foo") == false); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j_nonobject.contains(std::string_view("foo")) == false); CHECK(j_nonobject_const.contains(std::string_view("foo")) == false); #endif @@ -1127,9 +1489,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::array); const json j_nonobject_const(json::value_t::array); + CHECK(j_nonobject.contains("foo") == false); CHECK(j_nonobject_const.contains("foo") == false); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j_nonobject.contains(std::string_view("foo")) == false); CHECK(j_nonobject_const.contains(std::string_view("foo")) == false); #endif @@ -1139,9 +1503,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::boolean); const json j_nonobject_const(json::value_t::boolean); + CHECK(j_nonobject.contains("foo") == false); CHECK(j_nonobject_const.contains("foo") == false); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j_nonobject.contains(std::string_view("foo")) == false); CHECK(j_nonobject_const.contains(std::string_view("foo")) == false); #endif @@ -1151,9 +1517,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::number_integer); const json j_nonobject_const(json::value_t::number_integer); + CHECK(j_nonobject.contains("foo") == false); CHECK(j_nonobject_const.contains("foo") == false); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j_nonobject.contains(std::string_view("foo")) == false); CHECK(j_nonobject_const.contains(std::string_view("foo")) == false); #endif @@ -1163,9 +1531,11 @@ TEST_CASE("element access 2") { json j_nonobject(json::value_t::number_unsigned); const json j_nonobject_const(json::value_t::number_unsigned); + CHECK(j_nonobject.contains("foo") == false); CHECK(j_nonobject_const.contains("foo") == false); -#if defined(JSON_HAS_CPP_17) + +#ifdef JSON_HAS_CPP_17 CHECK(j_nonobject.contains(std::string_view("foo")) == false); CHECK(j_nonobject_const.contains(std::string_view("foo")) == false); #endif @@ -1177,7 +1547,7 @@ TEST_CASE("element access 2") const json j_nonobject_const(json::value_t::number_float); CHECK(j_nonobject.contains("foo") == false); CHECK(j_nonobject_const.contains("foo") == false); -#if defined(JSON_HAS_CPP_17) +#ifdef JSON_HAS_CPP_17 CHECK(j_nonobject.contains(std::string_view("foo")) == false); CHECK(j_nonobject_const.contains(std::string_view("foo")) == false); #endif