Compare commits

..
Author SHA1 Message Date
Niels Lohmann d490ad8541 Fix a scalar set() through a view of a value that an edit dropped
set(target, scalar) on an array/object that spans more than one node first
switches the container that target is in to links, since that container
steps over target's parsed subtree by its node count. The container was
looked up from root(); for a target that is no longer part of the document
(an edit erased or replaced it, or a value that contains it) the lookup
found nothing and the scalar was written anyway. The dropped container then
read past its nodes when walked, and a later edit of it made block_of()
write more links than the block it allocated holds.

When the lookup from root() fails, look for the container whose contiguous
layout still steps over the slot: the nearest container before it in its
allocation whose extent covers it (edits never enlarge an extent, so this
is the original parent). If that container still uses its layout, it
switches to links as a live parent does. Every other edit through a view of
a dropped value already worked and changed only the detached value; the
scalar set now does the same, as documented.

Also stop block_of() when its block is full, so that it never writes past
the capacity it allocated.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-11-16 07:41:42 +01:00
9 changed files with 267 additions and 275 deletions

No files matched your search

@@ -100,7 +100,8 @@ 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
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
sees the new value; a view of a value that a later edit replaces or drops keeps showing what it last held. An edit
sees the new value; a view of a value that a later edit replaces or drops keeps showing what it last held. Such a
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
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).
@@ -164,7 +164,9 @@ general.
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
originally stepped over `target`'s whole subtree by its node count, which no longer applies once `target` is a
one-node scalar.
one-node scalar. This also holds when `target` is no longer part of the document (an edit erased or replaced it, or
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
+43 -72
View File
@@ -1927,21 +1927,6 @@ class binary_reader
return result;
}
/*!
@brief move past a value of @a size bytes, starting with @a head, that a
bulk run reads, as get() and get_number() would
Called before the value is passed on, so that an error reported while
passing it on (see @ref emit_float) has the position and the last byte
that reading the value byte by byte gives.
*/
void bulk_advance(const std::size_t size, const unsigned char head)
{
ia.bulk_skip(size);
chars_read += size;
current = head;
}
/*!
@brief read the integers, floats, booleans, and nulls that follow in a
definite-length array, without the per-element bookkeeping of
@@ -1967,70 +1952,71 @@ class binary_reader
{
const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
const unsigned char head = data[0];
std::size_t size = 0;
bool accepted = false;
switch (head)
{
case 0x18:
bulk_advance(2, head);
size = 2;
accepted = emit_unsigned(data[1]);
break;
case 0x19:
bulk_advance(3, head);
size = 3;
accepted = emit_unsigned(load_big_endian<std::uint16_t>(data + 1));
break;
case 0x1A:
bulk_advance(5, head);
size = 5;
accepted = emit_unsigned(load_big_endian<std::uint32_t>(data + 1));
break;
case 0x1B:
bulk_advance(9, head);
size = 9;
accepted = emit_unsigned(load_big_endian<std::uint64_t>(data + 1));
break;
case 0x38:
bulk_advance(2, head);
size = 2;
accepted = emit_cbor_negative_integer(data[1]);
break;
case 0x39:
bulk_advance(3, head);
size = 3;
accepted = emit_cbor_negative_integer(load_big_endian<std::uint16_t>(data + 1));
break;
case 0x3A:
bulk_advance(5, head);
size = 5;
accepted = emit_cbor_negative_integer(load_big_endian<std::uint32_t>(data + 1));
break;
case 0x3B:
bulk_advance(9, head);
size = 9;
accepted = emit_cbor_negative_integer(load_big_endian<std::uint64_t>(data + 1));
break;
case 0xF4:
bulk_advance(1, head);
size = 1;
accepted = sax->boolean(false);
break;
case 0xF5:
bulk_advance(1, head);
size = 1;
accepted = sax->boolean(true);
break;
case 0xF6:
bulk_advance(1, head);
size = 1;
accepted = sax->null();
break;
case 0xFA:
bulk_advance(5, head);
size = 5;
accepted = emit_float(load_big_endian<float>(data + 1));
break;
case 0xFB:
bulk_advance(9, head);
size = 9;
accepted = emit_float(load_big_endian<double>(data + 1));
break;
default:
if (head <= 0x17)
{
bulk_advance(1, head);
size = 1;
accepted = sax->number_unsigned(static_cast<number_unsigned_t>(head));
}
else if (head >= 0x20 && head <= 0x37)
{
bulk_advance(1, head);
size = 1;
accepted = sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - head));
}
else
@@ -2040,6 +2026,10 @@ class binary_reader
}
break;
}
// as if read by get() and get_number(): current is the head byte
ia.bulk_skip(size);
chars_read += size;
current = head;
--remaining;
if (JSON_HEDLEY_UNLIKELY(!accepted))
{
@@ -2877,72 +2867,73 @@ class binary_reader
{
const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
const unsigned char head = data[0];
std::size_t size = 0;
bool accepted = false;
switch (head)
{
case 0xC0: // nil
bulk_advance(1, head);
size = 1;
accepted = sax->null();
break;
case 0xC2: // false
bulk_advance(1, head);
size = 1;
accepted = sax->boolean(false);
break;
case 0xC3: // true
bulk_advance(1, head);
size = 1;
accepted = sax->boolean(true);
break;
case 0xCA: // float 32
bulk_advance(5, head);
size = 5;
accepted = emit_float(load_big_endian<float>(data + 1));
break;
case 0xCB: // float 64
bulk_advance(9, head);
size = 9;
accepted = emit_float(load_big_endian<double>(data + 1));
break;
case 0xCC: // uint 8
bulk_advance(2, head);
size = 2;
accepted = emit_unsigned(data[1]);
break;
case 0xCD: // uint 16
bulk_advance(3, head);
size = 3;
accepted = emit_unsigned(load_big_endian<std::uint16_t>(data + 1));
break;
case 0xCE: // uint 32
bulk_advance(5, head);
size = 5;
accepted = emit_unsigned(load_big_endian<std::uint32_t>(data + 1));
break;
case 0xCF: // uint 64
bulk_advance(9, head);
size = 9;
accepted = emit_unsigned(load_big_endian<std::uint64_t>(data + 1));
break;
case 0xD0: // int 8
bulk_advance(2, head);
size = 2;
accepted = emit_signed(static_cast<std::int8_t>(data[1]));
break;
case 0xD1: // int 16
bulk_advance(3, head);
size = 3;
accepted = emit_signed(load_big_endian<std::int16_t>(data + 1));
break;
case 0xD2: // int 32
bulk_advance(5, head);
size = 5;
accepted = emit_signed(load_big_endian<std::int32_t>(data + 1));
break;
case 0xD3: // int 64
bulk_advance(9, head);
size = 9;
accepted = emit_signed(load_big_endian<std::int64_t>(data + 1));
break;
default:
if (head <= 0x7F)
{
// positive fixint
bulk_advance(1, head);
size = 1;
accepted = sax->number_unsigned(static_cast<number_unsigned_t>(head));
}
else if (head >= 0xE0)
{
// negative fixint
bulk_advance(1, head);
size = 1;
accepted = sax->number_integer(static_cast<std::int8_t>(head));
}
else
@@ -2952,6 +2943,10 @@ class binary_reader
}
break;
}
// as if read by get() and get_number(): current is the last byte
ia.bulk_skip(size);
chars_read += size;
current = data[size - 1];
--remaining;
if (JSON_HEDLEY_UNLIKELY(!accepted))
{
@@ -3855,7 +3850,6 @@ class binary_reader
const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
// UBJSON stores numbers big-endian, BJData little-endian
const bool swap = is_little_endian != (input_format == input_format_t::bjdata);
const std::size_t start = chars_read;
std::size_t read = 0;
bool accepted = true;
while (read < count && accepted)
@@ -3867,39 +3861,16 @@ class binary_reader
byte_swap(number);
}
++read;
// where passing the value on can report an error (see
// emit_float), the position is that after the value, as if it
// was read by get_number()
set_chars_read(start + (read * size), std::integral_constant<bool, may_overflow_number_float<NumberType>()> {});
accepted = emit_ubjson_number(number);
}
// get_number() does not change current
// as if read by get_number(): current is the last byte read
ia.bulk_skip(read * size);
chars_read = start + (read * size);
chars_read += read * size;
current = data[(read * size) - 1];
remaining -= read;
return accepted;
}
/*!
@brief whether a value of type @a NumberType can be finite and still
overflow number_float_t, which @ref emit_float reports as an error
False for the default number types, so that the loop in @ref
parse_ubjson_typed_run need not track the position per value.
*/
template<typename NumberType>
static constexpr bool may_overflow_number_float() noexcept
{
return static_cast<long double>((std::numeric_limits<number_float_t>::max)()) < static_cast<long double>((std::numeric_limits<NumberType>::max)());
}
void set_chars_read(const std::size_t position, std::true_type /*track*/) noexcept
{
chars_read = position;
}
void set_chars_read(const std::size_t /*position*/, std::false_type /*track*/) const noexcept {}
template<typename NumberType, enable_if_t<std::is_floating_point<NumberType>::value, int> = 0>
bool emit_ubjson_number(const NumberType number)
{
+15 -2
View File
@@ -384,9 +384,22 @@ class editor
// for the container is linear in the size of the document, so
// links (which are marked in the slot) avoid it.
node* const p = parent_known ? parent : find_parent(m_doc, slot);
if (p != nullptr && ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0))
if (p != nullptr)
{
block_of(m_doc, p, 0);
if ((p->flags & node_flags::moved) == 0 || moved_capacity(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;
+38 -1
View File
@@ -194,7 +194,9 @@ inline node* block_of(document_data& d, node* n, std::size_t extra)
h->len = n->len;
h->next = static_cast<std::uint32_t>(used);
node* o = h + 1;
for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n); c != e;)
// (the bound on o keeps the copy inside the block even if the elements
// 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)
{
@@ -276,6 +278,41 @@ 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 detail
NLOHMANN_JSON_NAMESPACE_END
+43 -72
View File
@@ -20605,21 +20605,6 @@ class binary_reader
return result;
}
/*!
@brief move past a value of @a size bytes, starting with @a head, that a
bulk run reads, as get() and get_number() would
Called before the value is passed on, so that an error reported while
passing it on (see @ref emit_float) has the position and the last byte
that reading the value byte by byte gives.
*/
void bulk_advance(const std::size_t size, const unsigned char head)
{
ia.bulk_skip(size);
chars_read += size;
current = head;
}
/*!
@brief read the integers, floats, booleans, and nulls that follow in a
definite-length array, without the per-element bookkeeping of
@@ -20645,70 +20630,71 @@ class binary_reader
{
const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
const unsigned char head = data[0];
std::size_t size = 0;
bool accepted = false;
switch (head)
{
case 0x18:
bulk_advance(2, head);
size = 2;
accepted = emit_unsigned(data[1]);
break;
case 0x19:
bulk_advance(3, head);
size = 3;
accepted = emit_unsigned(load_big_endian<std::uint16_t>(data + 1));
break;
case 0x1A:
bulk_advance(5, head);
size = 5;
accepted = emit_unsigned(load_big_endian<std::uint32_t>(data + 1));
break;
case 0x1B:
bulk_advance(9, head);
size = 9;
accepted = emit_unsigned(load_big_endian<std::uint64_t>(data + 1));
break;
case 0x38:
bulk_advance(2, head);
size = 2;
accepted = emit_cbor_negative_integer(data[1]);
break;
case 0x39:
bulk_advance(3, head);
size = 3;
accepted = emit_cbor_negative_integer(load_big_endian<std::uint16_t>(data + 1));
break;
case 0x3A:
bulk_advance(5, head);
size = 5;
accepted = emit_cbor_negative_integer(load_big_endian<std::uint32_t>(data + 1));
break;
case 0x3B:
bulk_advance(9, head);
size = 9;
accepted = emit_cbor_negative_integer(load_big_endian<std::uint64_t>(data + 1));
break;
case 0xF4:
bulk_advance(1, head);
size = 1;
accepted = sax->boolean(false);
break;
case 0xF5:
bulk_advance(1, head);
size = 1;
accepted = sax->boolean(true);
break;
case 0xF6:
bulk_advance(1, head);
size = 1;
accepted = sax->null();
break;
case 0xFA:
bulk_advance(5, head);
size = 5;
accepted = emit_float(load_big_endian<float>(data + 1));
break;
case 0xFB:
bulk_advance(9, head);
size = 9;
accepted = emit_float(load_big_endian<double>(data + 1));
break;
default:
if (head <= 0x17)
{
bulk_advance(1, head);
size = 1;
accepted = sax->number_unsigned(static_cast<number_unsigned_t>(head));
}
else if (head >= 0x20 && head <= 0x37)
{
bulk_advance(1, head);
size = 1;
accepted = sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - head));
}
else
@@ -20718,6 +20704,10 @@ class binary_reader
}
break;
}
// as if read by get() and get_number(): current is the head byte
ia.bulk_skip(size);
chars_read += size;
current = head;
--remaining;
if (JSON_HEDLEY_UNLIKELY(!accepted))
{
@@ -21555,72 +21545,73 @@ class binary_reader
{
const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
const unsigned char head = data[0];
std::size_t size = 0;
bool accepted = false;
switch (head)
{
case 0xC0: // nil
bulk_advance(1, head);
size = 1;
accepted = sax->null();
break;
case 0xC2: // false
bulk_advance(1, head);
size = 1;
accepted = sax->boolean(false);
break;
case 0xC3: // true
bulk_advance(1, head);
size = 1;
accepted = sax->boolean(true);
break;
case 0xCA: // float 32
bulk_advance(5, head);
size = 5;
accepted = emit_float(load_big_endian<float>(data + 1));
break;
case 0xCB: // float 64
bulk_advance(9, head);
size = 9;
accepted = emit_float(load_big_endian<double>(data + 1));
break;
case 0xCC: // uint 8
bulk_advance(2, head);
size = 2;
accepted = emit_unsigned(data[1]);
break;
case 0xCD: // uint 16
bulk_advance(3, head);
size = 3;
accepted = emit_unsigned(load_big_endian<std::uint16_t>(data + 1));
break;
case 0xCE: // uint 32
bulk_advance(5, head);
size = 5;
accepted = emit_unsigned(load_big_endian<std::uint32_t>(data + 1));
break;
case 0xCF: // uint 64
bulk_advance(9, head);
size = 9;
accepted = emit_unsigned(load_big_endian<std::uint64_t>(data + 1));
break;
case 0xD0: // int 8
bulk_advance(2, head);
size = 2;
accepted = emit_signed(static_cast<std::int8_t>(data[1]));
break;
case 0xD1: // int 16
bulk_advance(3, head);
size = 3;
accepted = emit_signed(load_big_endian<std::int16_t>(data + 1));
break;
case 0xD2: // int 32
bulk_advance(5, head);
size = 5;
accepted = emit_signed(load_big_endian<std::int32_t>(data + 1));
break;
case 0xD3: // int 64
bulk_advance(9, head);
size = 9;
accepted = emit_signed(load_big_endian<std::int64_t>(data + 1));
break;
default:
if (head <= 0x7F)
{
// positive fixint
bulk_advance(1, head);
size = 1;
accepted = sax->number_unsigned(static_cast<number_unsigned_t>(head));
}
else if (head >= 0xE0)
{
// negative fixint
bulk_advance(1, head);
size = 1;
accepted = sax->number_integer(static_cast<std::int8_t>(head));
}
else
@@ -21630,6 +21621,10 @@ class binary_reader
}
break;
}
// as if read by get() and get_number(): current is the last byte
ia.bulk_skip(size);
chars_read += size;
current = data[size - 1];
--remaining;
if (JSON_HEDLEY_UNLIKELY(!accepted))
{
@@ -22533,7 +22528,6 @@ class binary_reader
const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
// UBJSON stores numbers big-endian, BJData little-endian
const bool swap = is_little_endian != (input_format == input_format_t::bjdata);
const std::size_t start = chars_read;
std::size_t read = 0;
bool accepted = true;
while (read < count && accepted)
@@ -22545,39 +22539,16 @@ class binary_reader
byte_swap(number);
}
++read;
// where passing the value on can report an error (see
// emit_float), the position is that after the value, as if it
// was read by get_number()
set_chars_read(start + (read * size), std::integral_constant<bool, may_overflow_number_float<NumberType>()> {});
accepted = emit_ubjson_number(number);
}
// get_number() does not change current
// as if read by get_number(): current is the last byte read
ia.bulk_skip(read * size);
chars_read = start + (read * size);
chars_read += read * size;
current = data[(read * size) - 1];
remaining -= read;
return accepted;
}
/*!
@brief whether a value of type @a NumberType can be finite and still
overflow number_float_t, which @ref emit_float reports as an error
False for the default number types, so that the loop in @ref
parse_ubjson_typed_run need not track the position per value.
*/
template<typename NumberType>
static constexpr bool may_overflow_number_float() noexcept
{
return static_cast<long double>((std::numeric_limits<number_float_t>::max)()) < static_cast<long double>((std::numeric_limits<NumberType>::max)());
}
void set_chars_read(const std::size_t position, std::true_type /*track*/) noexcept
{
chars_read = position;
}
void set_chars_read(const std::size_t /*position*/, std::false_type /*track*/) const noexcept {}
template<typename NumberType, enable_if_t<std::is_floating_point<NumberType>::value, int> = 0>
bool emit_ubjson_number(const NumberType number)
{
+53 -3
View File
@@ -5564,7 +5564,9 @@ inline node* block_of(document_data& d, node* n, std::size_t extra)
h->len = n->len;
h->next = static_cast<std::uint32_t>(used);
node* o = h + 1;
for (const node* c = d.first_child_edited(n), *e = d.child_end_edited(n); c != e;)
// (the bound on o keeps the copy inside the block even if the elements
// 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)
{
@@ -5646,6 +5648,41 @@ 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 detail
NLOHMANN_JSON_NAMESPACE_END
@@ -6522,9 +6559,22 @@ class editor
// for the container is linear in the size of the document, so
// links (which are marked in the slot) avoid it.
node* const p = parent_known ? parent : find_parent(m_doc, slot);
if (p != nullptr && ((p->flags & node_flags::moved) == 0 || moved_capacity(m_doc, p) == 0))
if (p != nullptr)
{
block_of(m_doc, p, 0);
if ((p->flags & node_flags::moved) == 0 || moved_capacity(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;
-123
View File
@@ -14,7 +14,6 @@ using nlohmann::json;
#include <cmath>
#include <fstream>
#include <limits>
#include <list>
#include <map>
#include <string>
#include <vector>
@@ -368,125 +367,3 @@ TEST_CASE("Binary formats with narrow number types")
CHECK(format.decode(format.encode(json(1e300)), false).is_discarded());
}
}
namespace
{
// records the SAX events of narrow_json, including the arguments of parse_error
struct narrow_event_recorder
{
using number_integer_t = narrow_json::number_integer_t;
using number_unsigned_t = narrow_json::number_unsigned_t;
using number_float_t = narrow_json::number_float_t;
using string_t = narrow_json::string_t;
using binary_t = narrow_json::binary_t;
bool null()
{
events.emplace_back("null");
return true;
}
bool boolean(bool val)
{
events.emplace_back(val ? "true" : "false");
return true;
}
bool number_integer(number_integer_t val)
{
events.push_back(std::to_string(val));
return true;
}
bool number_unsigned(number_unsigned_t val)
{
events.push_back(std::to_string(val));
return true;
}
bool number_float(number_float_t val, const string_t& /*unused*/)
{
events.push_back(std::to_string(val));
return true;
}
bool string(string_t& val)
{
events.push_back(val);
return true;
}
bool binary(binary_t& /*unused*/)
{
events.emplace_back("binary");
return true;
}
bool start_object(std::size_t /*unused*/)
{
events.emplace_back("{");
return true;
}
bool key(string_t& val)
{
events.push_back(val);
return true;
}
bool end_object()
{
events.emplace_back("}");
return true;
}
bool start_array(std::size_t /*unused*/)
{
events.emplace_back("[");
return true;
}
bool end_array()
{
events.emplace_back("]");
return true;
}
bool parse_error(std::size_t position, const std::string& last_token, const nlohmann::detail::exception& ex)
{
events.push_back("parse_error(" + std::to_string(position) + ", " + last_token + ", " + ex.what() + ")");
return false;
}
std::vector<std::string> events {}; // NOLINT(readability-redundant-member-init)
};
} // namespace
TEST_CASE("Binary formats with narrow number types from contiguous and non-contiguous input")
{
// contiguous input reads runs of numbers in one loop; a number that
// overflows number_float_t must be reported with the same position and
// last byte as when the input is read byte by byte
const json values = {1, 70000, -70000, 1.5, 2.5, 1e300, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5};
const json doubles = {1.5, 2.5, 3.5, 1e300, 4.5, 5.5, 6.5, 7.5, 8.5};
struct binary_input
{
const char* name;
json::input_format_t format;
bytes data;
};
const std::vector<binary_input> inputs =
{
{"CBOR", json::input_format_t::cbor, json::to_cbor(values)},
{"CBOR doubles", json::input_format_t::cbor, json::to_cbor(doubles)},
{"MessagePack", json::input_format_t::msgpack, json::to_msgpack(values)},
{"MessagePack doubles", json::input_format_t::msgpack, json::to_msgpack(doubles)},
{"UBJSON", json::input_format_t::ubjson, json::to_ubjson(values, true)},
{"UBJSON typed doubles", json::input_format_t::ubjson, json::to_ubjson(doubles, true, true)},
{"BJData", json::input_format_t::bjdata, json::to_bjdata(values, true)},
{"BJData typed doubles", json::input_format_t::bjdata, json::to_bjdata(doubles, true, true)},
};
for (const auto& input : inputs)
{
const std::string name = input.name;
CAPTURE(name)
const std::list<std::uint8_t> bytewise(input.data.begin(), input.data.end());
narrow_event_recorder from_contiguous;
narrow_event_recorder from_bytewise;
CHECK_FALSE(narrow_json::sax_parse(input.data, &from_contiguous, input.format));
CHECK_FALSE(narrow_json::sax_parse(bytewise.begin(), bytewise.end(), &from_bytewise, input.format));
CHECK(from_contiguous.events == from_bytewise.events);
REQUIRE(!from_contiguous.events.empty());
CHECK(from_contiguous.events.back().find("out_of_range.406") != std::string::npos);
}
}
+70
View File
@@ -589,6 +589,76 @@ 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"}]})"));
}
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)
TEST_CASE("json_view edits: the size of a text arena")
{