mirror of
https://github.com/boykopovar/AnyPS5.git
synced 2026-11-04 13:07:32 +00:00
457 lines
40 KiB
C++
457 lines
40 KiB
C++
#include "prx/libSceJson2/include/Api.hpp"
|
|
#include "prx/libc/include/general/VabiMacros.hpp"
|
|
#include "JsonTestAllocator.hpp"
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <string>
|
|
#include <map>
|
|
#include <vector>
|
|
#include <limits>
|
|
|
|
using namespace SceJson2;
|
|
|
|
struct Parameter { void* allocator; void* context; std::size_t bufferSize; std::int32_t mode; std::uint32_t reserved[3]; };
|
|
using Handler = void (APS5_VABI*)(int, const String*, const std::size_t*, const Value*, const Value*, void*);
|
|
static void Require(bool valid, const char* message) {
|
|
if (!valid) { std::fprintf(stderr, "%s\n", message); std::abort(); }
|
|
}
|
|
struct Context {
|
|
int calls = 0;
|
|
unsigned error = 0;
|
|
std::string key;
|
|
const String* keyPointer = nullptr;
|
|
std::size_t index = 0;
|
|
bool indexed = false;
|
|
const Value* parent = nullptr;
|
|
const Value* value = nullptr;
|
|
bool reenter = false;
|
|
const Value* fallback = nullptr;
|
|
};
|
|
static void APS5_VABI Recover(int error, const String* key, const std::size_t* index,
|
|
const Value* parent, const Value* value, void* context) {
|
|
auto& trace = *static_cast<Context*>(context);
|
|
++trace.calls;
|
|
trace.error = static_cast<unsigned>(error);
|
|
trace.key = key ? _ZNK3sce4Json6String5c_strEv(key) : "";
|
|
trace.keyPointer = key;
|
|
trace.indexed = index != nullptr;
|
|
trace.index = index ? *index : 0;
|
|
trace.parent = parent;
|
|
trace.value = value;
|
|
if (trace.reenter) {
|
|
trace.fallback = _ZNK3sce4Json5ValueixEPKc(value, "retry");
|
|
_ZN3sce4Json5Value3setEl(const_cast<Value*>(trace.fallback), 77);
|
|
}
|
|
}
|
|
static void Event(const Context& trace, int calls, unsigned error, const Value* value, const Value* parent) {
|
|
Require(trace.calls == calls && trace.error == error && trace.value == value && trace.parent == parent,
|
|
"Recovery must receive the exact error, source value, parent and context");
|
|
}
|
|
struct PartialElementTrace {
|
|
std::map<void*, std::size_t> live;
|
|
std::map<void*, unsigned> generations;
|
|
std::vector<std::size_t> requests;
|
|
unsigned nextGeneration = 0;
|
|
int budget = -1;
|
|
unsigned notifications = 0;
|
|
unsigned calls = 0;
|
|
const Value* expectedValue = nullptr;
|
|
const Value* expectedParent = nullptr;
|
|
const Value* expectedFallback = nullptr;
|
|
bool reenter = false;
|
|
bool assignString = false;
|
|
const Value* collectionSource = nullptr;
|
|
bool once = false;
|
|
unsigned expectedError = 0x80848118;
|
|
};
|
|
static void* APS5_VABI AllocatePartialElement(void*, std::size_t size, void* data) {
|
|
auto& trace = *static_cast<PartialElementTrace*>(data); trace.requests.push_back(size);
|
|
if (!trace.budget) { if (trace.once) trace.budget = -1; return nullptr; }
|
|
if (trace.budget > 0) --trace.budget;
|
|
void* memory = std::malloc(size);
|
|
Require(memory && trace.live.emplace(memory, size).second && trace.generations.emplace(memory, ++trace.nextGeneration).second, "Partial metadata requires independent allocation generations");
|
|
std::memset(memory, 0xa5, size); return memory;
|
|
}
|
|
static void APS5_VABI FreePartialElement(void*, void* memory, void* data) {
|
|
if (!memory) return;
|
|
auto& trace = *static_cast<PartialElementTrace*>(data);
|
|
Require(trace.live.erase(memory) == 1 && trace.generations.erase(memory) == 1, "Partial recovery metadata must release through its owning allocator exactly once");
|
|
std::free(memory);
|
|
}
|
|
static void APS5_VABI NotifyPartialElement(void*, int error, std::size_t size, void* data) {
|
|
auto& trace = *static_cast<PartialElementTrace*>(data);
|
|
Require(static_cast<unsigned>(error) == 0x80848102 && trace.requests.back() == size, "Failure notices must identify the rejected metadata allocation");
|
|
++trace.notifications;
|
|
}
|
|
static void APS5_VABI RecoverPartialElement(int error, const String* key, const std::size_t* index, const Value* parent, const Value* value, void* data) {
|
|
auto& trace = *static_cast<PartialElementTrace*>(data); ++trace.calls;
|
|
Require(static_cast<unsigned>(error) == trace.expectedError && !key && index && *index == std::numeric_limits<std::size_t>::max() && value == trace.expectedValue && parent == trace.expectedParent,
|
|
"Partial recovery must preserve error, all index bits, source, immediate parent and context");
|
|
if (trace.reenter || trace.assignString || trace.collectionSource) {
|
|
const auto calls = trace.calls;
|
|
Require(_ZNK3sce4Json5Value8getValueEm(value, *index) == trace.expectedFallback && trace.calls == calls, "Reentry must share the fallback while suppressing recursive callbacks");
|
|
if (trace.collectionSource) {
|
|
if (trace.collectionSource->type == 6) _ZN3sce4Json5Value3setERKNS0_5ArrayE(const_cast<Value*>(trace.expectedFallback), reinterpret_cast<const Array*>(trace.collectionSource->payload));
|
|
else _ZN3sce4Json5Value3setERKNS0_6ObjectE(const_cast<Value*>(trace.expectedFallback), reinterpret_cast<const Object*>(trace.collectionSource->payload));
|
|
} else if (trace.assignString) _ZN3sce4Json5Value3setEPKc(const_cast<Value*>(trace.expectedFallback), "recovery");
|
|
else _ZN3sce4Json5Value3setEl(const_cast<Value*>(trace.expectedFallback), 77);
|
|
}
|
|
}
|
|
static void* const PartialElementTable[]{nullptr, nullptr, reinterpret_cast<void*>(AllocatePartialElement), reinterpret_cast<void*>(FreePartialElement), reinterpret_cast<void*>(NotifyPartialElement)};
|
|
struct PartialElementAllocator { void* const* table = PartialElementTable; };
|
|
static void CheckPartialElementFallbacks() {
|
|
for (unsigned budget = 0; budget <= 3; ++budget) for (bool reenter : {false, true}) {
|
|
PartialElementTrace trace; PartialElementAllocator allocator; Parameter parameter{&allocator, &trace, 16384, 2, {}};
|
|
std::uint8_t owner = 0; _ZN3sce4Json11InitializerC1Ev(&owner);
|
|
Require(_ZN3sce4Json11Initializer10initializeEPKNS0_14InitParameter2E(&owner, reinterpret_cast<const InitParameter2*>(¶meter)) == 0, "Initialize partial element recovery");
|
|
Value root{}; _ZN3sce4Json5ValueC1Ev(&root);
|
|
const auto* moduleFallback = _ZNK3sce4Json5Value8getValueEm(&root, std::numeric_limits<std::size_t>::max());
|
|
Require(moduleFallback && trace.live.at(const_cast<Value*>(moduleFallback)) == 32, "Initial recovery must expose the initialized module fallback");
|
|
const auto requests = trace.requests.size(); trace.budget = static_cast<int>(budget);
|
|
const int status = _ZN3sce4Json5Value30setElementAccessFailureHandlerEPFviPKNS0_6StringEPKmPKS1_S8_PvES9_(&root, RecoverPartialElement, &trace);
|
|
std::vector<std::size_t> expected{72}; if (budget) expected.push_back(32); if (budget >= 2) expected.push_back(16);
|
|
Require(status == (budget < 3 ? static_cast<int>(0x80848102) : 0) && trace.notifications == unsigned(budget < 3) &&
|
|
std::vector<std::size_t>(trace.requests.begin() + requests, trace.requests.end()) == expected,
|
|
"Partial handler admission must preserve exact auxiliary, fallback and record request order");
|
|
void* originalAuxiliary = root.auxiliary; const auto retryRequests = trace.requests.size(); trace.budget = -1;
|
|
Require(_ZN3sce4Json5Value30setElementAccessFailureHandlerEPFviPKNS0_6StringEPKmPKS1_S8_PvES9_(&root, RecoverPartialElement, &trace) == 0, "Independent registration retry must succeed");
|
|
const auto retryExpected = budget == 0 ? std::vector<std::size_t>{72, 32, 16} : budget < 3 ? std::vector<std::size_t>{16} : std::vector<std::size_t>{};
|
|
Require(std::vector<std::size_t>(trace.requests.begin() + retryRequests, trace.requests.end()) == retryExpected && (!originalAuxiliary || root.auxiliary == originalAuxiliary),
|
|
"Registration retry must reuse admitted metadata without recreating a missing fallback");
|
|
auto* auxiliary = reinterpret_cast<void**>(root.auxiliary); auto* fallback = reinterpret_cast<Value*>(auxiliary[2]);
|
|
Require(bool(fallback) == (budget != 1) && auxiliary[5], "Failed fallback admission must remain missing after successful handler retry");
|
|
const auto auxiliaryGeneration = trace.generations.at(auxiliary), recordGeneration = trace.generations.at(auxiliary[5]);
|
|
const auto fallbackGeneration = fallback ? trace.generations.at(fallback) : 0;
|
|
trace.expectedFallback = fallback ? fallback : moduleFallback; trace.reenter = reenter;
|
|
const auto dispatch = [&](const Value* source, const Value* parent, unsigned calls) {
|
|
trace.expectedValue = source; trace.expectedParent = parent;
|
|
const auto before = trace.requests.size(); const auto notices = trace.notifications;
|
|
trace.budget = 0;
|
|
Require(_ZNK3sce4Json5Value8getValueEm(source, std::numeric_limits<std::size_t>::max()) == trace.expectedFallback && trace.calls == calls &&
|
|
trace.requests.size() == before && trace.notifications == notices,
|
|
"Partial fallback dispatch and callback reentry must preserve identity without allocation or notifications");
|
|
trace.budget = -1;
|
|
Require(!reenter || (trace.expectedFallback->type == 2 && trace.expectedFallback->payload == 77), "Callback mutation must remain visible through the returned fallback");
|
|
};
|
|
dispatch(&root, nullptr, 1);
|
|
Require(_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&root, "[1]", 3) == 0, "Parsing must retain partial root recovery metadata");
|
|
const auto* child = _ZNK3sce4Json5Value8getValueEm(&root, 0);
|
|
Require(child && child->parent == &root, "The parsed child must retain its actual parent"); dispatch(child, &root, 2);
|
|
Require(static_cast<void*>(root.auxiliary) == auxiliary && auxiliary[2] == fallback && trace.generations.at(auxiliary) == auxiliaryGeneration && trace.generations.at(auxiliary[5]) == recordGeneration &&
|
|
(!fallback || (trace.generations.at(fallback) == fallbackGeneration && fallback->parent == &root)) &&
|
|
reinterpret_cast<void**>(auxiliary[5])[0] == reinterpret_cast<void*>(&RecoverPartialElement) && reinterpret_cast<void**>(auxiliary[5])[1] == &trace,
|
|
"Parsing and dispatch must preserve auxiliary, fallback and handler generations, callback ABI and ownership");
|
|
_ZN3sce4Json5ValueD1Ev(&root);
|
|
Require(_ZN3sce4Json11Initializer9terminateEv(&owner) == 0 && !owner && trace.live.empty() && trace.generations.empty(), "Every partial admission and retry must reclaim real allocation ownership");
|
|
}
|
|
}
|
|
|
|
static void CheckElementStringFailures() {
|
|
for (bool missingFallback : {false, true}) for (bool nested : {false, true}) for (unsigned budget = 0; budget <= 5; ++budget) {
|
|
PartialElementTrace trace; PartialElementAllocator allocator; Parameter parameter{&allocator, &trace, 16384, 2, {}};
|
|
std::uint8_t owner = 0; _ZN3sce4Json11InitializerC1Ev(&owner);
|
|
Require(_ZN3sce4Json11Initializer10initializeEPKNS0_14InitParameter2E(&owner, reinterpret_cast<const InitParameter2*>(¶meter)) == 0, "Initialize fallback String failure resources");
|
|
Value root{}; _ZN3sce4Json5ValueC1Ev(&root);
|
|
const auto* moduleFallback = _ZNK3sce4Json5Value8getValueEm(&root, std::numeric_limits<std::size_t>::max());
|
|
if (missingFallback) {
|
|
trace.budget = 1;
|
|
Require(_ZN3sce4Json5Value30setElementAccessFailureHandlerEPFviPKNS0_6StringEPKmPKS1_S8_PvES9_(&root, RecoverPartialElement, &trace) == static_cast<int>(0x80848102), "Prepare a root without its auxiliary fallback");
|
|
trace.budget = -1;
|
|
}
|
|
Require(_ZN3sce4Json5Value30setElementAccessFailureHandlerEPFviPKNS0_6StringEPKmPKS1_S8_PvES9_(&root, RecoverPartialElement, &trace) == 0 &&
|
|
_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&root, "[1]", 3) == 0, "Prepare nested recovery with admitted callback metadata");
|
|
auto* auxiliary = reinterpret_cast<void**>(root.auxiliary);
|
|
auto* fallback = reinterpret_cast<Value*>(auxiliary[2]);
|
|
Require(bool(fallback) != missingFallback, "Parsing must preserve the intended fallback admission state");
|
|
trace.expectedFallback = fallback ? fallback : moduleFallback;
|
|
trace.expectedValue = nested ? _ZNK3sce4Json5Value8getValueEm(&root, 0) : &root;
|
|
trace.expectedParent = nested ? &root : nullptr; trace.expectedError = nested ? 0x80848118 : 0x80848116; trace.assignString = true;
|
|
const auto generations = trace.generations;
|
|
std::map<void*, std::vector<unsigned char>> snapshots;
|
|
for (const auto& [pointer, size] : trace.live) {
|
|
if (pointer == trace.expectedFallback) continue;
|
|
const auto* bytes = reinterpret_cast<const unsigned char*>(pointer); snapshots.emplace(pointer, std::vector<unsigned char>{bytes, bytes + size});
|
|
}
|
|
const auto requests = trace.requests.size(); const auto notices = trace.notifications;
|
|
trace.budget = static_cast<int>(budget);
|
|
Require(_ZNK3sce4Json5Value8getValueEm(trace.expectedValue, std::numeric_limits<std::size_t>::max()) == trace.expectedFallback && trace.calls == 1,
|
|
"Callback String allocation failure must preserve the exact returned fallback and suppress reentry");
|
|
std::vector<std::size_t> expected{24}; if (budget) { expected.push_back(9); expected.push_back(8); } if (budget >= 3) expected.push_back(24); if (budget >= 4) expected.push_back(9);
|
|
Require(std::vector<std::size_t>(trace.requests.begin() + requests, trace.requests.end()) == expected && trace.notifications == notices + (budget == 1 ? 2u : unsigned(budget < 5)),
|
|
"Callback String assignment must preserve temporary and destination handle/header/character request order and actual failure notices");
|
|
Require(trace.expectedFallback->type == (budget < 4 ? 0 : 5) && trace.expectedFallback->parent == (missingFallback ? nullptr : &root),
|
|
"Failed String assignment must retain the admitted partial payload and fallback owner");
|
|
if (budget >= 4) Require(std::strcmp(_ZNK3sce4Json6String5c_strEv(reinterpret_cast<const String*>(trace.expectedFallback->payload)), budget == 4 ? "" : "recovery") == 0,
|
|
"Character failure must retain an empty String while successful admission exposes complete text");
|
|
trace.budget = -1; const auto retryRequests = trace.requests.size();
|
|
_ZN3sce4Json5Value3setEPKc(const_cast<Value*>(trace.expectedFallback), "recovery");
|
|
const auto retryExpected = budget < 4 ? std::vector<std::size_t>{24, 9, 8, 24, 9} : std::vector<std::size_t>{24, 9, 9};
|
|
Require(std::vector<std::size_t>(trace.requests.begin() + retryRequests, trace.requests.end()) == retryExpected && trace.expectedFallback->type == 5 &&
|
|
std::strcmp(_ZNK3sce4Json6String5c_strEv(reinterpret_cast<const String*>(trace.expectedFallback->payload)), "recovery") == 0,
|
|
"Independent retry must reuse admitted String storage and complete only missing payload allocations");
|
|
const auto retryGenerations = trace.generations; const auto repeatedRequests = trace.requests.size(); const auto repeatedNotices = trace.notifications;
|
|
trace.budget = 0;
|
|
Require(_ZNK3sce4Json5Value8getValueEm(trace.expectedValue, std::numeric_limits<std::size_t>::max()) == trace.expectedFallback && trace.calls == 2 &&
|
|
trace.generations == retryGenerations && trace.requests.size() == repeatedRequests + 1 && trace.requests.back() == 24 && trace.notifications == repeatedNotices + 1,
|
|
"Recovery must resume after allocation failure and preserve the completed payload when temporary admission fails");
|
|
trace.budget = -1;
|
|
Require(static_cast<void*>(root.auxiliary) == auxiliary && auxiliary[2] == fallback && auxiliary[5], "Payload failure and retry must not replace callback metadata or repair a missing fallback");
|
|
for (const auto& [pointer, generation] : generations) Require(trace.generations.at(pointer) == generation, "Payload recovery must preserve all preexisting allocation identities");
|
|
for (const auto& [pointer, bytes] : snapshots) Require(std::memcmp(pointer, bytes.data(), bytes.size()) == 0, "Payload recovery must preserve source, module and callback-record bytes");
|
|
_ZN3sce4Json5ValueD1Ev(&root);
|
|
Require(_ZN3sce4Json11Initializer9terminateEv(&owner) == 0 && !owner && trace.live.empty() && trace.generations.empty(), "Root and module fallbacks must release their real String payload ownership on teardown");
|
|
}
|
|
}
|
|
|
|
struct ElementListLink { ElementListLink* previous; ElementListLink* next; Value value; };
|
|
struct ElementTreeLink {
|
|
ElementTreeLink* parent; ElementTreeLink* left; ElementTreeLink* right;
|
|
const char* key; unsigned length; unsigned capacity; std::uint64_t reserved;
|
|
void* publicKey; std::uint64_t padding; Value value; unsigned char color; unsigned char nil; unsigned char tail[6];
|
|
};
|
|
static_assert(sizeof(ElementListLink) == 48 && sizeof(ElementTreeLink) == 104);
|
|
static std::string ElementCollectionState(const Value& value, const Value* parent);
|
|
static void ElementTreeState(const ElementTreeLink* node, const Value* owner, std::string& output, unsigned depth = 0) {
|
|
Require(depth < 8, "Fallback tree traversal must remain bounded");
|
|
if (node->nil) return;
|
|
ElementTreeState(node->left, owner, output, depth + 1);
|
|
output += std::string(node->key) + "/" + (node->publicKey ? *reinterpret_cast<const char* const*>(node->publicKey) : "?") + "=" + ElementCollectionState(node->value, owner) + ";";
|
|
ElementTreeState(node->right, owner, output, depth + 1);
|
|
}
|
|
static std::string ElementCollectionState(const Value& value, const Value* parent) {
|
|
std::string output = std::to_string(value.type) + (value.parent == parent ? "p" : value.parent ? "x" : "n");
|
|
if (!value.type) return output;
|
|
if (value.type == 2 || value.type == 3) return output + std::to_string(value.payload);
|
|
Require(value.type == 6 || value.type == 7, "Fallback contents must have their admitted scalar or collection type");
|
|
if (!value.payload) return output + "!";
|
|
auto* words = *reinterpret_cast<const std::uintptr_t* const*>(value.payload);
|
|
if (!words) return output + "?";
|
|
output += words[3] == reinterpret_cast<std::uintptr_t>(&value) ? "o" : "x";
|
|
output += std::to_string(words[1]) + "[";
|
|
if (!words[0]) return output + "missing]";
|
|
if (value.type == 7) {
|
|
auto* head = reinterpret_cast<const ElementTreeLink*>(words[0]); ElementTreeState(head->parent, &value, output);
|
|
} else {
|
|
auto* head = reinterpret_cast<const ElementListLink*>(words[0]); unsigned count = 0;
|
|
for (auto* node = head->next; node != head; node = node->next) {
|
|
Require(++count < 8, "Fallback list traversal must remain bounded"); output += ElementCollectionState(node->value, &value) + ";";
|
|
}
|
|
}
|
|
return output + "]";
|
|
}
|
|
static std::uint64_t ElementRequestOrder(const std::vector<std::size_t>& requests, std::size_t begin) {
|
|
std::uint64_t hash = UINT64_C(14695981039346656037);
|
|
for (auto i = begin; i < requests.size(); ++i) { hash ^= requests[i]; hash *= UINT64_C(1099511628211); }
|
|
return hash;
|
|
}
|
|
struct ElementCollectionCase {
|
|
bool object; bool once; unsigned budget; std::size_t requests; std::uint64_t requestOrder; unsigned notices; const char* state;
|
|
std::size_t retryRequests; std::uint64_t retryRequestOrder; const char* retryState;
|
|
};
|
|
static const ElementCollectionCase ElementCollectionCases[]{
|
|
{0, 0, 0, 1, UINT64_C(12638161911788193143), 1, "0p", 7, UINT64_C(8729915328826252127), "6po2[3p11;3p22;]"},
|
|
{0, 0, 1, 2, UINT64_C(598301484379165397), 1, "0p", 7, UINT64_C(8729915328826252127), "6po2[3p11;3p22;]"},
|
|
{0, 0, 2, 4, UINT64_C(4035778052887317517), 2, "6po0[missing]", 4, UINT64_C(12494627435050714437), "6po2[3p11;3p22;]"},
|
|
{0, 0, 3, 4, UINT64_C(4035778052887317517), 1, "6po0[]", 4, UINT64_C(12494627435050714437), "6po2[3p11;3p22;]"},
|
|
{0, 0, 4, 5, UINT64_C(15412030556972272551), 1, "6po0[]", 4, UINT64_C(12494627435050714437), "6po2[3p11;3p22;]"},
|
|
{0, 0, 5, 7, UINT64_C(8729915328826252127), 2, "6po0[]", 4, UINT64_C(12494627435050714437), "6po2[3p11;3p22;]"},
|
|
{0, 0, 6, 7, UINT64_C(8729915328826252127), 1, "6po1[3p11;]", 4, UINT64_C(12494627435050714437), "6po2[3p11;3p22;]"},
|
|
{0, 0, 7, 7, UINT64_C(8729915328826252127), 0, "6po2[3p11;3p22;]", 4, UINT64_C(12494627435050714437), "6po2[3p11;3p22;]"},
|
|
{0, 1, 0, 1, UINT64_C(12638161911788193143), 1, "0p", 7, UINT64_C(8729915328826252127), "6po2[3p11;3p22;]"},
|
|
{0, 1, 1, 2, UINT64_C(598301484379165397), 1, "0p", 7, UINT64_C(8729915328826252127), "6po2[3p11;3p22;]"},
|
|
{0, 1, 2, 7, UINT64_C(8729915328826252127), 1, "6po2[3p11;3p22;]", 4, UINT64_C(12494627435050714437), "6po2[3p11;3p22;]"},
|
|
{0, 1, 3, 4, UINT64_C(4035778052887317517), 1, "6po0[]", 4, UINT64_C(12494627435050714437), "6po2[3p11;3p22;]"},
|
|
{0, 1, 4, 5, UINT64_C(15412030556972272551), 1, "6po0[]", 4, UINT64_C(12494627435050714437), "6po2[3p11;3p22;]"},
|
|
{0, 1, 5, 7, UINT64_C(8729915328826252127), 1, "6po1[3p22;]", 4, UINT64_C(12494627435050714437), "6po2[3p11;3p22;]"},
|
|
{0, 1, 6, 7, UINT64_C(8729915328826252127), 1, "6po1[3p11;]", 4, UINT64_C(12494627435050714437), "6po2[3p11;3p22;]"},
|
|
{0, 1, 7, 7, UINT64_C(8729915328826252127), 0, "6po2[3p11;3p22;]", 4, UINT64_C(12494627435050714437), "6po2[3p11;3p22;]"},
|
|
{1, 0, 0, 1, UINT64_C(12638161911788193143), 1, "0p", 29, UINT64_C(16556326738605743255), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 1, 2, UINT64_C(598301484379165397), 1, "0p", 29, UINT64_C(16556326738605743255), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 2, 3, UINT64_C(2174132616866993959), 1, "0p", 29, UINT64_C(16556326738605743255), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 3, 4, UINT64_C(3997444679488938213), 1, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 4, 5, UINT64_C(8830793754451562391), 1, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 5, 11, UINT64_C(1847692082414021751), 6, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 6, 13, UINT64_C(11795418786358859533), 7, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 7, 13, UINT64_C(11795418786358859533), 6, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 8, 15, UINT64_C(8198587246079178223), 7, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 9, 15, UINT64_C(8198587246079178223), 6, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 10, 16, UINT64_C(18047407352626022791), 6, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 11, 16, UINT64_C(18047407352626022791), 5, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 12, 17, UINT64_C(72191830074401783), 5, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 13, 17, UINT64_C(72191830074401783), 4, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 14, 18, UINT64_C(8609619750561420695), 4, "7po1[/?=3n0;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 15, 19, UINT64_C(7887639270042689613), 4, "7po1[a/?=3n0;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 16, 20, UINT64_C(15090866843038583229), 4, "7po1[a/=3n0;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 17, 20, UINT64_C(15090866843038583229), 3, "7po1[a/a=3p11;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 18, 22, UINT64_C(16504299194552701231), 4, "7po1[a/a=3p11;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 19, 22, UINT64_C(16504299194552701231), 3, "7po1[a/a=3p11;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 20, 24, UINT64_C(3929529969927096549), 4, "7po1[a/a=3p11;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 21, 24, UINT64_C(3929529969927096549), 3, "7po1[a/a=3p11;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 22, 25, UINT64_C(4075476546177097205), 3, "7po1[a/a=3p11;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 23, 25, UINT64_C(4075476546177097205), 2, "7po1[a/a=3p11;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 24, 26, UINT64_C(7916499978844114973), 2, "7po1[a/a=3p11;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 25, 26, UINT64_C(7916499978844114973), 1, "7po1[a/a=3p11;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 26, 28, UINT64_C(14474737658796973967), 2, "7po2[a/a=3p11;/?=3n0;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 27, 28, UINT64_C(14474737658796973967), 1, "7po2[a/a=3p11;b/?=3n0;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 28, 29, UINT64_C(16556326738605743255), 1, "7po2[a/a=3p11;b/=3n0;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 0, 29, 29, UINT64_C(16556326738605743255), 0, "7po2[a/a=3p11;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 0, 1, UINT64_C(12638161911788193143), 1, "0p", 29, UINT64_C(16556326738605743255), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 1, 2, UINT64_C(598301484379165397), 1, "0p", 29, UINT64_C(16556326738605743255), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 2, 3, UINT64_C(2174132616866993959), 1, "0p", 29, UINT64_C(16556326738605743255), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 3, 4, UINT64_C(3997444679488938213), 1, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 4, 5, UINT64_C(8830793754451562391), 1, "7po0[]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 5, 22, UINT64_C(16085087199939238845), 1, "7po2[a/?=3p11;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 6, 26, UINT64_C(12187800176058535535), 1, "7po2[a/=3p11;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 7, 24, UINT64_C(14200822062155788271), 1, "7po2[a/?=3p11;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 8, 27, UINT64_C(16994698599719519703), 1, "7po2[a/=3p11;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 9, 27, UINT64_C(7401576235132465975), 1, "7po2[/a=3n0;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 10, 28, UINT64_C(11183815068046375183), 1, "7po2[/a=3n0;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 11, 26, UINT64_C(6368825009497694205), 1, "7po2[a/?=3n0;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 12, 28, UINT64_C(9933439070053794599), 1, "7po2[a/=3n0;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 13, 26, UINT64_C(18330066241628227221), 1, "7po1[b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 14, 29, UINT64_C(16556326738605743255), 1, "7po2[/a=3n0;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 15, 28, UINT64_C(9933439070053794599), 1, "7po2[a/?=3n0;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 16, 29, UINT64_C(16556326738605743255), 1, "7po2[a/=3n0;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 17, 22, UINT64_C(235942740017013557), 1, "7po2[a/a=3p11;b/?=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 18, 26, UINT64_C(8706565262351133383), 1, "7po2[a/a=3p11;b/=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 19, 24, UINT64_C(3883726514528165511), 1, "7po2[a/a=3p11;b/?=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 20, 27, UINT64_C(14424272583777125367), 1, "7po2[a/a=3p11;b/=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 21, 27, UINT64_C(9861833381400848727), 1, "7po2[/b=3n0;a/a=3p11;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 22, 28, UINT64_C(14449855710655478887), 1, "7po2[/b=3n0;a/a=3p11;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 23, 26, UINT64_C(7880037974236572341), 1, "7po2[a/a=3p11;b/?=3n0;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 24, 28, UINT64_C(14474737658796973967), 1, "7po2[a/a=3p11;b/=3n0;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 25, 26, UINT64_C(7916499978844114973), 1, "7po1[a/a=3p11;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 26, 29, UINT64_C(16556326738605743255), 1, "7po2[a/a=3p11;/b=3n0;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 27, 28, UINT64_C(14474737658796973967), 1, "7po2[a/a=3p11;b/?=3n0;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 28, 29, UINT64_C(16556326738605743255), 1, "7po2[a/a=3p11;b/=3n0;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
{1, 1, 29, 29, UINT64_C(16556326738605743255), 0, "7po2[a/a=3p11;b/b=3p22;]", 26, UINT64_C(3004510956633589525), "7po2[a/a=3p11;b/b=3p22;]"},
|
|
};
|
|
|
|
static void AssignElementCollection(PartialElementTrace& trace) {
|
|
if (trace.collectionSource->type == 6) _ZN3sce4Json5Value3setERKNS0_5ArrayE(const_cast<Value*>(trace.expectedFallback), reinterpret_cast<const Array*>(trace.collectionSource->payload));
|
|
else _ZN3sce4Json5Value3setERKNS0_6ObjectE(const_cast<Value*>(trace.expectedFallback), reinterpret_cast<const Object*>(trace.collectionSource->payload));
|
|
}
|
|
static void CheckElementCollectionFailures() {
|
|
for (const auto& expected : ElementCollectionCases) for (bool missingFallback : {false, true}) {
|
|
PartialElementTrace trace; PartialElementAllocator allocator; Parameter parameter{&allocator, &trace, 16384, 2, {}};
|
|
std::uint8_t owner = 0; _ZN3sce4Json11InitializerC1Ev(&owner);
|
|
Require(_ZN3sce4Json11Initializer10initializeEPKNS0_14InitParameter2E(&owner, reinterpret_cast<const InitParameter2*>(¶meter)) == 0, "Initialize collection fallback recovery");
|
|
Value root{}, replacement{}; _ZN3sce4Json5ValueC1Ev(&root); _ZN3sce4Json5ValueC1Ev(&replacement);
|
|
const auto* moduleFallback = _ZNK3sce4Json5Value8getValueEm(&root, std::numeric_limits<std::size_t>::max());
|
|
if (missingFallback) {
|
|
trace.budget = 1;
|
|
Require(_ZN3sce4Json5Value30setElementAccessFailureHandlerEPFviPKNS0_6StringEPKmPKS1_S8_PvES9_(&root, RecoverPartialElement, &trace) == static_cast<int>(0x80848102), "Prepare a missing root-owned fallback"); trace.budget = -1;
|
|
}
|
|
Require(_ZN3sce4Json5Value30setElementAccessFailureHandlerEPFviPKNS0_6StringEPKmPKS1_S8_PvES9_(&root, RecoverPartialElement, &trace) == 0 &&
|
|
_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&root, "[1]", 3) == 0, "Prepare nested callback dispatch");
|
|
const char* text = expected.object ? "{\"a\":11,\"b\":22}" : "[11,22]";
|
|
Require(_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&replacement, text, std::strlen(text)) == 0, "Prepare the independent callback replacement source");
|
|
const Value originalSource = replacement;
|
|
auto* auxiliary = reinterpret_cast<void**>(root.auxiliary);
|
|
trace.expectedFallback = auxiliary[2] ? reinterpret_cast<Value*>(auxiliary[2]) : moduleFallback;
|
|
trace.expectedValue = _ZNK3sce4Json5Value8getValueEm(&root, 0); trace.expectedParent = &root; trace.collectionSource = &replacement;
|
|
Require(bool(auxiliary[2]) != missingFallback, "Parsing must retain the intended fallback admission state");
|
|
const Value* fallbackParent = missingFallback ? nullptr : &root;
|
|
const auto generations = trace.generations;
|
|
std::map<void*, std::vector<unsigned char>> snapshots;
|
|
for (const auto& [pointer, size] : trace.live) {
|
|
if (pointer == trace.expectedFallback) continue;
|
|
const auto* bytes = reinterpret_cast<const unsigned char*>(pointer); snapshots.emplace(pointer, std::vector<unsigned char>{bytes, bytes + size});
|
|
}
|
|
const auto requests = trace.requests.size(); const auto notices = trace.notifications;
|
|
trace.budget = static_cast<int>(expected.budget); trace.once = expected.once;
|
|
Require(_ZNK3sce4Json5Value8getValueEm(trace.expectedValue, std::numeric_limits<std::size_t>::max()) == trace.expectedFallback && trace.calls == 1,
|
|
"Callback collection mutation must preserve fallback identity and suppress recursive recovery");
|
|
trace.budget = -1; trace.once = false;
|
|
Require(trace.requests.size() == requests + expected.requests && ElementRequestOrder(trace.requests, requests) == expected.requestOrder && trace.notifications == notices + expected.notices &&
|
|
ElementCollectionState(*trace.expectedFallback, fallbackParent) == expected.state,
|
|
"Fallback collection failures must preserve exact requests/notices, partial values, keys, counts, parent links and header ownership");
|
|
const auto retryRequests = trace.requests.size(); const auto retryNotices = trace.notifications;
|
|
AssignElementCollection(trace);
|
|
Require(trace.requests.size() == retryRequests + expected.retryRequests && ElementRequestOrder(trace.requests, retryRequests) == expected.retryRequestOrder && trace.notifications == retryNotices &&
|
|
ElementCollectionState(*trace.expectedFallback, fallbackParent) == expected.retryState,
|
|
"Independent fallback retry must retain metadata and publish the complete replacement with the reference allocation protocol");
|
|
const auto handle = trace.expectedFallback->payload;
|
|
Require(_ZNK3sce4Json5Value8getValueEm(trace.expectedValue, std::numeric_limits<std::size_t>::max()) == trace.expectedFallback && trace.calls == 2 &&
|
|
trace.expectedFallback->payload == handle && ElementCollectionState(*trace.expectedFallback, fallbackParent) == expected.retryState,
|
|
"Recovery must resume after failed allocation and retain its completed collection handle");
|
|
Require(static_cast<void*>(root.auxiliary) == auxiliary && bool(auxiliary[2]) != missingFallback && reinterpret_cast<void**>(auxiliary[5])[0] == reinterpret_cast<void*>(&RecoverPartialElement) &&
|
|
reinterpret_cast<void**>(auxiliary[5])[1] == &trace && std::memcmp(&replacement, &originalSource, sizeof(replacement)) == 0,
|
|
"Collection recovery must preserve the registered callback, context, source Value and missing-fallback state");
|
|
for (const auto& [pointer, generation] : generations) Require(trace.generations.at(pointer) == generation, "Collection recovery must retain every preexisting allocation generation");
|
|
for (const auto& [pointer, bytes] : snapshots) Require(std::memcmp(pointer, bytes.data(), bytes.size()) == 0, "Collection recovery must preserve source, module and callback metadata bytes");
|
|
_ZN3sce4Json5ValueD1Ev(&replacement); _ZN3sce4Json5ValueD1Ev(&root);
|
|
Require(_ZN3sce4Json11Initializer9terminateEv(&owner) == 0 && !owner && trace.live.empty() && trace.generations.empty(), "All source, partial/retried fallback and module resources must be reclaimed");
|
|
}
|
|
}
|
|
|
|
int main() {
|
|
Value root{};
|
|
_ZN3sce4Json5ValueC1Ev(&root);
|
|
Context trace;
|
|
Require(static_cast<unsigned>(_ZN3sce4Json5Value30setElementAccessFailureHandlerEPFviPKNS0_6StringEPKmPKS1_S8_PvES9_(&root, Recover, &trace)) == 0x80848110,
|
|
"Registration before initialization must report not initialized");
|
|
JsonTest::Allocator allocator;
|
|
Parameter parameter{&allocator, nullptr, 0, 2, {}};
|
|
std::uint8_t initializer = 0;
|
|
_ZN3sce4Json11InitializerC1Ev(&initializer);
|
|
Require(_ZN3sce4Json11Initializer10initializeEPKNS0_14InitParameter2E(&initializer, reinterpret_cast<const InitParameter2*>(¶meter)) == 0, "Initialize element recovery");
|
|
const char text[] = "{\"list\":[1],\"number\":2}";
|
|
Require(_ZN3sce4Json6Parser5parseERNS0_5ValueEPKcm(&root, text, sizeof(text) - 1) == 0, "Parse recovery tree");
|
|
Require(_ZN3sce4Json5Value30setElementAccessFailureHandlerEPFviPKNS0_6StringEPKmPKS1_S8_PvES9_(&root, Recover, &trace) == 0,
|
|
"Register root recovery");
|
|
const auto* list = _ZNK3sce4Json5ValueixEPKc(&root, "list");
|
|
const auto* number = _ZNK3sce4Json5ValueixEPKc(&root, "number");
|
|
Require(trace.calls == 0 && list->parent == &root && number->parent == &root, "Successful lookups must bypass failure recovery");
|
|
const auto* fallback = _ZNK3sce4Json5ValueixEPKc(&root, "missing");
|
|
Event(trace, 1, 0x80848115, &root, nullptr);
|
|
Require(trace.key == "missing" && !trace.indexed && fallback->type == 0 && fallback->parent == &root,
|
|
"A missing object key must return its root-owned fallback value");
|
|
String missing{};
|
|
_ZN3sce4Json6StringC1EPKc(&missing, "missing");
|
|
Require(_ZNK3sce4Json5Value8getValueERKNS0_6StringE(&root, &missing) == fallback,
|
|
"String and C-string lookup must share the root fallback");
|
|
Event(trace, 2, 0x80848115, &root, nullptr);
|
|
Require(trace.keyPointer == &missing, "The String overload must pass the supplied key object");
|
|
_ZNK3sce4Json5Value8getValueERKNS0_6StringE(list, &missing);
|
|
Event(trace, 3, 0x80848117, list, &root);
|
|
Require(trace.key == "missing" && !trace.indexed, "Wrong-type key lookup must pass the key and no index");
|
|
Require(_ZNK3sce4Json5Value8getValueEm(list, 1) == fallback, "Nested refusal must use the same root fallback");
|
|
Event(trace, 4, 0x80848116, list, &root);
|
|
Require(trace.indexed && trace.index == 1 && !trace.keyPointer, "Bounds failure must pass the complete index and no key");
|
|
_ZNK3sce4Json5Value8getValueEm(number, static_cast<std::size_t>(-1));
|
|
Event(trace, 5, 0x80848118, number, &root);
|
|
Require(trace.indexed && trace.index == static_cast<std::size_t>(-1), "Wrong-type numeric lookup must preserve all index bits");
|
|
Require(_ZNK3sce4Json5Value8getValueEm(&root, 0) == list && _ZN3sce4Json5Value10referValueEm(&root, 1) == number && trace.calls == 5,
|
|
"Numeric object lookup must use ordered entries without reporting failure");
|
|
Require(_ZN3sce4Json5Value10referValueEm(&root, 2) == nullptr && trace.calls == 5,
|
|
"The nullable mutable lookup must not dispatch failure recovery");
|
|
trace.reenter = true;
|
|
Require(_ZNK3sce4Json5ValueixEPKc(list, "missing") == fallback, "Reentrant refusal must keep fallback identity");
|
|
Event(trace, 6, 0x80848117, list, &root);
|
|
Require(trace.fallback == fallback && fallback->type == 2 && fallback->payload == 77,
|
|
"The callback must be able to update the root fallback without recursively dispatching itself");
|
|
trace.reenter = false;
|
|
Require(_ZNK3sce4Json5Value8getValueEm(fallback, 9) == fallback && trace.calls == 6,
|
|
"A refusal on the fallback itself must suppress recovery");
|
|
_ZN3sce4Json5Value5clearEv(const_cast<Value*>(fallback));
|
|
Require(_ZNK3sce4Json5ValueixEPKc(&root, "missing") == fallback && trace.calls == 7 && fallback->type == 0,
|
|
"Recovery must resume after reentry and retain fallback ownership");
|
|
Require(static_cast<unsigned>(_ZN3sce4Json5Value30setElementAccessFailureHandlerEPFviPKNS0_6StringEPKmPKS1_S8_PvES9_(const_cast<Value*>(list), Recover, &trace)) == 0x80848104,
|
|
"An owned child must reject handler registration");
|
|
Require(_ZN3sce4Json5Value30setElementAccessFailureHandlerEPFviPKNS0_6StringEPKmPKS1_S8_PvES9_(&root, nullptr, nullptr) == 0,
|
|
"Unregister element recovery");
|
|
Require(_ZNK3sce4Json5ValueixEPKc(&root, "missing") == fallback && trace.calls == 7,
|
|
"Unregistration must preserve fallback identity and stop dispatch");
|
|
_ZN3sce4Json6StringD1Ev(&missing);
|
|
_ZN3sce4Json5ValueD1Ev(&root);
|
|
Require(_ZN3sce4Json11Initializer9terminateEv(&initializer) == 0, "Terminate element recovery");
|
|
CheckPartialElementFallbacks();
|
|
CheckElementStringFailures();
|
|
CheckElementCollectionFailures();
|
|
return 0;
|
|
}
|