Compare commits

..
Author SHA1 Message Date
Niels Lohmann 934b12a9e1 Build the tests with C++17/C++20-only sections in those standards
cmake/test.cmake only adds the _cpp17/_cpp20 variants of a unit test if the
file mentions JSON_HAS_CPP_17/JSON_HAS_CPP_20. Several files have sections
that need C++17 or C++20 (std::filesystem::path, std::string_view, char8_t,
std::u8string, operator<=>, ranges) but never mention the macros, so by
default these sections were only compiled away in the C++11 build and only
ran in the CI jobs that force a standard.

Mention the macros next to the guarded sections, as the other tests do:
unit-to_json-rvalue.cpp (C++17 and C++20), unit-json_view_builder.cpp
(C++17), unit-class_parser.cpp, unit-recursion_depth_limit.cpp,
unit-ubjson_valueless.cpp, unit-custom-number-types.cpp and
unit-allocator.cpp (C++20).

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-11-16 12:40:54 +01:00
14 changed files with 69 additions and 186 deletions

No files matched your search

@@ -100,8 +100,7 @@ points apply to every edit:
[`root()`](root.md). New values (and the element sequences of an edited array/object) go to storage owned by the [`root()`](root.md). New values (and the element sequences of an edited array/object) go to storage owned by the
document, allocated on demand. document, allocated on demand.
- **A view keeps referring to the same value.** After [`set`](set.md) replaces the value a view refers to, that view - **A view keeps referring to the same value.** After [`set`](set.md) replaces the value a view refers to, that view
sees the new value; a view of a value that a later edit replaces or drops keeps showing what it last held. Such a sees the new value; a view of a value that a later edit replaces or drops keeps showing what it last held. An edit
view can still be edited: the edit changes only that detached value, never anything reachable from `root()`. An edit
of an array or object, however, **invalidates the iterators taken over it** (its members may now live in a of an array or object, however, **invalidates the iterators taken over it** (its members may now live in a
different sequence), and a string obtained with [`get_string()`](../basic_json_view/get_string.md) stays valid even different sequence), and a string obtained with [`get_string()`](../basic_json_view/get_string.md) stays valid even
as further edits happen (earlier buffers of edited text are kept alive, not overwritten). as further edits happen (earlier buffers of edited text are kept alive, not overwritten).
@@ -164,9 +164,7 @@ general.
The same switch happens, for the same reason, when overload 1. replaces a multi-node array/object value with a The same switch happens, for the same reason, when overload 1. replaces a multi-node array/object value with a
scalar: the *parent's* element sequence is what has to switch to links, not `target` itself, because the parent scalar: the *parent's* element sequence is what has to switch to links, not `target` itself, because the parent
originally stepped over `target`'s whole subtree by its node count, which no longer applies once `target` is a originally stepped over `target`'s whole subtree by its node count, which no longer applies once `target` is a
one-node scalar. This also holds when `target` is no longer part of the document (an edit erased or replaced it, or one-node scalar.
a value that contains it): if the container that `target` was in still uses its parsed layout, it switches to links
(otherwise nothing steps over `target` any more), and only the dropped values change.
## Examples ## Examples
+2 -15
View File
@@ -384,22 +384,9 @@ class editor
// for the container is linear in the size of the document, so // for the container is linear in the size of the document, so
// links (which are marked in the slot) avoid it. // links (which are marked in the slot) avoid it.
node* const p = parent_known ? parent : find_parent(m_doc, slot); node* const p = parent_known ? parent : find_parent(m_doc, slot);
if (p != nullptr) if (p != nullptr && ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0))
{ {
if ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0) block_of(m_doc, p, 0);
{
block_of(m_doc, p, 0);
}
}
else
{
// the slot is no longer part of the document, but the
// (dropped) container it is in may still step over it
node* const q = find_layout_parent(m_doc, slot);
if (q != nullptr)
{
block_of(m_doc, q, 0);
}
} }
} }
*slot = e.scalar; *slot = e.scalar;
+1 -38
View File
@@ -194,9 +194,7 @@ inline node* block_of(document_data& d, node* n, std::size_t extra)
h->len = n->len; h->len = n->len;
h->next = static_cast<std::uint32_t>(used); h->next = static_cast<std::uint32_t>(used);
node* o = h + 1; node* o = h + 1;
// (the bound on o keeps the copy inside the block even if the elements for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n); c != e;)
// disagreed with the element count)
for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n), *const full = h + used; c != e && o != full;)
{ {
if (object) if (object)
{ {
@@ -278,41 +276,6 @@ inline node* find_parent(const document_data& d, const node* target)
} }
} }
/// The container whose contiguous layout (in the parsed index, or in a new
/// value) steps over `target`, also when an edit dropped the container or a
/// value that encloses it; nullptr if there is none, or if the container no
/// longer walks that layout (its elements moved). An edit never gives a node a
/// larger extent than it was parsed or encoded with (a scalar is one node, an
/// assigned array/object keeps the extent of the slot), so the containers whose
/// extent covers `target` are its original ancestors: the nearest one before it
/// is its original parent. The root of a new value that is the element sequence
/// of another container is walked by that container (which find_parent() finds
/// while it still uses the sequence), not by itself.
inline node* find_layout_parent(const document_data& d, const node* target)
{
const std::less<const node*> lt{};
const node* lo = d.nodes;
if (lt(target, lo) || !lt(target, d.nodes + d.node_count))
{
auto it = d.edits->regions.upper_bound(target);
if (it == d.edits->regions.begin())
{
return nullptr; // LCOV_EXCL_LINE (an array/object with elements is in the index or a new value)
}
--it;
lo = it->second != nullptr ? it->first + 1 : it->first;
}
for (const node* c = target; c != lo;)
{
--c;
if (is_container(*c) && lt(target, c + c->next))
{
return (c->flags & node_flags::moved) == 0 ? const_cast<node*>(c) : nullptr; // NOLINT(cppcoreguidelines-pro-type-const-cast): the nodes belong to the document
}
}
return nullptr;
}
} // namespace view } // namespace view
} // namespace detail } // namespace detail
NLOHMANN_JSON_NAMESPACE_END NLOHMANN_JSON_NAMESPACE_END
+3 -53
View File
@@ -5564,9 +5564,7 @@ inline node* block_of(document_data& d, node* n, std::size_t extra)
h->len = n->len; h->len = n->len;
h->next = static_cast<std::uint32_t>(used); h->next = static_cast<std::uint32_t>(used);
node* o = h + 1; node* o = h + 1;
// (the bound on o keeps the copy inside the block even if the elements for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n); c != e;)
// disagreed with the element count)
for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n), *const full = h + used; c != e && o != full;)
{ {
if (object) if (object)
{ {
@@ -5648,41 +5646,6 @@ inline node* find_parent(const document_data& d, const node* target)
} }
} }
/// The container whose contiguous layout (in the parsed index, or in a new
/// value) steps over `target`, also when an edit dropped the container or a
/// value that encloses it; nullptr if there is none, or if the container no
/// longer walks that layout (its elements moved). An edit never gives a node a
/// larger extent than it was parsed or encoded with (a scalar is one node, an
/// assigned array/object keeps the extent of the slot), so the containers whose
/// extent covers `target` are its original ancestors: the nearest one before it
/// is its original parent. The root of a new value that is the element sequence
/// of another container is walked by that container (which find_parent() finds
/// while it still uses the sequence), not by itself.
inline node* find_layout_parent(const document_data& d, const node* target)
{
const std::less<const node*> lt{};
const node* lo = d.nodes;
if (lt(target, lo) || !lt(target, d.nodes + d.node_count))
{
auto it = d.edits->regions.upper_bound(target);
if (it == d.edits->regions.begin())
{
return nullptr; // LCOV_EXCL_LINE (an array/object with elements is in the index or a new value)
}
--it;
lo = it->second != nullptr ? it->first + 1 : it->first;
}
for (const node* c = target; c != lo;)
{
--c;
if (is_container(*c) && lt(target, c + c->next))
{
return (c->flags & node_flags::moved) == 0 ? const_cast<node*>(c) : nullptr; // NOLINT(cppcoreguidelines-pro-type-const-cast): the nodes belong to the document
}
}
return nullptr;
}
} // namespace view } // namespace view
} // namespace detail } // namespace detail
NLOHMANN_JSON_NAMESPACE_END NLOHMANN_JSON_NAMESPACE_END
@@ -6559,22 +6522,9 @@ class editor
// for the container is linear in the size of the document, so // for the container is linear in the size of the document, so
// links (which are marked in the slot) avoid it. // links (which are marked in the slot) avoid it.
node* const p = parent_known ? parent : find_parent(m_doc, slot); node* const p = parent_known ? parent : find_parent(m_doc, slot);
if (p != nullptr) if (p != nullptr && ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0))
{ {
if ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0) block_of(m_doc, p, 0);
{
block_of(m_doc, p, 0);
}
}
else
{
// the slot is no longer part of the document, but the
// (dropped) container it is in may still step over it
node* const q = find_layout_parent(m_doc, slot);
if (q != nullptr)
{
block_of(m_doc, q, 0);
}
} }
} }
*slot = e.scalar; *slot = e.scalar;
+1 -2
View File
@@ -445,8 +445,7 @@ json_test_add_test_for(src/unit-stream-bulk-scan.cpp
# with other values of JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE: 1 (the smallest), # with other values of JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE: 1 (the smallest),
# 1000000 (so large that the budget cannot be reached), and the largest value of # 1000000 (so large that the budget cannot be reached), and the largest value of
# a 64-bit integer (which saturates the limit already at the first byte, and is # a 64-bit integer (which saturates the limit already at the first byte, and is
# clamped to the largest std::size_t where that has 32 bits). The file does not # clamped to the largest std::size_t where that has 32 bits)
# mention JSON_HAS_CPP_<n>, so only C++11 is built unless the standards are forced
json_test_set_test_options(test-ubjson_valueless_rate_1 json_test_set_test_options(test-ubjson_valueless_rate_1
COMPILE_DEFINITIONS JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE=1 COMPILE_DEFINITIONS JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE=1
) )
+8
View File
@@ -6,6 +6,13 @@
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me> // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
// cmake/test.cmake selects the C++ standard versions with which to build a
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
// When using macros that are only defined for particular versions of the standard
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
// version macro in a comment close by, like this:
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
#include "doctest_compatibility.h" #include "doctest_compatibility.h"
#define JSON_TESTS_PRIVATE #define JSON_TESTS_PRIVATE
@@ -15,6 +22,7 @@ using nlohmann::json;
#include <functional> #include <functional>
#include <limits> #include <limits>
#include <valarray> #include <valarray>
// JSON_HAS_CPP_20 (do not remove; see note at top of file)
#if JSON_HAS_RANGES #if JSON_HAS_RANGES
#include <ranges> #include <ranges>
#endif #endif
+10 -2
View File
@@ -6,6 +6,13 @@
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me> // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
// cmake/test.cmake selects the C++ standard versions with which to build a
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
// When using macros that are only defined for particular versions of the standard
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
// version macro in a comment close by, like this:
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
#include "doctest_compatibility.h" #include "doctest_compatibility.h"
// capture whether JSON_STRICT_NUL_HANDLING was enabled on the command line // capture whether JSON_STRICT_NUL_HANDLING was enabled on the command line
@@ -517,6 +524,7 @@ TEST_CASE("parser class")
CHECK(json::accept(u"[1]")); CHECK(json::accept(u"[1]"));
CHECK(json::parse(U"[1]") == json({1})); CHECK(json::parse(U"[1]") == json({1}));
CHECK(json::accept(U"[1]")); CHECK(json::accept(U"[1]"));
// JSON_HAS_CPP_20 (do not remove; see note at top of file)
#if defined(__cpp_char8_t) #if defined(__cpp_char8_t)
CHECK(json::parse(u8"[1]") == json({1})); CHECK(json::parse(u8"[1]") == json({1}));
CHECK(json::accept(u8"[1]")); CHECK(json::accept(u8"[1]"));
@@ -2502,7 +2510,7 @@ TEST_CASE("text of float tokens")
std::vector<std::string> result; std::vector<std::string> result;
std::copy_if(events.begin(), events.end(), std::back_inserter(result), [](const std::string & e) std::copy_if(events.begin(), events.end(), std::back_inserter(result), [](const std::string & e)
{ {
return e.compare(0, 13, "number_float(") == 0; return e.compare(0, 13, "number_float(") == 0; // NOLINT(modernize-use-starts-ends-with): C++11
}); });
return result; return result;
}; };
@@ -3103,7 +3111,7 @@ TEST_CASE("object keys are delivered decoded and validated")
std::vector<std::string> keys; std::vector<std::string> keys;
for (const auto& e : l.events) for (const auto& e : l.events)
{ {
if (e.compare(0, 4, "key(") == 0) if (e.compare(0, 4, "key(") == 0) // NOLINT(modernize-use-starts-ends-with): C++11
{ {
keys.push_back(e.substr(4, e.size() - 5)); keys.push_back(e.substr(4, e.size() - 5));
} }
+8
View File
@@ -6,6 +6,13 @@
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me> // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
// cmake/test.cmake selects the C++ standard versions with which to build a
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
// When using macros that are only defined for particular versions of the standard
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
// version macro in a comment close by, like this:
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
#include "doctest_compatibility.h" #include "doctest_compatibility.h"
#include <nlohmann/json.hpp> #include <nlohmann/json.hpp>
@@ -17,6 +24,7 @@
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
// JSON_HAS_CPP_20 (do not remove; see note at top of file)
#if JSON_HAS_THREE_WAY_COMPARISON #if JSON_HAS_THREE_WAY_COMPARISON
#include <compare> #include <compare>
#endif #endif
+9 -1
View File
@@ -6,6 +6,13 @@
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me> // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
// cmake/test.cmake selects the C++ standard versions with which to build a
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
// When using macros that are only defined for particular versions of the standard
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
// version macro in a comment close by, like this:
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
#include "doctest_compatibility.h" #include "doctest_compatibility.h"
#include <nlohmann/json.hpp> #include <nlohmann/json.hpp>
@@ -272,6 +279,7 @@ struct generator
TEST_CASE("json_view string_ref") TEST_CASE("json_view string_ref")
{ {
// std::string_view in C++17, a stand-in with the same members before // std::string_view in C++17, a stand-in with the same members before
// JSON_HAS_CPP_17 (do not remove; see note at top of file)
using nlohmann::detail::view::string_ref; using nlohmann::detail::view::string_ref;
const std::string text = "abc"; const std::string text = "abc";
const string_ref r(text); const string_ref r(text);
@@ -945,7 +953,7 @@ TEST_CASE("json_view document_data::holds() (the debug check of read())")
SECTION("current edit buffer") SECTION("current edit buffer")
{ {
d->edits.reset(new document_data::edit_state()); // NOLINT(cppcoreguidelines-owning-memory) d->edits.reset(new document_data::edit_state()); // NOLINT(cppcoreguidelines-owning-memory,modernize-make-unique)
CHECK(!d->holds(other.data(), other.size())); CHECK(!d->holds(other.data(), other.size()));
d->edits->texts.emplace_back(new char[16]); // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-owning-memory) d->edits->texts.emplace_back(new char[16]); // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-owning-memory)
d->edits->text_cap = 16; d->edits->text_cap = 16;
-70
View File
@@ -589,76 +589,6 @@ TEST_CASE("json_view edits: a container that was added is replaced by a scalar")
CHECK(d.root().materialize() == json::parse(R"({"a":[1,6,{"k":"s"}]})")); CHECK(d.root().materialize() == json::parse(R"({"a":[1,6,{"k":"s"}]})"));
} }
TEST_CASE("json_view edits: a scalar replaces an array or object that is no longer part of the document")
{
// the dropped container that the array/object is in still steps over its
// parsed extent: that container switches to links first, as a live one does
SECTION("members of an erased object")
{
json_editable_document d = json_editable_document::parse(R"({"p": {"a": [1, [2]], "b": 3, "e": []}, "q": 0})");
const json_editable_view p = d.root()["p"];
const json_editable_view a = p["a"];
d.erase(d.root(), "p");
d.set(a[1], 5);
CHECK(p.dump() == R"({"a":[1,5],"b":3,"e":[]})");
d.set(a, 5);
CHECK(p.size() == 3);
CHECK(p.dump() == R"({"a":5,"b":3,"e":[]})");
d.push_back(p["e"], 6);
CHECK(p.dump() == R"({"a":5,"b":3,"e":[6]})");
CHECK(d.root().dump() == R"({"q":0})");
}
SECTION("an array whose elements moved")
{
json_editable_document d = json_editable_document::parse(R"({"p": {"a": [1, 2], "b": 3}, "q": 0})");
const json_editable_view p = d.root()["p"];
const json_editable_view a = p["a"];
d.erase(d.root(), "p");
d.push_back(a, 4); // (the extent of a stays)
d.set(a, 5);
CHECK(p.dump() == R"({"a":5,"b":3})");
CHECK(d.root().dump() == R"({"q":0})");
}
SECTION("an element of an erased array, which grows afterwards")
{
json_editable_document d = json_editable_document::parse(R"({"p": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "q": 0})");
const json_editable_view p = d.root()["p"];
d.erase(d.root(), "p");
d.set(p[0], 5);
d.push_back(p, 1);
CHECK(p.dump() == "[5,1]");
CHECK(d.root().dump() == R"({"q":0})");
}
SECTION("values in an erased new value")
{
json_editable_document d = json_editable_document::parse("[0]");
const json_editable_view x = d.push_back(d.root(), json::parse("[[[1, 2]], 3]"));
const json_editable_view y = x[0];
d.erase(d.root(), 1);
d.set(y[0], 5);
CHECK(x.dump() == "[[5],3]");
d.set(y, 5);
CHECK(x.dump() == "[5,3]");
CHECK(d.root().dump() == "[0]");
}
SECTION("values in the elements that an array had before it was replaced")
{
json_editable_document d = json_editable_document::parse("[0]");
d.set(d.root()[0], json::parse("[[[1, 2]]]"));
const json_editable_view y = d.root()[0][0];
d.set(d.root()[0], json::array({3}));
d.set(y[0], 5);
CHECK(y.dump() == "[5]");
d.set(y, 5);
CHECK(y.dump() == "5");
CHECK(d.root().dump() == "[[3]]");
}
}
#if !defined(JSON_NOEXCEPTION) #if !defined(JSON_NOEXCEPTION)
TEST_CASE("json_view edits: the size of a text arena") TEST_CASE("json_view edits: the size of a text arena")
{ {
+8
View File
@@ -6,6 +6,13 @@
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me> // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
// cmake/test.cmake selects the C++ standard versions with which to build a
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
// When using macros that are only defined for particular versions of the standard
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
// version macro in a comment close by, like this:
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
#include "doctest_compatibility.h" #include "doctest_compatibility.h"
#include <nlohmann/json.hpp> #include <nlohmann/json.hpp>
@@ -348,6 +355,7 @@ static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<unsigned c
static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<wchar_t>::value, "wchar_t is refused"); static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<wchar_t>::value, "wchar_t is refused");
static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<char16_t>::value, "char16_t is refused"); static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<char16_t>::value, "char16_t is refused");
static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<char32_t>::value, "char32_t is refused"); static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<char32_t>::value, "char32_t is refused");
// JSON_HAS_CPP_20 (do not remove; see note at top of file)
#if defined(__cpp_char8_t) #if defined(__cpp_char8_t)
static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<char8_t>::value, "char8_t is refused"); static_assert(nlohmann::detail::recursion_depth_limit_is_char_or_bool<char8_t>::value, "char8_t is refused");
#endif #endif
+9
View File
@@ -6,6 +6,13 @@
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me> // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
// cmake/test.cmake selects the C++ standard versions with which to build a
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
// When using macros that are only defined for particular versions of the standard
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
// version macro in a comment close by, like this:
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
#include "doctest_compatibility.h" #include "doctest_compatibility.h"
#include <nlohmann/json.hpp> #include <nlohmann/json.hpp>
@@ -23,6 +30,7 @@ using nlohmann::json;
#include <valarray> #include <valarray>
#include <vector> #include <vector>
// JSON_HAS_CPP_17 (do not remove; see note at top of file)
#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) #if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1)
#if __has_include(<filesystem>) #if __has_include(<filesystem>)
#include <filesystem> #include <filesystem>
@@ -244,6 +252,7 @@ TEST_CASE("to_json from rvalue containers")
SECTION("std::filesystem::path rvalue is still a string") SECTION("std::filesystem::path rvalue is still a string")
{ {
CHECK(json(std::filesystem::path("a/b")) == json("a/b")); CHECK(json(std::filesystem::path("a/b")) == json("a/b"));
// JSON_HAS_CPP_20 (do not remove; see note at top of file)
#ifdef __cpp_lib_char8_t #ifdef __cpp_lib_char8_t
CHECK(json(std::u8string(u8"a/b")) == json("a/b")); CHECK(json(std::u8string(u8"a/b")) == json("a/b"));
#endif #endif
+8
View File
@@ -6,6 +6,13 @@
// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me> // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
// cmake/test.cmake selects the C++ standard versions with which to build a
// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
// When using macros that are only defined for particular versions of the standard
// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
// version macro in a comment close by, like this:
// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)
// The budget for the elements of the UBJSON containers of a valueless type // The budget for the elements of the UBJSON containers of a valueless type
// ('Z', 'T', 'F') of a whole input: 1048576 plus // ('Z', 'T', 'F') of a whole input: 1048576 plus
// JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE for every byte read (see // JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE for every byte read (see
@@ -92,6 +99,7 @@ static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<unsigned
static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<wchar_t>::value, "wchar_t is refused"); static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<wchar_t>::value, "wchar_t is refused");
static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<char16_t>::value, "char16_t is refused"); static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<char16_t>::value, "char16_t is refused");
static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<char32_t>::value, "char32_t is refused"); static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<char32_t>::value, "char32_t is refused");
// JSON_HAS_CPP_20 (do not remove; see note at top of file)
#if defined(__cpp_char8_t) #if defined(__cpp_char8_t)
static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<char8_t>::value, "char8_t is refused"); static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<char8_t>::value, "char8_t is refused");
#endif #endif