Compare commits

..
Author SHA1 Message Date
Niels Lohmann 04fbced73d Cut long tokens in parse error messages at UTF-8 character boundaries
A parse error message shows a token of more than 8192 bytes by its
first and its last 4096 bytes around "...". The cuts were at fixed byte
offsets, so they could split a UTF-8 character: for valid UTF-8 input,
what() and the last token passed to SAX parse_error() were not valid
UTF-8, and storing the message in a json value and dumping it threw
type_error.316.

Move the end of the first part back and the start of the last part
forward to a character boundary, by at most three bytes each. The
lexer always reads bytes (wide strings are converted to UTF-8 first),
and the decision depends only on bytes inside the two parts, so the
message stays the same for every kind of input. Both parts only get
shorter, so the buffers that keep the token need no more room.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-11-16 08:12:02 +01:00
8 changed files with 252 additions and 191 deletions

No files matched your search

@@ -79,10 +79,7 @@ basic_json(basic_json&& other) noexcept;
(e.g., `json j = std::move(vec);` or `json j(std::vector<std::string>{...});`), the elements are moved into
the JSON value instead of copied. Afterwards, the elements of the source container are in a valid but
unspecified state (**moved-from**). Keys of associative containers are `const` and therefore still copied.
Lvalues and `const` rvalues are copied, and the source is left unchanged. Only containers that own their
elements are moved from, that is, containers whose elements are `const` when accessed through a `const`
container. Non-owning ranges such as spans or iterator ranges (e.g., `gsl::span`, `std::span`) are copied, so
converting an rvalue span leaves the referenced elements unchanged.
Lvalues and `const` rvalues are copied, and the source is left unchanged.
- **numbers**: [`number_integer_t`](number_integer_t.md), [`number_unsigned_t`](number_unsigned_t.md),
[`number_float_t`](number_float_t.md), and all convertible number types such as `int`, `size_t`, `int64_t`, `float`
or `double` can be used.
+1 -1
View File
@@ -140,7 +140,7 @@ Exceptions have ids 1xx.
This error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member `byte` indicates the error position.
The message ends with the last read token (`last read: '...'`), with control characters written as `<U+XXXX>`. A token of more than 8192 characters is shown by its first and its last 4096 characters, separated by `...`.
The message ends with the last read token (`last read: '...'`), with control characters written as `<U+XXXX>`. A token of more than 8192 bytes is shown by its first and its last 4096 bytes, separated by `...`; each part is shortened by up to three bytes so that it does not end or begin within a UTF-8 character.
!!! failure "Example message"
+1 -3
View File
@@ -7,9 +7,7 @@ These changes are part of the `develop` branch, but not of a release yet.
2.3 ms). Two consequences: the source container is left in a valid but unspecified (moved-from) state, and if an
exception is thrown during the conversion, the source may be partially moved-from, so the strong exception guarantee
no longer holds for the source of an rvalue conversion (the JSON value itself is unaffected). Lvalues and `const`
objects are still copied, and so are non-owning ranges such as spans (a range whose elements stay mutable through a
`const` range): converting an rvalue span leaves the referenced elements unchanged.
See [`basic_json`](../../api/basic_json/basic_json.md).
objects are still copied. See [`basic_json`](../../api/basic_json/basic_json.md).
- In C++20 (library support for `char8_t`, `__cpp_lib_char8_t`), a `#!cpp std::u8string` is a JSON **string**:
`json j = std::u8string(u8"abc");` stores `"abc"`, and `#!cpp j.get<std::u8string>()` reads it back. Version 3.12.0
stored a `#!cpp std::u8string` as an array of code units (`[97,98,99]`); on the 3.13.0 development branch it was
+17 -35
View File
@@ -48,47 +48,30 @@ namespace detail
* leave j with the type of the new value, but the pointer to the destroyed old one.
*/
// reference type of the elements of a const T
template<typename T>
using const_range_reference_t = decltype(*std::declval<iterator_t<const T>&>());
// a container that owns its elements propagates constness to them (deep
// constness): the elements of a const std::vector<std::string> are const. A
// non-owning range (a span, an iterator range) has shallow constness: a const
// span still gives mutable access to the elements it refers to. Moving from an
// rvalue of such a range would empty the storage it refers to, so the elements
// of an rvalue range are only moved if it has deep constness.
template<typename T>
using owns_its_elements = std::is_const<typename std::remove_reference<detected_t<const_range_reference_t, T>>::type>;
// a move iterator over the elements of an rvalue container, unless they are
// const (e.g., std::set): libstdc++ before GCC 5 defines the reference of a
// std::move_iterator as value_type&&, which cannot bind to a const element
template<typename Iterator>
using is_mutable_iterator = std::integral_constant < bool,
!std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >;
// a move iterator over the elements of an rvalue container that owns them,
// unless they are const (e.g., std::set): libstdc++ before GCC 5 defines the
// reference of a std::move_iterator as value_type&&, which cannot bind to a
// const element
template<typename Iterator>
std::move_iterator<Iterator> make_move_iterator_if_impl(const Iterator& it, std::true_type /*move*/)
std::move_iterator<Iterator> make_move_iterator_if_mutable_impl(const Iterator& it, std::true_type /*mutable*/)
{
return std::make_move_iterator(it);
}
template<typename Iterator>
Iterator make_move_iterator_if_impl(const Iterator& it, std::false_type /*move*/)
Iterator make_move_iterator_if_mutable_impl(const Iterator& it, std::false_type /*mutable*/)
{
return it;
}
template<typename Container, typename Iterator>
using moves_elements = conjunction<owns_its_elements<Container>, is_mutable_iterator<Iterator>>;
template<typename Iterator>
using is_mutable_iterator = std::integral_constant < bool,
!std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >;
template<typename Container, typename Iterator>
auto make_move_iterator_if_owned(const Iterator& it)
-> decltype(make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {}))
template<typename Iterator>
auto make_move_iterator_if_mutable(const Iterator& it)
-> decltype(make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {}))
{
return make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {});
return make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {});
}
template<value_t> struct external_constructor;
@@ -210,14 +193,14 @@ struct external_constructor<value_t::array>
j.replace_value(value_t::array, value);
}
/// an rvalue container: move its elements if it owns them
/// an rvalue container: move its elements
template<typename BasicJsonType, typename CompatibleArrayType>
static void construct_moving(BasicJsonType& j, CompatibleArrayType& arr)
{
using std::begin;
using std::end;
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_owned<CompatibleArrayType>(begin(arr)), make_move_iterator_if_owned<CompatibleArrayType>(end(arr))));
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_mutable(begin(arr)), make_move_iterator_if_mutable(end(arr))));
j.replace_value(value_t::array, value);
}
@@ -271,14 +254,14 @@ struct external_constructor<value_t::object>
j.replace_value(value_t::object, value);
}
/// an rvalue container: move its values if it owns them
/// an rvalue container: move its values
template<typename BasicJsonType, typename CompatibleObjectType>
static void construct_moving(BasicJsonType& j, CompatibleObjectType& obj)
{
using std::begin;
using std::end;
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_owned<CompatibleObjectType>(begin(obj)), make_move_iterator_if_owned<CompatibleObjectType>(end(obj))));
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_mutable(begin(obj)), make_move_iterator_if_mutable(end(obj))));
j.replace_value(value_t::object, value);
}
@@ -473,8 +456,7 @@ using is_rvalue_array_to_json = conjunction<is_movable_container_rvalue<T>,
is_compatible_string_type<BasicJsonType, T>,
is_compatible_binary_type<BasicJsonType, T>>>>;
// rvalue containers: their elements are moved instead of copied if the
// container owns them (see owns_its_elements)
// rvalue containers: their elements are moved instead of copied
template<typename BasicJsonType, typename CompatibleArrayType,
enable_if_t<is_rvalue_array_to_json<BasicJsonType, CompatibleArrayType>::value, int> = 0>
inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) // NOLINT(cppcoreguidelines-missing-std-forward)
+56 -2
View File
@@ -2279,9 +2279,14 @@ scan_number_done:
std::string result;
if (chars.size() > 2 * shown)
{
append_escaped(result, chars.begin(), chars.begin() + static_cast<std::ptrdiff_t>(shown));
// the lexer reads bytes (wide characters arrive as UTF-8), so
// move both cuts to character boundaries to keep the message
// valid UTF-8; this only shortens the two parts
const auto head_end = chars.begin() + static_cast<std::ptrdiff_t>(utf8_head_cut(chars.data(), shown));
const auto tail_begin = chars.end() - static_cast<std::ptrdiff_t>(shown);
append_escaped(result, chars.begin(), head_end);
result += "...";
append_escaped(result, chars.end() - static_cast<std::ptrdiff_t>(shown), chars.end());
append_escaped(result, tail_begin + static_cast<std::ptrdiff_t>(utf8_tail_skip(&*tail_begin)), chars.end());
}
else
{
@@ -2291,6 +2296,55 @@ scan_number_done:
}
private:
/// whether @a c is a UTF-8 continuation byte
static bool is_utf8_continuation(const char_type c) noexcept
{
return (static_cast<unsigned char>(c) & 0xC0u) == 0x80u;
}
/*!
@brief the length of the first @a n characters at @a data without a UTF-8
character that begins there but does not end there
Looks only at the last 4 of these characters: in valid UTF-8, at most 3
bytes of a character can be before the cut.
*/
static std::size_t utf8_head_cut(const char_type* data, const std::size_t n) noexcept
{
std::size_t lead = n - 1;
while (lead > n - 4 && is_utf8_continuation(data[lead]))
{
--lead;
}
const auto c = static_cast<unsigned char>(data[lead]);
std::size_t length = 1;
if (c >= 0xF0u)
{
length = 4;
}
else if (c >= 0xE0u)
{
length = 3;
}
else if (c >= 0xC0u)
{
length = 2;
}
return lead + length > n ? lead : n;
}
/// the number of UTF-8 continuation bytes (at most 3) at @a data, which
/// belong to a character that begins before it
static std::size_t utf8_tail_skip(const char_type* data) noexcept
{
std::size_t skip = 0;
while (skip < 3 && is_utf8_continuation(data[skip]))
{
++skip;
}
return skip;
}
/// append the characters [first, last) to @a result, escaping control characters
template<typename Iterator>
static void append_escaped(std::string& result, Iterator first, Iterator last)
+73 -37
View File
@@ -7810,47 +7810,30 @@ namespace detail
* leave j with the type of the new value, but the pointer to the destroyed old one.
*/
// reference type of the elements of a const T
template<typename T>
using const_range_reference_t = decltype(*std::declval<iterator_t<const T>&>());
// a container that owns its elements propagates constness to them (deep
// constness): the elements of a const std::vector<std::string> are const. A
// non-owning range (a span, an iterator range) has shallow constness: a const
// span still gives mutable access to the elements it refers to. Moving from an
// rvalue of such a range would empty the storage it refers to, so the elements
// of an rvalue range are only moved if it has deep constness.
template<typename T>
using owns_its_elements = std::is_const<typename std::remove_reference<detected_t<const_range_reference_t, T>>::type>;
// a move iterator over the elements of an rvalue container, unless they are
// const (e.g., std::set): libstdc++ before GCC 5 defines the reference of a
// std::move_iterator as value_type&&, which cannot bind to a const element
template<typename Iterator>
using is_mutable_iterator = std::integral_constant < bool,
!std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >;
// a move iterator over the elements of an rvalue container that owns them,
// unless they are const (e.g., std::set): libstdc++ before GCC 5 defines the
// reference of a std::move_iterator as value_type&&, which cannot bind to a
// const element
template<typename Iterator>
std::move_iterator<Iterator> make_move_iterator_if_impl(const Iterator& it, std::true_type /*move*/)
std::move_iterator<Iterator> make_move_iterator_if_mutable_impl(const Iterator& it, std::true_type /*mutable*/)
{
return std::make_move_iterator(it);
}
template<typename Iterator>
Iterator make_move_iterator_if_impl(const Iterator& it, std::false_type /*move*/)
Iterator make_move_iterator_if_mutable_impl(const Iterator& it, std::false_type /*mutable*/)
{
return it;
}
template<typename Container, typename Iterator>
using moves_elements = conjunction<owns_its_elements<Container>, is_mutable_iterator<Iterator>>;
template<typename Iterator>
using is_mutable_iterator = std::integral_constant < bool,
!std::is_const<typename std::remove_reference<decltype(*std::declval<Iterator&>())>::type>::value >;
template<typename Container, typename Iterator>
auto make_move_iterator_if_owned(const Iterator& it)
-> decltype(make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {}))
template<typename Iterator>
auto make_move_iterator_if_mutable(const Iterator& it)
-> decltype(make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {}))
{
return make_move_iterator_if_impl(it, moves_elements<Container, Iterator> {});
return make_move_iterator_if_mutable_impl(it, is_mutable_iterator<Iterator> {});
}
template<value_t> struct external_constructor;
@@ -7972,14 +7955,14 @@ struct external_constructor<value_t::array>
j.replace_value(value_t::array, value);
}
/// an rvalue container: move its elements if it owns them
/// an rvalue container: move its elements
template<typename BasicJsonType, typename CompatibleArrayType>
static void construct_moving(BasicJsonType& j, CompatibleArrayType& arr)
{
using std::begin;
using std::end;
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_owned<CompatibleArrayType>(begin(arr)), make_move_iterator_if_owned<CompatibleArrayType>(end(arr))));
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(make_move_iterator_if_mutable(begin(arr)), make_move_iterator_if_mutable(end(arr))));
j.replace_value(value_t::array, value);
}
@@ -8033,14 +8016,14 @@ struct external_constructor<value_t::object>
j.replace_value(value_t::object, value);
}
/// an rvalue container: move its values if it owns them
/// an rvalue container: move its values
template<typename BasicJsonType, typename CompatibleObjectType>
static void construct_moving(BasicJsonType& j, CompatibleObjectType& obj)
{
using std::begin;
using std::end;
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_owned<CompatibleObjectType>(begin(obj)), make_move_iterator_if_owned<CompatibleObjectType>(end(obj))));
const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(make_move_iterator_if_mutable(begin(obj)), make_move_iterator_if_mutable(end(obj))));
j.replace_value(value_t::object, value);
}
@@ -8235,8 +8218,7 @@ using is_rvalue_array_to_json = conjunction<is_movable_container_rvalue<T>,
is_compatible_string_type<BasicJsonType, T>,
is_compatible_binary_type<BasicJsonType, T>>>>;
// rvalue containers: their elements are moved instead of copied if the
// container owns them (see owns_its_elements)
// rvalue containers: their elements are moved instead of copied
template<typename BasicJsonType, typename CompatibleArrayType,
enable_if_t<is_rvalue_array_to_json<BasicJsonType, CompatibleArrayType>::value, int> = 0>
inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) // NOLINT(cppcoreguidelines-missing-std-forward)
@@ -15800,9 +15782,14 @@ scan_number_done:
std::string result;
if (chars.size() > 2 * shown)
{
append_escaped(result, chars.begin(), chars.begin() + static_cast<std::ptrdiff_t>(shown));
// the lexer reads bytes (wide characters arrive as UTF-8), so
// move both cuts to character boundaries to keep the message
// valid UTF-8; this only shortens the two parts
const auto head_end = chars.begin() + static_cast<std::ptrdiff_t>(utf8_head_cut(chars.data(), shown));
const auto tail_begin = chars.end() - static_cast<std::ptrdiff_t>(shown);
append_escaped(result, chars.begin(), head_end);
result += "...";
append_escaped(result, chars.end() - static_cast<std::ptrdiff_t>(shown), chars.end());
append_escaped(result, tail_begin + static_cast<std::ptrdiff_t>(utf8_tail_skip(&*tail_begin)), chars.end());
}
else
{
@@ -15812,6 +15799,55 @@ scan_number_done:
}
private:
/// whether @a c is a UTF-8 continuation byte
static bool is_utf8_continuation(const char_type c) noexcept
{
return (static_cast<unsigned char>(c) & 0xC0u) == 0x80u;
}
/*!
@brief the length of the first @a n characters at @a data without a UTF-8
character that begins there but does not end there
Looks only at the last 4 of these characters: in valid UTF-8, at most 3
bytes of a character can be before the cut.
*/
static std::size_t utf8_head_cut(const char_type* data, const std::size_t n) noexcept
{
std::size_t lead = n - 1;
while (lead > n - 4 && is_utf8_continuation(data[lead]))
{
--lead;
}
const auto c = static_cast<unsigned char>(data[lead]);
std::size_t length = 1;
if (c >= 0xF0u)
{
length = 4;
}
else if (c >= 0xE0u)
{
length = 3;
}
else if (c >= 0xC0u)
{
length = 2;
}
return lead + length > n ? lead : n;
}
/// the number of UTF-8 continuation bytes (at most 3) at @a data, which
/// belong to a character that begins before it
static std::size_t utf8_tail_skip(const char_type* data) noexcept
{
std::size_t skip = 0;
while (skip < 3 && is_utf8_continuation(data[skip]))
{
++skip;
}
return skip;
}
/// append the characters [first, last) to @a result, escaping control characters
template<typename Iterator>
static void append_escaped(std::string& result, Iterator first, Iterator last)
+103
View File
@@ -3380,5 +3380,108 @@ TEST_CASE("parse error message of a long token")
CHECK(message(text, kind) == "no error");
}
}
SECTION("a long string of multi-byte characters")
{
// the parts of a long token are cut at character boundaries, so the
// message of valid UTF-8 input is valid UTF-8, also for wide strings
const auto last_read = [](const std::string & m) -> std::string
{
const auto pos = m.find("last read: '");
return pos == std::string::npos ? std::string() : m.substr(pos + 12, m.size() - pos - 13);
};
const auto utf8 = [](const char32_t c) -> std::string
{
std::string result;
if (c < 0x800)
{
result.push_back(static_cast<char>(0xC0 | (c >> 6)));
}
else if (c < 0x10000)
{
result.push_back(static_cast<char>(0xE0 | (c >> 12)));
result.push_back(static_cast<char>(0x80 | ((c >> 6) & 0x3F)));
}
else
{
result.push_back(static_cast<char>(0xF0 | (c >> 18)));
result.push_back(static_cast<char>(0x80 | ((c >> 12) & 0x3F)));
result.push_back(static_cast<char>(0x80 | ((c >> 6) & 0x3F)));
}
result.push_back(static_cast<char>(0x80 | (c & 0x3F)));
return result;
};
// characters of 2, 3, and 4 bytes
const std::vector<char32_t> characters = {0xE9, 0x20AC, 0x1F600};
for (const char32_t c : characters)
{
for (std::size_t offset = 0; offset < 4; ++offset)
{
CAPTURE(static_cast<std::uint32_t>(c))
CAPTURE(offset)
// an unterminated string: the token is the whole input
std::string text = "\"" + std::string(offset, 'a');
std::u32string text32 = U"\"" + std::u32string(offset, U'a');
while (text.size() < 9000)
{
text += utf8(c);
text32.push_back(c);
}
std::u16string text16;
for (const char32_t c32 : text32)
{
if (c32 < 0x10000)
{
text16.push_back(static_cast<char16_t>(c32));
}
else
{
text16.push_back(static_cast<char16_t>(0xD800 + ((c32 - 0x10000) >> 10)));
text16.push_back(static_cast<char16_t>(0xDC00 + ((c32 - 0x10000) & 0x3FF)));
}
}
const std::string shown = last_read(message(text, 0));
const auto dots = shown.find("...");
REQUIRE(dots != std::string::npos);
// the first and the last at most 4096 bytes, without parts of characters
CHECK(dots <= 4096);
CHECK(dots > 4092);
CHECK(text.compare(0, dots, shown, 0, dots) == 0);
const std::size_t tail = shown.size() - dots - 3;
CHECK(tail <= 4096);
CHECK(tail > 4092);
CHECK(text.compare(text.size() - tail, tail, shown, dots + 3, tail) == 0);
CHECK_NOTHROW(json(shown).dump());
for (int kind = 1; kind < 4; ++kind)
{
CAPTURE(kind)
CHECK(last_read(message(text, kind)) == shown);
}
json _;
std::string m32;
std::string m16;
try
{
_ = json::parse(text32);
}
catch (const json::parse_error& e)
{
m32 = e.what();
}
try
{
_ = json::parse(text16);
}
catch (const json::parse_error& e)
{
m16 = e.what();
}
CHECK(last_read(m32) == shown);
CHECK(last_read(m16) == shown);
}
}
}
}
#endif
-109
View File
@@ -67,67 +67,6 @@ void to_json(json& j, tracked&& t)
t.moved_from = true;
}
// non-owning range over contiguous storage (like gsl::span or a pre-C++20 span
// backport): its constness is shallow, so a const span gives mutable elements
template<typename T>
struct span_like
{
using value_type = T;
using iterator = T*;
using const_iterator = T*;
T* first;
T* last;
T* begin() const
{
return first;
}
T* end() const
{
return last;
}
};
// non-owning view of key/value pairs with key_type and mapped_type, so it is
// converted like an object
template<typename K, typename V>
struct map_span_like
{
using key_type = K;
using mapped_type = V;
using value_type = std::pair<const K, V>;
using iterator = value_type*;
using const_iterator = value_type*;
value_type* first;
value_type* last;
value_type* begin() const
{
return first;
}
value_type* end() const
{
return last;
}
};
// owning container that can only be iterated when it is not const
struct mutable_only_range
{
std::vector<std::string> values;
std::vector<std::string>::iterator begin()
{
return values.begin();
}
std::vector<std::string>::iterator end()
{
return values.end();
}
};
// user type with its own rvalue-aware serializer
struct udt_container
{
@@ -205,34 +144,6 @@ TEST_CASE("to_json from rvalue containers")
CHECK(tracked_moves == 2);
}
SECTION("tracked elements: standard containers move")
{
tracked_copies = 0;
tracked_moves = 0;
std::list<tracked> l;
l.emplace_back("l");
CHECK(json(std::move(l)) == json::array({"l"}));
std::deque<tracked> d;
d.emplace_back("d");
CHECK(json(std::move(d)) == json::array({"d"}));
std::forward_list<tracked> fl;
fl.emplace_front("f");
CHECK(json(std::move(fl)) == json::array({"f"}));
std::array<tracked, 1> a{{tracked("a")}};
CHECK(json(std::move(a)) == json::array({"a"}));
std::unordered_map<std::string, tracked> um;
um.emplace("k", tracked("u"));
CHECK(json(std::move(um)) == json({{"k", "u"}}));
CHECK(tracked_moves == 5);
CHECK(tracked_copies == 0);
}
SECTION("const rvalue is copied")
{
tracked_copies = 0;
@@ -310,26 +221,6 @@ TEST_CASE("to_json from rvalue containers")
CHECK(json(std::move(obj)) == json({{"a", 1}}));
}
SECTION("non-owning ranges are copied")
{
std::vector<std::string> v{long_a, long_b};
const json j = span_like<std::string> {v.data(), v.data() + v.size()};
CHECK(j == json::array({long_a, long_b}));
CHECK(v[0] == long_a);
CHECK(v[1] == long_b);
std::vector<std::pair<const std::string, std::string>> m{{"a", long_a}};
const json jm = map_span_like<std::string, std::string> {m.data(), m.data() + m.size()};
CHECK(jm == json({{"a", long_a}}));
CHECK(m[0].second == long_a);
// without a const begin(), it cannot be told whether the range owns
// its elements, so they are copied
mutable_only_range r{{long_a}};
CHECK(json(std::move(r)) == json::array({long_a}));
CHECK(r.values[0] == long_a); // NOLINT(bugprone-use-after-move,hicpp-invalid-access-moved)
}
SECTION("user type with its own to_json overloads")
{
udt_container c{{1, 2}};