Mirror-bot/AnyPS5
1
0 Fork 0
mirror of https://github.com/boykopovar/AnyPS5.git synced 2026-11-04 13:07:32 +00:00
Code Issues Projects Releases Activity
Files
25797f0faba7bfd01c6e5ffdb357edac799be4e2
AnyPS5/core/libs/tests/GuestJsonObjectAllocator.cpp
T

1128 lines
57 KiB
C++
Raw Blame History

#include "prx/libSceJson2/include/Api.hpp"
#include "prx/libc/include/general/VabiMacros.hpp"
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace SceJson2;
struct StoredText { const char* characters; std::uint32_t length; std::uint32_t capacity; std::uint64_t reserved; };
struct TreeNode { TreeNode* parent; TreeNode* left; TreeNode* right; StoredText key; Pair pair; std::uint8_t color; std::uint8_t nil; std::uint8_t reserved[6]; };
struct TreeHeader { TreeNode* head; std::size_t count; std::uint64_t reserved; Value* owner; };
struct Parameter { void* allocator; void* context; std::size_t bufferSize; std::int32_t mode; std::uint32_t reserved[3]; };
static_assert(sizeof(TreeNode) == 104 && offsetof(TreeNode, pair) == 48 && offsetof(TreeNode, color) == 96);
using ReadCallback = int (APS5_VABI*)(char&, void*);
static void Require(bool valid, const char* message) {
if (!valid) { std::fprintf(stderr, "%s\n", message); std::abort(); }
}
struct ObjectAllocationTrace {
std::map<void*, std::size_t> live;
std::vector<std::size_t> requests;
std::set<void*> headers;
int budget = -1;
bool failOnce = false;
unsigned notifications = 0;
};
static void* APS5_VABI AllocateObject(void*, std::size_t bytes, void* context) {
auto& trace = *static_cast<ObjectAllocationTrace*>(context); trace.requests.push_back(bytes);
if (trace.budget == 0) { if (trace.failOnce) trace.budget = -1; return nullptr; }
if (trace.budget > 0) --trace.budget;
void* memory = std::malloc(bytes);
Require(memory != nullptr, "Tracking allocator requires host memory");
std::memset(memory, 0xa5, bytes); trace.live.emplace(memory, bytes); return memory;
}
static void APS5_VABI FreeObject(void*, void* memory, void* context) {
if (!memory) return;
auto& trace = *static_cast<ObjectAllocationTrace*>(context);
if (trace.headers.erase(memory)) {
const auto* words = reinterpret_cast<const std::uint64_t*>(memory);
Require(words[0] == 0xffffffff && words[1] == UINT64_MAX, "Object teardown must poison the header before freeing it");
}
Require(trace.live.erase(memory) == 1, "Object resources must return through their owning allocator"); std::free(memory);
}
static void APS5_VABI NotifyObject(void*, int error, std::size_t bytes, void* context) {
auto& trace = *static_cast<ObjectAllocationTrace*>(context);
Require(static_cast<unsigned>(error) == 0x80848102 && trace.requests.back() == bytes, "Object notification must identify the failed allocation"); ++trace.notifications;
}
static void* const ObjectVtable[]{nullptr, nullptr, reinterpret_cast<void*>(AllocateObject), reinterpret_cast<void*>(FreeObject), reinterpret_cast<void*>(NotifyObject)};
struct ObjectAllocator { void* const* vtable = ObjectVtable; };
static bool Owned(const ObjectAllocationTrace& trace, const void* memory, std::size_t bytes) {
const auto found = trace.live.find(const_cast<void*>(memory)); return found != trace.live.end() && found->second == bytes;
}
static Value* Entry(Object& object, const char* key) {
String text{}; _ZN3sce4Json6StringC1EPKc(&text, key);
auto* result = _ZN3sce4Json6ObjectixERKNS0_6StringE(&object, &text);
_ZN3sce4Json6StringD1Ev(&text); return result;
}
static void CheckTree(const Object& object, ObjectAllocationTrace& trace, const std::map<std::string, Value*>& entries) {
const auto* header = reinterpret_cast<const TreeHeader*>(object.items);
Require(Owned(trace, header, 32) && Owned(trace, header->head, 104) && !header->owner && header->count == entries.size(), "Object header and sentinel must be actual allocator-owned resources");
trace.headers.insert(object.items);
auto* head = header->head;
Require(head->nil == 1 && head->color == 0, "Sentinel flags must mark a black nil node");
std::vector<TreeNode*> nodes;
std::function<unsigned(TreeNode*, TreeNode*)> visit = [&](TreeNode* node, TreeNode* parent) -> unsigned {
if (node == head) return 1;
Require(Owned(trace, node, 104) && !node->nil && node->color <= 1 && node->parent == parent, "Every tree node must retain its native allocation and parent link");
Require(node->color == 0 || (node->left->color == 0 && node->right->color == 0), "Red nodes must have black children");
const auto left = visit(node->left, node); nodes.push_back(node); const auto right = visit(node->right, node);
Require(left == right, "Every path must retain the same black height");
Require(Owned(trace, node->pair.key.text, 24) && !node->pair.value.parent && !node->pair.value.auxiliary, "Node pairs must expose native string and value ownership");
const auto found = entries.find(node->key.characters);
Require(found != entries.end() && found->second == &node->pair.value && std::strcmp(node->key.characters, _ZNK3sce4Json6String5c_strEv(&node->pair.key)) == 0, "Rotations must preserve entry identity and both key representations");
return left + (node->color == 0);
};
Require(head->parent->color == 0, "Tree root must remain black"); visit(head->parent, head);
Require(nodes.size() == entries.size() && (nodes.empty() ? head->left == head && head->right == head : head->left == nodes.front() && head->right == nodes.back()), "Sentinel endpoints must match the ordered entries");
auto expected = entries.begin();
for (const auto* node : nodes) { Require(expected->first == node->key.characters, "Tree iteration must preserve key order"); ++expected; }
}
static std::vector<std::string> Keys(const Object& object) {
ObjectIterator current{}, end{}; _ZNK3sce4Json6Object5beginEv(&current, &object); _ZNK3sce4Json6Object3endEv(&end, &object);
std::vector<std::string> keys;
while (*reinterpret_cast<void**>(current.state) != *reinterpret_cast<void**>(end.state)) {
keys.emplace_back(_ZNK3sce4Json6String5c_strEv(&_ZNK3sce4Json6Object8iteratordeEv(&current)->key));
_ZN3sce4Json6Object8iteratorppEv(&current);
}
_ZN3sce4Json6Object8iteratorD1Ev(&current); _ZN3sce4Json6Object8iteratorD1Ev(&end); return keys;
}
static void CheckSerialized(Value& value, const char* expected) {
String output{}; _ZN3sce4Json6StringC1Ev(&output);
Require(_ZN3sce4Json5Value9serializeERNS0_6StringE(&value, &output) == 0 && std::strcmp(_ZNK3sce4Json6String5c_strEv(&output), expected) == 0,
"Object keys and string values must retain their distinct binary serialization behavior");
_ZN3sce4Json6StringD1Ev(&output);
}
static void CheckBinaryKeys() {
String key{}; _ZN3sce4Json6StringC1EPKc(&key, "a");
const char suffix[]{0, 'b'}; _ZN3sce4Json6String6appendEPKcm(&key, suffix, sizeof(suffix));
Value value{}; _ZN3sce4Json5ValueC1ERKNS0_6StringE(&value, &key);
CheckSerialized(value, R"("a\u0000b")"); _ZN3sce4Json5ValueD1Ev(&value);
Object object{}; _ZN3sce4Json6ObjectC1Ev(&object); _ZN3sce4Json6ObjectixERKNS0_6StringE(&object, &key);
_ZN3sce4Json5ValueC1ERKNS0_6ObjectE(&value, &object); CheckSerialized(value, R"({"a":null})");
_ZN3sce4Json5ValueD1Ev(&value); _ZN3sce4Json6ObjectD1Ev(&object); _ZN3sce4Json6StringD1Ev(&key);
_ZN3sce4Json5ValueC1Ev(&value);
const char input[] = R"({"a":1,"a\u0000suffix":2})";
Require(_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&value, input, sizeof(input) - 1) == 0 && _ZNK3sce4Json5Value5countEv(&value) == 2,
"The inspected parser drops the decoded zero byte without treating the two keys as duplicates");
CheckSerialized(value, R"({"a":1,"asuffix":2})"); _ZN3sce4Json5ValueD1Ev(&value);
_ZN3sce4Json5ValueC1Ev(&value);
const char string[] = R"("a\u0000b")";
Require(_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&value, string, sizeof(string) - 1) == 0, "Parse a zero-byte escape in a string value");
CheckSerialized(value, R"("ab")"); _ZN3sce4Json5ValueD1Ev(&value);
}
static void CheckFailures(ObjectAllocationTrace& trace, const Value* moduleFallback) {
const auto baseline = trace.live.size();
for (bool once : {false, true}) for (int budget = 0; budget <= 8; ++budget) {
Object object{}; _ZN3sce4Json6ObjectC1Ev(&object); Entry(object, "a"); Entry(object, "c");
trace.headers.insert(object.items);
String text{}; _ZN3sce4Json6StringC1EPKc(&text, "b");
trace.budget = budget; trace.failOnce = once;
const auto notifications = trace.notifications;
auto* result = _ZN3sce4Json6ObjectixERKNS0_6StringE(&object, &text);
trace.budget = -1;
const bool inserted = once ? budget != 4 : budget >= 5;
const auto expected = inserted ? std::size_t{3} : std::size_t{2};
Require(_ZNK3sce4Json6Object4sizeEv(&object) == expected, "Failed object insertion must retain the observed partial entry count");
const bool fallback = budget < 7;
Require((result == moduleFallback) == fallback, "Insertion must preserve its operation-level versus late-assignment failure result");
std::vector<std::string> expectedKeys{"a", "c"};
if (inserted) {
if (once && (budget == 0 || budget == 2)) expectedKeys = {"", "a", "c"};
else expectedKeys = {"a", budget == 8 ? "b" : "", "c"};
}
Require(Keys(object) == expectedKeys, "Partial allocation failures must preserve the observed public keys and ordering");
static constexpr unsigned persistentNotifications[]{3, 3, 3, 2, 1, 2, 1, 1, 0};
Require(trace.notifications - notifications == (once ? static_cast<unsigned>(budget < 8) : persistentNotifications[budget]), "Object failures must notify for each real failed request");
_ZN3sce4Json6StringD1Ev(&text); _ZN3sce4Json6ObjectD1Ev(&object);
Require(trace.live.size() == baseline, "All partial insertion states must be destructible without leaks");
}
trace.failOnce = false;
}
static std::string AssignmentContents(const Object& object) {
std::string result;
auto* head = reinterpret_cast<const TreeHeader*>(object.items)->head;
auto* node = head->left;
while (node != head) {
result += node->pair.key.text ? reinterpret_cast<const StoredText*>(node->pair.key.text)->characters : "~";
result += ":" + std::to_string(node->pair.value.type) + ":" + std::to_string(node->pair.value.payload) + ";";
if (!node->right->nil) { node = node->right; while (!node->left->nil) node = node->left; }
else { auto* parent = node->parent; while (!parent->nil && node == parent->right) { node = parent; parent = parent->parent; } node = parent; }
}
return result;
}
static void CheckInsertions(ObjectAllocationTrace& trace) {
struct Case { bool duplicate; bool once; int budget; std::size_t count; unsigned notifications; bool state; const char* result; const char* contents; };
const Case cases[]{
{0, 0, -1, 3, 0, 1, "b", "a:2:11;b:2:22;c:2:33;"},
{0, 0, 0, 2, 4, 0, "NONE", "a:2:11;c:2:33;"},
{0, 0, 1, 2, 3, 1, "END", "a:2:11;c:2:33;"},
{0, 0, 2, 2, 3, 1, "END", "a:2:11;c:2:33;"},
{0, 0, 3, 2, 4, 1, "END", "a:2:11;c:2:33;"},
{0, 0, 4, 2, 3, 1, "END", "a:2:11;c:2:33;"},
{0, 0, 5, 2, 2, 1, "END", "a:2:11;c:2:33;"},
{0, 0, 6, 2, 2, 1, "END", "a:2:11;c:2:33;"},
{0, 0, 7, 2, 1, 1, "END", "a:2:11;c:2:33;"},
{0, 0, 8, 3, 2, 1, "NULL", "a:2:11;~:0:11936128518282651045;c:2:33;"},
{0, 0, 9, 3, 1, 1, "NULL", "a:2:11;~:0:11936128518282651045;c:2:33;"},
{0, 0, 10, 3, 1, 1, "", "a:2:11;:0:11936128518282651045;c:2:33;"},
{0, 0, 11, 3, 0, 1, "b", "a:2:11;b:2:22;c:2:33;"},
{0, 0, 12, 3, 0, 1, "b", "a:2:11;b:2:22;c:2:33;"},
{0, 1, -1, 3, 0, 1, "b", "a:2:11;b:2:22;c:2:33;"},
{0, 1, 0, 3, 1, 0, "NONE", "a:2:11;b:2:22;c:2:33;"},
{0, 1, 1, 3, 1, 1, "b", "b:0:11936128518282651045;a:2:11;c:2:33;"},
{0, 1, 2, 3, 1, 1, "NULL", "a:2:11;~:0:11936128518282651045;c:2:33;"},
{0, 1, 3, 3, 1, 1, "", "a:2:11;:0:11936128518282651045;c:2:33;"},
{0, 1, 4, 3, 1, 1, "b", "b:0:11936128518282651045;a:2:11;c:2:33;"},
{0, 1, 5, 3, 1, 1, "NULL", "a:2:11;~:0:11936128518282651045;c:2:33;"},
{0, 1, 6, 3, 1, 1, "", "a:2:11;:0:11936128518282651045;c:2:33;"},
{0, 1, 7, 2, 1, 1, "END", "a:2:11;c:2:33;"},
{0, 1, 8, 3, 1, 1, "b", "a:2:11;b:0:11936128518282651045;c:2:33;"},
{0, 1, 9, 3, 1, 1, "NULL", "a:2:11;~:0:11936128518282651045;c:2:33;"},
{0, 1, 10, 3, 1, 1, "", "a:2:11;:0:11936128518282651045;c:2:33;"},
{0, 1, 11, 3, 0, 1, "b", "a:2:11;b:2:22;c:2:33;"},
{0, 1, 12, 3, 0, 1, "b", "a:2:11;b:2:22;c:2:33;"},
{1, 0, -1, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 0, 0, 2, 4, 0, "NONE", "a:2:11;c:2:33;"},
{1, 0, 1, 2, 3, 1, "END", "a:2:11;c:2:33;"},
{1, 0, 2, 2, 3, 1, "END", "a:2:11;c:2:33;"},
{1, 0, 3, 2, 4, 1, "END", "a:2:11;c:2:33;"},
{1, 0, 4, 2, 3, 1, "END", "a:2:11;c:2:33;"},
{1, 0, 5, 2, 1, 1, "a", "a:2:11;c:2:33;"},
{1, 0, 6, 2, 1, 1, "a", "a:2:11;c:2:33;"},
{1, 0, 7, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 0, 8, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 0, 9, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 0, 10, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 0, 11, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 0, 12, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 1, -1, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 1, 0, 2, 1, 0, "NONE", "a:2:11;c:2:33;"},
{1, 1, 1, 3, 1, 1, "a", "a:0:11936128518282651045;a:2:11;c:2:33;"},
{1, 1, 2, 2, 1, 1, "a", "a:2:11;c:2:33;"},
{1, 1, 3, 2, 1, 1, "a", "a:2:11;c:2:33;"},
{1, 1, 4, 3, 1, 1, "a", "a:0:11936128518282651045;a:2:11;c:2:33;"},
{1, 1, 5, 2, 1, 1, "a", "a:2:11;c:2:33;"},
{1, 1, 6, 2, 1, 1, "a", "a:2:11;c:2:33;"},
{1, 1, 7, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 1, 8, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 1, 9, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 1, 10, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 1, 11, 2, 0, 1, "a", "a:2:11;c:2:33;"},
{1, 1, 12, 2, 0, 1, "a", "a:2:11;c:2:33;"},
};
const auto baseline = trace.live.size();
for (const auto& test : cases) {
Object object{}; _ZN3sce4Json6ObjectC1Ev(&object);
auto* first = Entry(object, "a"); _ZN3sce4Json5Value3setEl(first, 11);
_ZN3sce4Json5Value3setEl(Entry(object, "c"), 33);
Pair pair{}; _ZN3sce4Json6StringC1EPKc(&pair.key, test.duplicate ? "a" : "b");
_ZN3sce4Json5ValueC1Ev(&pair.value); _ZN3sce4Json5Value3setEl(&pair.value, 22);
const auto notifications = trace.notifications;
trace.budget = test.budget; trace.failOnce = test.once;
ObjectIterator result{};
Require(_ZN3sce4Json6Object6insertERKNS1_4PairE(&result, &object, &pair) == &result, "Insertion must return its result iterator");
trace.budget = -1; trace.failOnce = false;
Require((result.state != nullptr) == test.state, "Insertion must preserve independent iterator allocation failure");
auto* node = result.state ? *reinterpret_cast<TreeNode**>(result.state) : nullptr;
const char* key = !node ? "NONE" : node->nil ? "END" : node->pair.key.text ? reinterpret_cast<const StoredText*>(node->pair.key.text)->characters : "NULL";
Require(std::strcmp(key, test.result) == 0, "Insertion must return the reference entry or end node on failure");
Require(_ZNK3sce4Json6Object4sizeEv(&object) == test.count && AssignmentContents(object) == test.contents, "Insertion must preserve partial keys, inactive payloads and duplicate values");
Require(trace.notifications - notifications == test.notifications, "Insertion must notify every failed owned allocation");
Require(first->type == 2 && first->payload == 11 && pair.value.type == 2 && pair.value.payload == 22, "Insertion must preserve existing entries and its input value");
_ZN3sce4Json6Object8iteratorD1Ev(&result); _ZN3sce4Json6StringD1Ev(&pair.key); _ZN3sce4Json5ValueD1Ev(&pair.value); _ZN3sce4Json6ObjectD1Ev(&object);
Require(trace.live.size() == baseline, "Insertion failure must release temporary allocations and iterator state");
}
}
static void CheckIteratorFailures(ObjectAllocationTrace& trace) {
const auto baseline = trace.live.size();
Object object{}; _ZN3sce4Json6ObjectC1Ev(&object);
Entry(object, "a");
String key{}; _ZN3sce4Json6StringC1EPKc(&key, "a");
ObjectIterator source{}; _ZNK3sce4Json6Object5beginEv(&source, &object);
const auto retained = trace.live.size();
for (unsigned operation = 0; operation < 5; ++operation) {
const auto requests = trace.requests.size();
const auto notifications = trace.notifications;
ObjectIterator failed{}; trace.budget = 0;
switch (operation) {
case 0: _ZN3sce4Json6Object8iteratorC1Ev(&failed); break;
case 1: _ZN3sce4Json6Object8iteratorC1ERKS2_(&failed, &source); break;
case 2: _ZNK3sce4Json6Object5beginEv(&failed, &object); break;
case 3: _ZNK3sce4Json6Object3endEv(&failed, &object); break;
case 4: _ZNK3sce4Json6Object4findERKNS0_6StringE(&failed, &object, &key); break;
}
trace.budget = -1;
Require(!failed.state && trace.live.size() == retained, "Failed iterator allocation must retain no state or borrowed resources");
Require(trace.requests.size() == requests + 1 && trace.requests.back() == 8 && trace.notifications == notifications + 1, "ObjectIterator failure must report its actual eight-byte allocation");
_ZN3sce4Json6Object8iteratorD1Ev(&failed);
}
ObjectIterator absent{}, copy{}, target{}, end{};
const auto requests = trace.requests.size();
trace.budget = 0;
_ZN3sce4Json6Object8iteratorC1ERKS2_(&copy, &absent);
Require(_ZN3sce4Json6Object8iteratoraSERKS2_(&absent, &source) == &absent && !absent.state && !copy.state && trace.requests.size() == requests, "Copying absent state and assigning into absent state must not allocate");
trace.budget = -1;
_ZN3sce4Json6Object8iteratorC1ERKS2_(&target, &source);
_ZNK3sce4Json6Object3endEv(&end, &object);
auto* storage = target.state;
trace.budget = 0;
_ZN3sce4Json6Object8iteratoraSERKS2_(&target, &end);
Require(target.state == storage && *reinterpret_cast<void**>(target.state) == reinterpret_cast<TreeHeader*>(object.items)->head, "Assignment from end must preserve owned iterator state and copy the sentinel");
_ZN3sce4Json6Object8iteratoraSERKS2_(&target, &absent);
Require(!target.state && trace.live.size() == retained + 1, "Assignment from absent state must release the destination iterator state");
trace.budget = -1;
_ZN3sce4Json6Object8iteratorD1Ev(&end); _ZN3sce4Json6Object8iteratorD1Ev(&target);
Object missing{};
_ZNK3sce4Json6Object5beginEv(&target, &missing);
Require(Owned(trace, target.state, 8) && !*reinterpret_cast<void**>(target.state), "A missing object must produce an allocated iterator with no position");
_ZN3sce4Json6Object8iteratorD1Ev(&target);
_ZN3sce4Json6Object8iteratorD1Ev(&source); _ZN3sce4Json6StringD1Ev(&key); _ZN3sce4Json6ObjectD1Ev(&object);
Require(trace.live.size() == baseline, "ObjectIterator failure and assignment paths must release all owned state");
}
static void CheckNestedAssignment(ObjectAllocationTrace& trace) {
const auto baseline = trace.live.size();
Value source{}, destination{};
_ZN3sce4Json5ValueC1Ev(&source); _ZN3sce4Json5ValueC1Ev(&destination);
const char input[] = "{\"nested\":{\"x\":1},\"array\":[2],\"text\":\"abc\",\"bool\":true,\"real\":1.25,\"nil\":null}";
const char previous[] = "{\"old\":0}";
Require(_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&source, input, sizeof(input) - 1) == 0, "Parse nested assignment source");
Require(_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&destination, previous, sizeof(previous) - 1) == 0, "Parse nested assignment destination");
auto* target = reinterpret_cast<Object*>(destination.payload);
_ZN3sce4Json6ObjectaSERKS1_(target, reinterpret_cast<const Object*>(source.payload));
String expected{}, actual{};
_ZN3sce4Json6StringC1Ev(&expected); _ZN3sce4Json6StringC1Ev(&actual);
Require(_ZN3sce4Json5Value9serializeERNS0_6StringE(&source, &expected) == 0 && _ZN3sce4Json5Value9serializeERNS0_6StringE(&destination, &actual) == 0, "Serialize nested assignment results");
Require(std::strcmp(_ZNK3sce4Json6String5c_strEv(&expected), _ZNK3sce4Json6String5c_strEv(&actual)) == 0, "Assignment must preserve nested collections, strings and scalar types");
auto* header = reinterpret_cast<TreeHeader*>(target->items);
Require(header->owner == &destination, "Assigned root object must retain its owner");
ObjectIterator iterator{}; _ZNK3sce4Json6Object5beginEv(&iterator, target);
for (std::size_t index = 0; index < header->count; ++index) {
const auto* pair = _ZNK3sce4Json6Object8iteratordeEv(&iterator);
Require(pair->value.parent == &destination, "Assigned entries must bind to the destination value");
if (pair->value.type == 6 || pair->value.type == 7) {
auto* nestedStorage = *reinterpret_cast<void* const*>(pair->value.payload);
Value* owner = nullptr; std::memcpy(&owner, reinterpret_cast<const char*>(nestedStorage) + 24, sizeof(owner));
Require(owner == &pair->value, "Nested collection ownership must bind to the assigned entry");
}
_ZN3sce4Json6Object8iteratorppEv(&iterator);
}
_ZN3sce4Json6Object8iteratorD1Ev(&iterator);
_ZN3sce4Json6StringD1Ev(&actual); _ZN3sce4Json6StringD1Ev(&expected);
_ZN3sce4Json5ValueD1Ev(&destination); _ZN3sce4Json5ValueD1Ev(&source);
Require(trace.live.size() == baseline, "Nested assignment must release all resources");
}
static std::string NestedObjectFailureState(const Value& value, const Value* parent = nullptr) {
std::string state = std::to_string(value.type) + (value.parent == parent ? "p" : value.parent ? "x" : "-");
if (value.type == 0) return state;
if (value.type < 5) return state + ":" + std::to_string(value.payload);
if (!value.payload) return state + "!";
const auto* header = *reinterpret_cast<void* const*>(value.payload);
if (!header) return state + "?";
if (value.type == 5) {
const auto* text = reinterpret_cast<const StoredText*>(header);
return state + ":" + std::string(text->characters, text->length);
}
const auto* words = reinterpret_cast<const std::uintptr_t*>(header);
state += words[3] == reinterpret_cast<std::uintptr_t>(&value) ? "o" : "!";
state += std::to_string(words[1]) + "[";
if (!words[0]) return state + "?]";
if (value.type == 6) {
const auto* head = reinterpret_cast<const std::uintptr_t*>(words[0]);
const auto* node = reinterpret_cast<const std::uintptr_t*>(head[1]);
unsigned steps = 0;
while (node != head) {
Require(++steps < 32, "Nested test array links must reach their sentinel");
state += NestedObjectFailureState(*reinterpret_cast<const Value*>(node + 2), &value) + ";";
node = reinterpret_cast<const std::uintptr_t*>(node[1]);
}
} else {
Require(value.type == 7, "Nested test collection must be an array or object");
const auto* head = reinterpret_cast<const TreeNode*>(words[0]);
unsigned steps = 0;
std::function<void(const TreeNode*)> visit = [&](const TreeNode* node) {
if (node == head) return;
Require(node && ++steps < 32, "Nested test tree links must reach their sentinel");
visit(node->left);
state += node->pair.key.text ? _ZNK3sce4Json6String5c_strEv(&node->pair.key) : "~";
state += "=" + NestedObjectFailureState(node->pair.value, &value) + ";";
visit(node->right);
};
visit(head->parent);
}
return state + "]";
}
struct NestedReader {
unsigned operation;
Value* source;
Value* destination;
Pair* pair;
ObjectIterator* iterator;
std::size_t offset = 0;
unsigned calls = 0;
};
static int APS5_VABI ReadWithCollectionOperation(char& character, void* context) {
auto& reader = *static_cast<NestedReader*>(context);
if (reader.offset == 2) {
++reader.calls;
if (reader.operation == 0) _ZN3sce4Json5ArrayaSERKS1_(reinterpret_cast<Array*>(reader.destination->payload), reinterpret_cast<const Array*>(reader.source->payload));
else if (reader.operation == 1) _ZN3sce4Json6ObjectaSERKS1_(reinterpret_cast<Object*>(reader.destination->payload), reinterpret_cast<const Object*>(reader.source->payload));
else _ZN3sce4Json6Object6insertERKNS1_4PairE(reader.iterator, reinterpret_cast<Object*>(reader.destination->payload), reader.pair);
}
const char text[] = "\"abc\"";
if (reader.offset == sizeof(text) - 1) return static_cast<int>(0x80848101u);
character = text[reader.offset++];
return 0;
}
static void CheckInheritedCollectionErrors(ObjectAllocationTrace& trace) {
const char* const failedStates[]{"6po2[3-:0;3-:0;]", "7po2[a=3-:0;c=3-:0;]", "7po2[a=0-;z=3p:99;]"};
const char* const healthyStates[]{"6po2[3p:10;3p:20;]", "7po2[a=3p:11;c=3p:33;]", "7po2[a=2p:11;z=3p:99;]"};
const auto baseline = trace.live.size();
for (unsigned operation = 0; operation < 3; ++operation) for (bool fail : {false, true}) {
Value source{}, destination{}, parsed{};
_ZN3sce4Json5ValueC1Ev(&source); _ZN3sce4Json5ValueC1Ev(&destination); _ZN3sce4Json5ValueC1Ev(&parsed);
const auto* input = operation == 0 ? "[10,20]" : "{\"a\":11,\"c\":33}";
const auto* previous = operation == 0 ? "[99]" : "{\"z\":99}";
Require(_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&source, input, std::strlen(input)) == 0 && _ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&destination, previous, std::strlen(previous)) == 0, "Prepare nested operation source and destination");
const auto sourceState = NestedObjectFailureState(source);
Pair pair{}; _ZN3sce4Json6StringC1EPKc(&pair.key, "a"); _ZN3sce4Json5Value3setEl(&pair.value, 11);
ObjectIterator iterator{};
NestedReader reader{operation, &source, &destination, &pair, &iterator};
const auto notifications = trace.notifications;
trace.budget = fail ? 4 : -1; trace.failOnce = fail;
const auto status = static_cast<unsigned>(_ZN3sce4Json6Parser5parseERNS0_5ValueEPFiRcPvES5_(&parsed, ReadWithCollectionOperation, &reader));
trace.budget = -1; trace.failOnce = false;
const auto actual = NestedObjectFailureState(destination);
const auto* expected = fail ? failedStates[operation] : healthyStates[operation];
if (actual != expected) std::fprintf(stderr, "Nested operation=%u fail=%d expected=%s actual=%s\n", operation, fail, expected, actual.c_str());
Require(reader.calls == 1 && actual == expected, "Nested collection operations must retain inherited errors and preserve healthy behavior");
Require(status == (fail ? 0x80848102u : 0u) && trace.notifications - notifications == (fail ? 1u : 0u), "Nested operation completion must retain the parser failure until outer completion");
Require(NestedObjectFailureState(source) == sourceState, "Nested failure propagation must preserve its source");
Require(parsed.type == 5 && std::strcmp(_ZNK3sce4Json6String5c_strEv(reinterpret_cast<const String*>(parsed.payload)), fail ? "bc" : "abc") == 0, "Nested calls must preserve the parser character-retry result");
Require(_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&parsed, "true", 4) == 0, "Outer completion must clear inherited errors before the next independent parse");
_ZN3sce4Json6Object8iteratorD1Ev(&iterator);
_ZN3sce4Json6StringD1Ev(&pair.key); _ZN3sce4Json5ValueD1Ev(&pair.value);
_ZN3sce4Json5ValueD1Ev(&parsed); _ZN3sce4Json5ValueD1Ev(&destination); _ZN3sce4Json5ValueD1Ev(&source);
Require(trace.live.size() == baseline, "Nested operation completion must reclaim parser, collection and iterator resources");
}
}
static void CheckParserObjectFailures(ObjectAllocationTrace& trace) {
static const char* const states[]{
"0p",
"7po0[]",
"7po1[~=0-;]",
"7po1[=0p;]",
"7po1[a=0p;]",
"7po1[a=5p:;]",
"7po1[a=5p:abc;]",
"7po2[a=5p:abc;~=0-;]",
"7po2[a=5p:abc;=0p;]",
"7po2[a=5p:abc;b=0p;]",
"7po2[a=5p:abc;b=6po0[];]",
"7po2[a=5p:abc;b=6po1[3p:0;];]",
"7po2[a=5p:abc;b=6po1[3p:2;];]",
"7po1[=0-;]",
"7po1[a=5p:bc;]",
"7po2[=0-;a=5p:abc;]",
"7po2[a=5p:abc;=0-;]",
};
struct Case { bool once; int budget; unsigned notifications; std::size_t requests; unsigned state; };
const Case cases[]{
{0, 0, 2, 2, 0},
{0, 1, 2, 3, 0},
{0, 2, 2, 4, 0},
{0, 3, 2, 5, 1},
{0, 4, 2, 6, 1},
{0, 5, 1, 6, 1},
{0, 6, 3, 9, 1},
{0, 7, 3, 10, 1},
{0, 8, 3, 11, 1},
{0, 9, 3, 12, 1},
{0, 10, 2, 12, 1},
{0, 11, 1, 12, 1},
{0, 12, 2, 14, 2},
{0, 13, 1, 14, 2},
{0, 14, 1, 15, 3},
{0, 15, 1, 16, 4},
{0, 16, 1, 17, 4},
{0, 17, 3, 20, 5},
{0, 18, 3, 21, 6},
{0, 19, 3, 22, 6},
{0, 20, 3, 23, 6},
{0, 21, 3, 24, 6},
{0, 22, 2, 24, 6},
{0, 23, 1, 24, 6},
{0, 24, 2, 26, 7},
{0, 25, 1, 26, 7},
{0, 26, 1, 27, 8},
{0, 27, 1, 28, 9},
{0, 28, 1, 29, 9},
{0, 30, 1, 31, 10},
{0, 31, 1, 32, 11},
{0, 32, 1, 33, 11},
{0, 33, 0, 33, 12},
{1, 0, 1, 3, 0},
{1, 1, 1, 4, 0},
{1, 2, 1, 5, 0},
{1, 3, 1, 5, 1},
{1, 4, 1, 6, 1},
{1, 5, 1, 6, 1},
{1, 6, 1, 11, 13},
{1, 7, 1, 12, 13},
{1, 8, 1, 12, 2},
{1, 9, 1, 13, 13},
{1, 10, 1, 13, 2},
{1, 11, 1, 12, 1},
{1, 12, 1, 14, 13},
{1, 13, 1, 14, 2},
{1, 14, 1, 15, 3},
{1, 15, 1, 16, 4},
{1, 16, 1, 17, 4},
{1, 17, 1, 19, 14},
{1, 18, 1, 23, 15},
{1, 19, 1, 24, 15},
{1, 20, 1, 24, 7},
{1, 21, 1, 25, 15},
{1, 22, 1, 25, 7},
{1, 23, 1, 24, 6},
{1, 24, 1, 26, 16},
{1, 25, 1, 26, 7},
{1, 26, 1, 27, 8},
{1, 27, 1, 28, 9},
{1, 28, 1, 29, 9},
{1, 30, 1, 31, 10},
{1, 31, 1, 32, 11},
{1, 32, 1, 33, 11},
{1, 33, 0, 33, 12},
};
const auto baseline = trace.live.size();
for (const auto& test : cases) {
Value value{}; _ZN3sce4Json5ValueC1Ev(&value); _ZN3sce4Json5Value3setEl(&value, 77);
const auto notifications = trace.notifications;
const auto requests = trace.requests.size();
const char input[] = "{\"a\":\"abc\",\"b\":[2]}";
trace.budget = test.budget; trace.failOnce = test.once;
const auto status = static_cast<unsigned>(_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&value, input, sizeof(input) - 1));
trace.budget = -1; trace.failOnce = false;
const auto actual = NestedObjectFailureState(value);
const bool matches = status == (test.notifications ? 0x80848102u : 0u) && actual == states[test.state] && trace.notifications - notifications == test.notifications && trace.requests.size() - requests == test.requests;
if (!matches) std::fprintf(stderr, "Object parse once=%d budget=%d expected=%s actual=%s status=%x requests=%zu notifications=%u\n", test.once, test.budget, states[test.state], actual.c_str(), status, trace.requests.size() - requests, trace.notifications - notifications);
Require(matches, "Object parser failures must retain reference partial members, ownership and allocation accounting");
_ZN3sce4Json5ValueD1Ev(&value);
Require(trace.live.size() == baseline, "Object parser failures must reclaim every partial key, member and metadata allocation");
}
}
static void CheckNestedFailureCases(ObjectAllocationTrace& trace) {
static const char* const states[]{
"7po1[z=3p:99;]",
"7po0[]",
"7po1[~=0-;]",
"7po1[=0-;]",
"7po1[a=0-;]",
"7po1[a=5p:;]",
"7po1[a=5p:abc;]",
"7po2[a=5p:abc;~=0-;]",
"7po2[a=5p:abc;=0-;]",
"7po2[a=5p:abc;b=0-;]",
"7po2[a=5p:abc;b=7-o0[];]",
"7po2[a=5p:abc;b=7po0[];]",
"7po2[a=5p:abc;b=7po1[~=0-;];]",
"7po2[a=5p:abc;b=7po1[=0-;];]",
"7po2[a=5p:abc;b=7po1[x=0-;];]",
"7po2[a=5p:abc;b=7po1[x=5p:;];]",
"7po2[a=5p:abc;b=7po1[x=5p:def;];]",
"7po3[a=5p:abc;b=7po1[x=5p:def;];~=0-;]",
"7po3[a=5p:abc;b=7po1[x=5p:def;];=0-;]",
"7po3[a=5p:abc;b=7po1[x=5p:def;];c=0-;]",
"7po3[a=5p:abc;b=7po1[x=5p:def;];c=6-o0[?];]",
"7po3[a=5p:abc;b=7po1[x=5p:def;];c=6-o0[];]",
"7po3[a=5p:abc;b=7po1[x=5p:def;];c=6po0[];]",
"7po3[a=5p:abc;b=7po1[x=5p:def;];c=6po1[3p:42;];]",
"7po3[~=5p:abc;b=7po1[x=5p:def;];c=6po1[3p:42;];]",
"7po3[=5p:abc;b=7po1[x=5p:def;];c=6po1[3p:42;];]",
"7po3[a=5-:;b=7po1[x=5p:def;];c=6po1[3p:42;];]",
"7po3[~=5-:;b=7po1[x=5p:def;];c=6po1[3p:42;];]",
"7po3[=5-:;b=7po1[x=5p:def;];c=6po1[3p:42;];]",
"7po3[a=0-;b=7po1[x=5p:def;];c=6po1[3p:42;];]",
"7po2[b=7po1[x=5p:def;];c=6po1[3p:42;];]",
"7po3[a=5p:;b=7po1[x=5p:def;];c=6po1[3p:42;];]",
"7po3[a=5p:abc;~=7po1[x=5p:def;];c=6po1[3p:42;];]",
"7po3[a=5p:abc;=7po1[x=5p:def;];c=6po1[3p:42;];]",
"7po3[b=7-o0[];a=5p:abc;c=6po1[3p:42;];]",
"7po3[a=5p:abc;~=7-o0[];c=6po1[3p:42;];]",
"7po3[a=5p:abc;=7-o0[];c=6po1[3p:42;];]",
"7po3[a=5p:abc;b=0-;c=6po1[3p:42;];]",
"7po3[a=5p:abc;b=7-o0[];c=6po1[3p:42;];]",
"7po2[a=5p:abc;c=6po1[3p:42;];]",
"7po3[a=5p:abc;b=7po0[];c=6po1[3p:42;];]",
"7po3[a=5p:abc;b=7po1[~=5p:def;];c=6po1[3p:42;];]",
"7po3[a=5p:abc;b=7po1[=5p:def;];c=6po1[3p:42;];]",
"7po3[a=5p:abc;b=7po1[x=5-:;];c=6po1[3p:42;];]",
"7po3[a=5p:abc;b=7po1[~=5-:;];c=6po1[3p:42;];]",
"7po3[a=5p:abc;b=7po1[=5-:;];c=6po1[3p:42;];]",
"7po3[a=5p:abc;b=7po1[x=0-;];c=6po1[3p:42;];]",
"7po3[a=5p:abc;b=7po1[x=5p:;];c=6po1[3p:42;];]",
"7po3[a=5p:abc;b=7po1[x=5p:def;];~=6po1[3p:42;];]",
"7po3[a=5p:abc;b=7po1[x=5p:def;];=6po1[3p:42;];]",
"7po3[c=6-o0[];a=5p:abc;b=7po1[x=5p:def;];]",
"7po3[a=5p:abc;b=7po1[x=5p:def;];~=6-o0[];]",
"7po3[a=5p:abc;b=7po1[x=5p:def;];=6-o0[];]",
"7p?",
"7p!0[?]",
"7p!0[]",
"7p!3[~=0-;]",
"7p!3[=0-;]",
"7p!3[b=0-;]",
"7p!3[b=7-o0[];]",
"7p!3[b=7-o1[~=0-;];]",
"7p!3[b=7-o1[=0-;];]",
"7p!3[b=7-o1[x=0-;];]",
"7p!3[b=7-o1[x=5p:;];]",
"7p!3[b=7-o1[x=5p:def;];]",
"7p!3[~=0-;b=7-o1[x=5p:def;];]",
"7p!3[=0-;b=7-o1[x=5p:def;];]",
"7p!3[a=0-;b=7-o1[x=5p:def;];]",
"7p!3[a=5-:;b=7-o1[x=5p:def;];]",
"7p!3[a=5-:abc;b=7-o1[x=5p:def;];]",
"7p!3[a=5-:abc;b=7-o1[x=5p:def;];~=0-;]",
"7p!3[a=5-:abc;b=7-o1[x=5p:def;];=0-;]",
"7p!3[a=5-:abc;b=7-o1[x=5p:def;];c=0-;]",
"7p!3[a=5-:abc;b=7-o1[x=5p:def;];c=6-o0[?];]",
"7p!3[a=5-:abc;b=7-o1[x=5p:def;];c=6-o0[];]",
"7p!3[a=5-:abc;b=7-o1[x=5p:def;];c=6-o1[3p:42;];]",
"7p!3[a=5-:abc;~=7-o1[x=5p:def;];c=6-o1[3p:42;];]",
"7p!3[a=5-:abc;=7-o1[x=5p:def;];c=6-o1[3p:42;];]",
"7p!3[a=5-:abc;b=0-;c=6-o1[3p:42;];]",
"7p!3[a=5-:abc;b=7-o0[];c=6-o1[3p:42;];]",
"7p!3[a=5-:abc;b=7-o1[~=5p:def;];c=6-o1[3p:42;];]",
"7p!3[a=5-:abc;b=7-o1[=5p:def;];c=6-o1[3p:42;];]",
"7p!3[a=5-:abc;b=7-o1[x=5-:;];c=6-o1[3p:42;];]",
"7p!3[a=5-:abc;b=7-o1[~=5-:;];c=6-o1[3p:42;];]",
"7p!3[a=5-:abc;b=7-o1[=5-:;];c=6-o1[3p:42;];]",
"7p!3[a=5-:abc;b=7-o1[x=0-;];c=6-o1[3p:42;];]",
"7p!3[a=5-:abc;b=7-o1[x=5p:;];c=6-o1[3p:42;];]",
"7p!3[b=7-o1[x=5p:def;];c=6-o1[3p:42;];]",
"7p!3[~=5-:abc;b=7-o1[x=5p:def;];c=6-o1[3p:42;];]",
"7p!3[=5-:abc;b=7-o1[x=5p:def;];c=6-o1[3p:42;];]",
"7p!3[a=0-;b=7-o1[x=5p:def;];c=6-o1[3p:42;];]",
"7p!3[a=5-:;b=7-o1[x=5p:def;];c=6-o1[3p:42;];]",
"7p!3[a=5-:abc;b=7-o1[x=5p:def;];~=6-o1[3p:42;];]",
"7p!3[a=5-:abc;b=7-o1[x=5p:def;];=6-o1[3p:42;];]",
};
struct Case { bool constructor; bool once; int budget; unsigned notifications; std::size_t requests; unsigned state; };
const Case cases[]{
{0, 0, 0, 1, 1, 0},
{0, 0, 1, 1, 2, 0},
{0, 0, 2, 12, 14, 1},
{0, 0, 3, 12, 15, 1},
{0, 0, 4, 12, 16, 1},
{0, 0, 5, 13, 18, 1},
{0, 0, 6, 12, 18, 1},
{0, 0, 7, 13, 20, 1},
{0, 0, 8, 12, 20, 1},
{0, 0, 9, 12, 21, 1},
{0, 0, 10, 12, 22, 1},
{0, 0, 11, 12, 23, 1},
{0, 0, 12, 11, 23, 1},
{0, 0, 13, 11, 24, 1},
{0, 0, 14, 10, 24, 1},
{0, 0, 15, 10, 25, 1},
{0, 0, 16, 9, 25, 1},
{0, 0, 17, 9, 26, 2},
{0, 0, 18, 10, 28, 2},
{0, 0, 19, 10, 29, 3},
{0, 0, 20, 9, 29, 4},
{0, 0, 21, 9, 30, 4},
{0, 0, 22, 9, 31, 5},
{0, 0, 23, 8, 31, 6},
{0, 0, 24, 8, 32, 6},
{0, 0, 25, 8, 33, 6},
{0, 0, 26, 8, 34, 6},
{0, 0, 27, 9, 36, 6},
{0, 0, 28, 8, 36, 6},
{0, 0, 29, 9, 38, 6},
{0, 0, 30, 8, 38, 6},
{0, 0, 31, 8, 39, 6},
{0, 0, 32, 8, 40, 6},
{0, 0, 33, 9, 42, 6},
{0, 0, 34, 9, 43, 6},
{0, 0, 35, 8, 43, 6},
{0, 0, 36, 8, 44, 6},
{0, 0, 37, 7, 44, 6},
{0, 0, 38, 7, 45, 6},
{0, 0, 39, 6, 45, 6},
{0, 0, 40, 6, 46, 6},
{0, 0, 41, 6, 47, 6},
{0, 0, 42, 6, 48, 6},
{0, 0, 43, 6, 49, 6},
{0, 0, 44, 5, 49, 6},
{0, 0, 45, 7, 52, 7},
{0, 0, 46, 6, 52, 7},
{0, 0, 47, 6, 53, 8},
{0, 0, 48, 5, 53, 9},
{0, 0, 49, 5, 54, 9},
{0, 0, 50, 5, 55, 9},
{0, 0, 51, 5, 56, 10},
{0, 0, 52, 5, 57, 10},
{0, 0, 53, 5, 58, 11},
{0, 0, 54, 5, 59, 11},
{0, 0, 55, 8, 63, 11},
{0, 0, 56, 8, 64, 11},
{0, 0, 57, 8, 65, 11},
{0, 0, 58, 9, 67, 11},
{0, 0, 59, 8, 67, 11},
{0, 0, 60, 9, 69, 11},
{0, 0, 61, 8, 69, 11},
{0, 0, 62, 8, 70, 11},
{0, 0, 63, 8, 71, 11},
{0, 0, 64, 8, 72, 11},
{0, 0, 65, 7, 72, 11},
{0, 0, 66, 7, 73, 11},
{0, 0, 67, 6, 73, 11},
{0, 0, 68, 6, 74, 11},
{0, 0, 69, 5, 74, 11},
{0, 0, 70, 7, 77, 12},
{0, 0, 71, 6, 77, 12},
{0, 0, 72, 6, 78, 13},
{0, 0, 73, 5, 78, 14},
{0, 0, 74, 5, 79, 14},
{0, 0, 75, 5, 80, 15},
{0, 0, 76, 4, 80, 16},
{0, 0, 77, 4, 81, 16},
{0, 0, 78, 5, 83, 16},
{0, 0, 79, 4, 83, 16},
{0, 0, 80, 5, 85, 16},
{0, 0, 81, 4, 85, 16},
{0, 0, 82, 5, 87, 16},
{0, 0, 83, 4, 87, 16},
{0, 0, 84, 4, 88, 16},
{0, 0, 85, 6, 91, 16},
{0, 0, 86, 5, 91, 16},
{0, 0, 87, 5, 92, 16},
{0, 0, 88, 4, 92, 16},
{0, 0, 89, 4, 93, 16},
{0, 0, 90, 3, 93, 16},
{0, 0, 91, 3, 94, 16},
{0, 0, 92, 2, 94, 16},
{0, 0, 93, 2, 95, 16},
{0, 0, 94, 3, 97, 16},
{0, 0, 95, 2, 97, 16},
{0, 0, 96, 2, 98, 16},
{0, 0, 97, 1, 98, 16},
{0, 0, 98, 3, 101, 17},
{0, 0, 99, 2, 101, 17},
{0, 0, 100, 2, 102, 18},
{0, 0, 101, 1, 102, 19},
{0, 0, 102, 1, 103, 19},
{0, 0, 103, 2, 105, 20},
{0, 0, 104, 1, 105, 21},
{0, 0, 105, 1, 106, 21},
{0, 0, 106, 1, 107, 22},
{0, 0, 107, 1, 108, 22},
{0, 0, 108, 1, 109, 22},
{0, 0, 109, 0, 109, 23},
{0, 1, 0, 1, 1, 0},
{0, 1, 1, 1, 2, 0},
{0, 1, 2, 1, 104, 23},
{0, 1, 3, 1, 105, 23},
{0, 1, 4, 1, 102, 24},
{0, 1, 5, 1, 106, 25},
{0, 1, 6, 1, 104, 24},
{0, 1, 7, 1, 107, 25},
{0, 1, 8, 1, 106, 23},
{0, 1, 9, 1, 107, 23},
{0, 1, 10, 1, 106, 26},
{0, 1, 11, 1, 107, 26},
{0, 1, 12, 1, 105, 27},
{0, 1, 13, 1, 107, 28},
{0, 1, 14, 1, 105, 29},
{0, 1, 15, 1, 106, 29},
{0, 1, 16, 1, 103, 30},
{0, 1, 17, 1, 108, 26},
{0, 1, 18, 1, 107, 27},
{0, 1, 19, 1, 108, 28},
{0, 1, 20, 1, 107, 29},
{0, 1, 21, 1, 108, 29},
{0, 1, 22, 1, 109, 31},
{0, 1, 23, 1, 95, 23},
{0, 1, 24, 1, 96, 23},
{0, 1, 25, 1, 97, 23},
{0, 1, 26, 1, 102, 32},
{0, 1, 27, 1, 106, 33},
{0, 1, 28, 1, 104, 32},
{0, 1, 29, 1, 107, 33},
{0, 1, 30, 1, 98, 23},
{0, 1, 31, 1, 99, 23},
{0, 1, 32, 1, 100, 23},
{0, 1, 33, 1, 108, 23},
{0, 1, 34, 1, 109, 23},
{0, 1, 35, 1, 84, 34},
{0, 1, 36, 1, 85, 34},
{0, 1, 37, 1, 83, 35},
{0, 1, 38, 1, 85, 36},
{0, 1, 39, 1, 77, 37},
{0, 1, 40, 1, 78, 37},
{0, 1, 41, 1, 79, 37},
{0, 1, 42, 1, 85, 38},
{0, 1, 43, 1, 86, 38},
{0, 1, 44, 1, 78, 39},
{0, 1, 45, 1, 86, 38},
{0, 1, 46, 1, 85, 35},
{0, 1, 47, 1, 86, 36},
{0, 1, 48, 1, 82, 37},
{0, 1, 49, 1, 83, 37},
{0, 1, 50, 1, 84, 37},
{0, 1, 51, 1, 85, 38},
{0, 1, 52, 1, 86, 38},
{0, 1, 53, 1, 87, 40},
{0, 1, 54, 1, 88, 40},
{0, 1, 55, 1, 104, 23},
{0, 1, 56, 1, 105, 23},
{0, 1, 57, 1, 102, 41},
{0, 1, 58, 1, 106, 42},
{0, 1, 59, 1, 104, 41},
{0, 1, 60, 1, 107, 42},
{0, 1, 61, 1, 106, 23},
{0, 1, 62, 1, 107, 23},
{0, 1, 63, 1, 106, 43},
{0, 1, 64, 1, 107, 43},
{0, 1, 65, 1, 105, 44},
{0, 1, 66, 1, 107, 45},
{0, 1, 67, 1, 105, 46},
{0, 1, 68, 1, 106, 46},
{0, 1, 69, 1, 103, 40},
{0, 1, 70, 1, 108, 43},
{0, 1, 71, 1, 107, 44},
{0, 1, 72, 1, 108, 45},
{0, 1, 73, 1, 107, 46},
{0, 1, 74, 1, 108, 46},
{0, 1, 75, 1, 109, 47},
{0, 1, 76, 1, 95, 23},
{0, 1, 77, 1, 96, 23},
{0, 1, 78, 1, 109, 23},
{0, 1, 79, 1, 102, 48},
{0, 1, 80, 1, 106, 49},
{0, 1, 81, 1, 104, 48},
{0, 1, 82, 1, 107, 49},
{0, 1, 83, 1, 98, 23},
{0, 1, 84, 1, 99, 23},
{0, 1, 85, 1, 109, 23},
{0, 1, 86, 1, 108, 23},
{0, 1, 87, 1, 109, 23},
{0, 1, 88, 1, 104, 50},
{0, 1, 89, 1, 105, 50},
{0, 1, 90, 1, 103, 51},
{0, 1, 91, 1, 105, 52},
{0, 1, 92, 1, 97, 19},
{0, 1, 93, 1, 98, 19},
{0, 1, 94, 1, 106, 21},
{0, 1, 95, 1, 105, 21},
{0, 1, 96, 1, 106, 21},
{0, 1, 97, 1, 98, 16},
{0, 1, 98, 1, 106, 21},
{0, 1, 99, 1, 105, 51},
{0, 1, 100, 1, 106, 52},
{0, 1, 101, 1, 102, 19},
{0, 1, 102, 1, 103, 19},
{0, 1, 103, 1, 106, 21},
{0, 1, 104, 1, 105, 21},
{0, 1, 105, 1, 106, 21},
{0, 1, 106, 1, 107, 22},
{0, 1, 107, 1, 108, 22},
{0, 1, 108, 1, 109, 22},
{0, 1, 109, 0, 109, 23},
{1, 0, 0, 1, 1, 53},
{1, 0, 1, 2, 3, 54},
{1, 0, 2, 1, 3, 54},
{1, 0, 3, 1, 4, 55},
{1, 0, 4, 5, 9, 56},
{1, 0, 5, 4, 9, 56},
{1, 0, 6, 4, 10, 57},
{1, 0, 7, 3, 10, 58},
{1, 0, 8, 3, 11, 58},
{1, 0, 9, 3, 12, 58},
{1, 0, 10, 3, 13, 59},
{1, 0, 11, 3, 14, 59},
{1, 0, 12, 6, 18, 59},
{1, 0, 13, 6, 19, 59},
{1, 0, 14, 6, 20, 59},
{1, 0, 15, 7, 22, 59},
{1, 0, 16, 6, 22, 59},
{1, 0, 17, 7, 24, 59},
{1, 0, 18, 6, 24, 59},
{1, 0, 19, 6, 25, 59},
{1, 0, 20, 6, 26, 59},
{1, 0, 21, 6, 27, 59},
{1, 0, 22, 5, 27, 59},
{1, 0, 23, 5, 28, 59},
{1, 0, 24, 4, 28, 59},
{1, 0, 25, 4, 29, 59},
{1, 0, 26, 3, 29, 59},
{1, 0, 27, 5, 32, 60},
{1, 0, 28, 4, 32, 60},
{1, 0, 29, 4, 33, 61},
{1, 0, 30, 3, 33, 62},
{1, 0, 31, 3, 34, 62},
{1, 0, 32, 3, 35, 63},
{1, 0, 33, 2, 35, 64},
{1, 0, 34, 4, 38, 65},
{1, 0, 35, 3, 38, 65},
{1, 0, 36, 3, 39, 66},
{1, 0, 37, 2, 39, 67},
{1, 0, 38, 2, 40, 67},
{1, 0, 39, 2, 41, 68},
{1, 0, 40, 1, 41, 69},
{1, 0, 41, 3, 44, 70},
{1, 0, 42, 2, 44, 70},
{1, 0, 43, 2, 45, 71},
{1, 0, 44, 1, 45, 72},
{1, 0, 45, 1, 46, 72},
{1, 0, 46, 2, 48, 73},
{1, 0, 47, 1, 48, 74},
{1, 0, 48, 1, 49, 74},
{1, 0, 49, 1, 50, 74},
{1, 0, 50, 0, 50, 75},
{1, 1, 0, 1, 1, 53},
{1, 1, 1, 1, 50, 75},
{1, 1, 2, 1, 3, 54},
{1, 1, 3, 1, 4, 55},
{1, 1, 4, 1, 50, 75},
{1, 1, 5, 1, 49, 76},
{1, 1, 6, 1, 50, 77},
{1, 1, 7, 1, 25, 78},
{1, 1, 8, 1, 26, 78},
{1, 1, 9, 1, 27, 78},
{1, 1, 10, 1, 28, 79},
{1, 1, 11, 1, 29, 79},
{1, 1, 12, 1, 45, 75},
{1, 1, 13, 1, 46, 75},
{1, 1, 14, 1, 43, 80},
{1, 1, 15, 1, 47, 81},
{1, 1, 16, 1, 45, 80},
{1, 1, 17, 1, 48, 81},
{1, 1, 18, 1, 47, 75},
{1, 1, 19, 1, 48, 75},
{1, 1, 20, 1, 47, 82},
{1, 1, 21, 1, 48, 82},
{1, 1, 22, 1, 46, 83},
{1, 1, 23, 1, 48, 84},
{1, 1, 24, 1, 46, 85},
{1, 1, 25, 1, 47, 85},
{1, 1, 26, 1, 44, 79},
{1, 1, 27, 1, 49, 82},
{1, 1, 28, 1, 48, 83},
{1, 1, 29, 1, 49, 84},
{1, 1, 30, 1, 48, 85},
{1, 1, 31, 1, 49, 85},
{1, 1, 32, 1, 50, 86},
{1, 1, 33, 1, 44, 87},
{1, 1, 34, 1, 50, 75},
{1, 1, 35, 1, 49, 88},
{1, 1, 36, 1, 50, 89},
{1, 1, 37, 1, 48, 90},
{1, 1, 38, 1, 49, 90},
{1, 1, 39, 1, 50, 91},
{1, 1, 40, 1, 41, 69},
{1, 1, 41, 1, 50, 75},
{1, 1, 42, 1, 49, 92},
{1, 1, 43, 1, 50, 93},
{1, 1, 44, 1, 45, 72},
{1, 1, 45, 1, 46, 72},
{1, 1, 46, 1, 50, 75},
{1, 1, 47, 1, 48, 74},
{1, 1, 48, 1, 49, 74},
{1, 1, 49, 1, 50, 74},
{1, 1, 50, 0, 50, 75},
};
const auto baseline = trace.live.size();
for (const auto& test : cases) {
Value source{}, destination{};
_ZN3sce4Json5ValueC1Ev(&source); _ZN3sce4Json5ValueC1Ev(&destination);
const char input[] = "{\"a\":\"abc\",\"b\":{\"x\":\"def\"},\"c\":[42]}";
Require(_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&source, input, sizeof(input) - 1) == 0, "Prepare nested failure source");
Require(_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&destination, "{\"z\":99}", 8) == 0, "Prepare nested failure destination");
const auto sourceState = NestedObjectFailureState(source);
Object copy{};
auto* sourceObject = reinterpret_cast<const Object*>(source.payload);
const auto notifications = trace.notifications;
const auto requests = trace.requests.size();
trace.budget = test.budget; trace.failOnce = test.once;
if (test.constructor) _ZN3sce4Json6ObjectC1ERKS1_(&copy, sourceObject);
else _ZN3sce4Json6ObjectaSERKS1_(reinterpret_cast<Object*>(destination.payload), sourceObject);
trace.budget = -1; trace.failOnce = false;
std::string actual;
if (test.constructor) {
Value proxy{}; proxy.type = static_cast<ValueType>(7); proxy.payload = reinterpret_cast<std::uintptr_t>(&copy);
actual = NestedObjectFailureState(proxy);
} else actual = NestedObjectFailureState(destination);
const bool matches = actual == states[test.state] && trace.notifications - notifications == test.notifications && trace.requests.size() - requests == test.requests;
if (!matches) std::fprintf(stderr, "Nested object constructor=%d once=%d budget=%d expected=%s actual=%s requests=%zu notifications=%u\n", test.constructor, test.once, test.budget, states[test.state], actual.c_str(), trace.requests.size() - requests, trace.notifications - notifications);
Require(matches, "Nested object failure must retain the reference state, ownership and allocation accounting");
Require(NestedObjectFailureState(source) == sourceState, "Nested allocation failures must preserve source contents and ownership");
if (test.constructor) _ZN3sce4Json6ObjectD1Ev(&copy);
_ZN3sce4Json5ValueD1Ev(&destination); _ZN3sce4Json5ValueD1Ev(&source);
Require(trace.live.size() == baseline, "Nested object failure must reclaim every admitted resource");
}
}
static void CheckAssignments(ObjectAllocationTrace& trace) {
struct Case { bool once; int budget; std::size_t count; unsigned notifications; const char* contents; };
const Case cases[]{
{0, -1, 2, 0, "a:2:11;c:2:33;"},
{0, 0, 1, 1, "z:2:99;"},
{0, 1, 1, 1, "z:2:99;"},
{0, 2, 0, 6, ""},
{0, 3, 0, 7, ""},
{0, 4, 0, 6, ""},
{0, 5, 0, 7, ""},
{0, 6, 0, 6, ""},
{0, 7, 0, 6, ""},
{0, 8, 0, 5, ""},
{0, 9, 0, 5, ""},
{0, 10, 0, 4, ""},
{0, 11, 1, 4, "~:2:0;"},
{0, 12, 1, 4, "~:2:0;"},
{0, 13, 1, 4, ":2:0;"},
{0, 14, 1, 3, "a:2:11;"},
{0, 15, 1, 4, "a:2:11;"},
{0, 16, 1, 3, "a:2:11;"},
{0, 17, 1, 4, "a:2:11;"},
{0, 18, 1, 3, "a:2:11;"},
{0, 19, 1, 3, "a:2:11;"},
{0, 20, 1, 2, "a:2:11;"},
{0, 21, 1, 2, "a:2:11;"},
{0, 22, 1, 1, "a:2:11;"},
{0, 23, 2, 2, "a:2:11;~:2:0;"},
{0, 24, 2, 1, "a:2:11;~:2:0;"},
{0, 25, 2, 1, "a:2:11;:2:0;"},
{0, 26, 2, 0, "a:2:11;c:2:33;"},
{1, -1, 2, 0, "a:2:11;c:2:33;"},
{1, 0, 1, 1, "z:2:99;"},
{1, 1, 1, 1, "z:2:99;"},
{1, 2, 2, 1, "~:2:11;c:2:33;"},
{1, 3, 2, 1, ":2:11;c:2:33;"},
{1, 4, 2, 1, "~:2:11;c:2:33;"},
{1, 5, 2, 1, ":2:11;c:2:33;"},
{1, 6, 2, 1, "a:2:0;c:2:33;"},
{1, 7, 2, 1, "a:2:0;c:2:33;"},
{1, 8, 2, 1, "~:2:0;c:2:33;"},
{1, 9, 2, 1, ":2:0;c:2:33;"},
{1, 10, 1, 1, "c:2:33;"},
{1, 11, 2, 1, "a:2:0;c:2:33;"},
{1, 12, 2, 1, "~:2:0;c:2:33;"},
{1, 13, 2, 1, ":2:0;c:2:33;"},
{1, 14, 2, 1, "a:2:11;~:2:33;"},
{1, 15, 2, 1, "a:2:11;:2:33;"},
{1, 16, 2, 1, "a:2:11;~:2:33;"},
{1, 17, 2, 1, "a:2:11;:2:33;"},
{1, 18, 2, 1, "c:2:0;a:2:11;"},
{1, 19, 2, 1, "c:2:0;a:2:11;"},
{1, 20, 2, 1, "a:2:11;~:2:0;"},
{1, 21, 2, 1, "a:2:11;:2:0;"},
{1, 22, 1, 1, "a:2:11;"},
{1, 23, 2, 1, "a:2:11;c:2:0;"},
{1, 24, 2, 1, "a:2:11;~:2:0;"},
{1, 25, 2, 1, "a:2:11;:2:0;"},
{1, 26, 2, 0, "a:2:11;c:2:33;"},
};
const auto baseline = trace.live.size();
for (const auto& test : cases) {
Object source{}, destination{};
_ZN3sce4Json6ObjectC1Ev(&source); _ZN3sce4Json6ObjectC1Ev(&destination);
_ZN3sce4Json5Value3setEl(Entry(source, "a"), 11);
_ZN3sce4Json5Value3setEl(Entry(source, "c"), 33);
_ZN3sce4Json5Value3setEl(Entry(destination, "z"), 99);
Value owner{};
reinterpret_cast<TreeHeader*>(destination.items)->owner = &owner;
auto* previous = destination.items;
trace.headers.insert(previous);
const auto notifications = trace.notifications;
trace.budget = test.budget; trace.failOnce = test.once;
Require(_ZN3sce4Json6ObjectaSERKS1_(&destination, &source) == &destination, "Object assignment must return its destination");
trace.budget = -1; trace.failOnce = false;
Require((destination.items == previous) == (test.budget == 0 || test.budget == 1), "Only initial replacement allocation failures preserve the old object header");
Require(reinterpret_cast<TreeHeader*>(destination.items)->owner == &owner, "Replacement trees must retain their destination owner");
Require(_ZNK3sce4Json6Object4sizeEv(&destination) == test.count && AssignmentContents(destination) == test.contents, "Assignment failure must retain the reference partial entries and values");
Require(trace.notifications - notifications == test.notifications, "Assignment must report each failed owned allocation");
Require(AssignmentContents(source) == "a:2:11;c:2:33;", "Assignment must preserve the source");
trace.headers.insert(destination.items);
_ZN3sce4Json6ObjectD1Ev(&destination); _ZN3sce4Json6ObjectD1Ev(&source);
Require(trace.live.size() == baseline, "Assignment failure must reclaim temporary and replaced resources");
}
Object object{}; _ZN3sce4Json6ObjectC1Ev(&object);
_ZN3sce4Json5Value3setEl(Entry(object, "a"), 11);
auto* previous = object.items;
trace.headers.insert(previous);
_ZN3sce4Json6ObjectaSERKS1_(&object, &object);
Require(object.items != previous && AssignmentContents(object) == "a:2:11;", "Modern self-assignment must rebuild while preserving values");
trace.headers.insert(object.items);
_ZN3sce4Json6ObjectD1Ev(&object);
Require(trace.live.size() == baseline, "Self-assignment must release its previous tree");
}
int main() {
ObjectAllocationTrace trace; ObjectAllocator allocator;
Parameter parameter{&allocator, &trace, 16384, 2, {}};
std::uint8_t initializer = 0; _ZN3sce4Json11InitializerC1Ev(&initializer);
Require(_ZN3sce4Json11Initializer10initializeEPKNS0_14InitParameter2E(&initializer, reinterpret_cast<const InitParameter2*>(&parameter)) == 0, "Initialize object allocation contract");
const auto baseline = trace.live.size();
for (int budget : {0, 1}) {
Object partial{}; trace.budget = budget; _ZN3sce4Json6ObjectC1Ev(&partial); trace.budget = -1;
Require(!partial.items && _ZNK3sce4Json6Object4sizeEv(&partial) == 0 && trace.live.size() == baseline, "Failed object construction must reclaim partial header ownership");
_ZN3sce4Json6ObjectD1Ev(&partial);
}
Object object{}; _ZN3sce4Json6ObjectC1Ev(&object);
std::map<std::string, Value*> entries;
CheckTree(object, trace, entries);
for (unsigned index = 0; index < 32; ++index) {
char key[3]; std::snprintf(key, sizeof(key), "%02u", index * 13 % 32);
auto* value = Entry(object, key); _ZN3sce4Json5Value3setEl(value, index);
entries.emplace(key, value); CheckTree(object, trace, entries);
}
ObjectIterator current{}, copy{}; _ZNK3sce4Json6Object5beginEv(&current, &object); _ZN3sce4Json6Object8iteratorC1ERKS2_(&copy, &current);
Require(Owned(trace, current.state, 8) && Owned(trace, copy.state, 8) && current.state != copy.state && *reinterpret_cast<void**>(current.state) == *reinterpret_cast<void**>(copy.state), "Object iterator copies must own one independent node pointer");
_ZN3sce4Json6Object8iteratorD1Ev(&copy); _ZN3sce4Json6Object8iteratorD1Ev(&current);
const auto beforeCopies = trace.live.size();
for (int budget = 0; budget <= 10; ++budget) {
Object duplicate{}; trace.budget = budget; _ZN3sce4Json6ObjectC1ERKS1_(&duplicate, &object); trace.budget = -1;
Require(_ZNK3sce4Json6Object4sizeEv(&duplicate) == (budget >= 4 ? 32 : 0), "Partial tree copies retain the source count once the root allocation succeeds");
if (duplicate.items) trace.headers.insert(duplicate.items);
_ZN3sce4Json6ObjectD1Ev(&duplicate); Require(trace.live.size() == beforeCopies, "Partial tree copies must release their actual nodes");
}
for (unsigned index = 0; index < 32; ++index) {
char key[3]; std::snprintf(key, sizeof(key), "%02u", index * 7 % 32);
String text{}; _ZN3sce4Json6StringC1EPKc(&text, key);
const auto requests = trace.requests.size();
const auto notifications = trace.notifications;
trace.budget = 0;
_ZN3sce4Json6Object5eraseERKNS0_6StringE(&object, &text);
_ZN3sce4Json6Object5eraseERKNS0_6StringE(&object, &text);
trace.budget = -1;
Require(trace.requests.size() == requests && trace.notifications == notifications, "Existing and missing key erasure must work without allocating or reporting allocation failure");
_ZN3sce4Json6StringD1Ev(&text);
entries.erase(key); CheckTree(object, trace, entries);
}
_ZN3sce4Json6Object5clearEv(&object); _ZN3sce4Json6ObjectD1Ev(&object);
Require(trace.live.size() == baseline, "Tree operations must release all owned resources");
Value null{}; _ZN3sce4Json5ValueC1Ev(&null);
const auto* moduleFallback = _ZNK3sce4Json5ValueixEm(&null, 0);
_ZN3sce4Json5ValueD1Ev(&null);
CheckFailures(trace, moduleFallback);
CheckIteratorFailures(trace);
CheckInsertions(trace);
CheckAssignments(trace);
CheckNestedAssignment(trace);
CheckNestedFailureCases(trace);
CheckParserObjectFailures(trace);
CheckInheritedCollectionErrors(trace);
CheckBinaryKeys();
Require(trace.live.size() == baseline, "Binary-key operations must release their storage");
Require(_ZN3sce4Json11Initializer9terminateEv(&initializer) == 0 && trace.live.empty(), "Terminate object allocation contract");
return 0;
}
Reference in new issue View Git Blame Copy Permalink