180 lines
8.9 KiB
C++
180 lines
8.9 KiB
C++
|
// Step 564: Memory Snapshot Model (12 tests)
|
||
|
|
|
||
|
|
#include "MemorySnapshotModel.h"
|
||
|
|
|
||
|
|
#include <iostream>
|
||
|
|
|
||
|
|
static int passed = 0, failed = 0;
|
||
|
|
#define TEST(name) { std::cout << " " << #name << "... "; }
|
||
|
|
#define PASS() { std::cout << "PASS\n"; ++passed; }
|
||
|
|
#define FAIL(msg) { std::cout << "FAIL: " << msg << "\n"; ++failed; }
|
||
|
|
#define CHECK(cond, msg) if (!(cond)) { FAIL(msg); return; } else {}
|
||
|
|
|
||
|
|
void test_create_snapshot_success() {
|
||
|
|
TEST(create_snapshot_success);
|
||
|
|
MemorySnapshot snapshot;
|
||
|
|
std::string error;
|
||
|
|
const bool ok = MemorySnapshotModel::createSnapshot("snap-1", "sess-1", "thread-1", 7, &snapshot, &error);
|
||
|
|
CHECK(ok, "snapshot creation should succeed");
|
||
|
|
CHECK(snapshot.snapshotId == "snap-1", "snapshot id mismatch");
|
||
|
|
CHECK(snapshot.sessionId == "sess-1", "session id mismatch");
|
||
|
|
CHECK(snapshot.threadId == "thread-1", "thread id mismatch");
|
||
|
|
CHECK(snapshot.sequence == 7, "sequence mismatch");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
void test_create_snapshot_fails_with_missing_ids() {
|
||
|
|
TEST(create_snapshot_fails_with_missing_ids);
|
||
|
|
MemorySnapshot snapshot;
|
||
|
|
std::string error;
|
||
|
|
const bool ok = MemorySnapshotModel::createSnapshot("", "sess-1", "thread-1", 1, &snapshot, &error);
|
||
|
|
CHECK(!ok, "creation should fail with missing snapshot id");
|
||
|
|
CHECK(error == "snapshot_id_or_session_id_missing", "wrong error");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
void test_create_snapshot_fails_with_missing_thread() {
|
||
|
|
TEST(create_snapshot_fails_with_missing_thread);
|
||
|
|
MemorySnapshot snapshot;
|
||
|
|
std::string error;
|
||
|
|
const bool ok = MemorySnapshotModel::createSnapshot("snap-1", "sess-1", "", 1, &snapshot, &error);
|
||
|
|
CHECK(!ok, "creation should fail with missing thread id");
|
||
|
|
CHECK(error == "thread_id_missing", "wrong error");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
void test_add_region_success() {
|
||
|
|
TEST(add_region_success);
|
||
|
|
MemorySnapshot snapshot;
|
||
|
|
std::string error;
|
||
|
|
CHECK(MemorySnapshotModel::createSnapshot("snap-1", "sess-1", "thread-1", 1, &snapshot, &error), "create failed");
|
||
|
|
MemoryRegionRecord stackRegion{"r-stack", MemoryRegionKind::Stack, 0x1000, 64, false};
|
||
|
|
CHECK(MemorySnapshotModel::addRegion(&snapshot, stackRegion, &error), "add region failed");
|
||
|
|
CHECK(snapshot.regions.size() == 1, "region count should be one");
|
||
|
|
CHECK(snapshot.regions[0].id == "r-stack", "region id mismatch");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
void test_add_region_rejects_duplicate_id() {
|
||
|
|
TEST(add_region_rejects_duplicate_id);
|
||
|
|
MemorySnapshot snapshot;
|
||
|
|
std::string error;
|
||
|
|
CHECK(MemorySnapshotModel::createSnapshot("snap-1", "sess-1", "thread-1", 1, &snapshot, &error), "create failed");
|
||
|
|
MemoryRegionRecord first{"dup", MemoryRegionKind::Heap, 0x2000, 32, false};
|
||
|
|
MemoryRegionRecord second{"dup", MemoryRegionKind::Heap, 0x3000, 32, false};
|
||
|
|
CHECK(MemorySnapshotModel::addRegion(&snapshot, first, &error), "first add failed");
|
||
|
|
CHECK(!MemorySnapshotModel::addRegion(&snapshot, second, &error), "duplicate id should fail");
|
||
|
|
CHECK(error == "region_id_duplicate", "wrong duplicate error");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
void test_add_region_rejects_invalid_bounds() {
|
||
|
|
TEST(add_region_rejects_invalid_bounds);
|
||
|
|
MemorySnapshot snapshot;
|
||
|
|
std::string error;
|
||
|
|
CHECK(MemorySnapshotModel::createSnapshot("snap-1", "sess-1", "thread-1", 1, &snapshot, &error), "create failed");
|
||
|
|
MemoryRegionRecord badStart{"bad-start", MemoryRegionKind::Heap, 0, 32, false};
|
||
|
|
CHECK(!MemorySnapshotModel::addRegion(&snapshot, badStart, &error), "zero start should fail");
|
||
|
|
CHECK(error == "region_start_address_invalid", "wrong start-address error");
|
||
|
|
MemoryRegionRecord badSize{"bad-size", MemoryRegionKind::Heap, 0x2000, 0, false};
|
||
|
|
CHECK(!MemorySnapshotModel::addRegion(&snapshot, badSize, &error), "zero size should fail");
|
||
|
|
CHECK(error == "region_size_invalid", "wrong size error");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
void test_regions_are_sorted_by_start_address() {
|
||
|
|
TEST(regions_are_sorted_by_start_address);
|
||
|
|
MemorySnapshot snapshot;
|
||
|
|
std::string error;
|
||
|
|
CHECK(MemorySnapshotModel::createSnapshot("snap-1", "sess-1", "thread-1", 1, &snapshot, &error), "create failed");
|
||
|
|
CHECK(MemorySnapshotModel::addRegion(&snapshot, {"r2", MemoryRegionKind::Heap, 0x3000, 16, false}, &error), "add r2 failed");
|
||
|
|
CHECK(MemorySnapshotModel::addRegion(&snapshot, {"r1", MemoryRegionKind::Stack, 0x1000, 16, false}, &error), "add r1 failed");
|
||
|
|
CHECK(MemorySnapshotModel::addRegion(&snapshot, {"r3", MemoryRegionKind::Global, 0x2000, 16, true}, &error), "add r3 failed");
|
||
|
|
CHECK(snapshot.regions[0].id == "r1", "first region should be r1");
|
||
|
|
CHECK(snapshot.regions[1].id == "r3", "second region should be r3");
|
||
|
|
CHECK(snapshot.regions[2].id == "r2", "third region should be r2");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
void test_find_region_by_address_within_bounds() {
|
||
|
|
TEST(find_region_by_address_within_bounds);
|
||
|
|
MemorySnapshot snapshot;
|
||
|
|
std::string error;
|
||
|
|
CHECK(MemorySnapshotModel::createSnapshot("snap-1", "sess-1", "thread-1", 1, &snapshot, &error), "create failed");
|
||
|
|
CHECK(MemorySnapshotModel::addRegion(&snapshot, {"heap-a", MemoryRegionKind::Heap, 0x5000, 128, false}, &error), "add failed");
|
||
|
|
const MemoryRegionRecord* found = MemorySnapshotModel::findRegionByAddress(snapshot, 0x507F);
|
||
|
|
CHECK(found != nullptr, "region should be found");
|
||
|
|
CHECK(found->id == "heap-a", "wrong region resolved");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
void test_find_region_by_address_at_exclusive_end_returns_null() {
|
||
|
|
TEST(find_region_by_address_at_exclusive_end_returns_null);
|
||
|
|
MemorySnapshot snapshot;
|
||
|
|
std::string error;
|
||
|
|
CHECK(MemorySnapshotModel::createSnapshot("snap-1", "sess-1", "thread-1", 1, &snapshot, &error), "create failed");
|
||
|
|
CHECK(MemorySnapshotModel::addRegion(&snapshot, {"heap-a", MemoryRegionKind::Heap, 0x5000, 128, false}, &error), "add failed");
|
||
|
|
const MemoryRegionRecord* found = MemorySnapshotModel::findRegionByAddress(snapshot, 0x5080);
|
||
|
|
CHECK(found == nullptr, "exclusive upper-bound should not match");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
void test_add_reference_success() {
|
||
|
|
TEST(add_reference_success);
|
||
|
|
MemorySnapshot snapshot;
|
||
|
|
std::string error;
|
||
|
|
CHECK(MemorySnapshotModel::createSnapshot("snap-1", "sess-1", "thread-1", 1, &snapshot, &error), "create failed");
|
||
|
|
MemoryReferenceRecord ref{0x4000, 0x7000, "next"};
|
||
|
|
CHECK(MemorySnapshotModel::addReference(&snapshot, ref, &error), "add reference failed");
|
||
|
|
CHECK(snapshot.references.size() == 1, "reference count should be one");
|
||
|
|
CHECK(snapshot.references[0].label == "next", "label mismatch");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
void test_add_reference_rejects_invalid_fields() {
|
||
|
|
TEST(add_reference_rejects_invalid_fields);
|
||
|
|
MemorySnapshot snapshot;
|
||
|
|
std::string error;
|
||
|
|
CHECK(MemorySnapshotModel::createSnapshot("snap-1", "sess-1", "thread-1", 1, &snapshot, &error), "create failed");
|
||
|
|
CHECK(!MemorySnapshotModel::addReference(&snapshot, {0, 0x7000, "next"}, &error), "zero source should fail");
|
||
|
|
CHECK(error == "reference_address_invalid", "wrong address error");
|
||
|
|
CHECK(!MemorySnapshotModel::addReference(&snapshot, {0x4000, 0x7000, ""}, &error), "empty label should fail");
|
||
|
|
CHECK(error == "reference_label_missing", "wrong label error");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
void test_outgoing_references_filter_by_source_address() {
|
||
|
|
TEST(outgoing_references_filter_by_source_address);
|
||
|
|
MemorySnapshot snapshot;
|
||
|
|
std::string error;
|
||
|
|
CHECK(MemorySnapshotModel::createSnapshot("snap-1", "sess-1", "thread-1", 1, &snapshot, &error), "create failed");
|
||
|
|
CHECK(MemorySnapshotModel::addReference(&snapshot, {0x1000, 0x2000, "a"}, &error), "add ref a failed");
|
||
|
|
CHECK(MemorySnapshotModel::addReference(&snapshot, {0x1000, 0x3000, "b"}, &error), "add ref b failed");
|
||
|
|
CHECK(MemorySnapshotModel::addReference(&snapshot, {0x5000, 0x6000, "c"}, &error), "add ref c failed");
|
||
|
|
const auto refs = MemorySnapshotModel::outgoingReferences(snapshot, 0x1000);
|
||
|
|
CHECK(refs.size() == 2, "expected two outgoing refs");
|
||
|
|
CHECK(refs[0].label == "a", "first outgoing label mismatch");
|
||
|
|
CHECK(refs[1].label == "b", "second outgoing label mismatch");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
int main() {
|
||
|
|
std::cout << "Step 564: Memory Snapshot Model\n";
|
||
|
|
|
||
|
|
test_create_snapshot_success(); // 1
|
||
|
|
test_create_snapshot_fails_with_missing_ids(); // 2
|
||
|
|
test_create_snapshot_fails_with_missing_thread(); // 3
|
||
|
|
test_add_region_success(); // 4
|
||
|
|
test_add_region_rejects_duplicate_id(); // 5
|
||
|
|
test_add_region_rejects_invalid_bounds(); // 6
|
||
|
|
test_regions_are_sorted_by_start_address(); // 7
|
||
|
|
test_find_region_by_address_within_bounds(); // 8
|
||
|
|
test_find_region_by_address_at_exclusive_end_returns_null(); // 9
|
||
|
|
test_add_reference_success(); // 10
|
||
|
|
test_add_reference_rejects_invalid_fields(); // 11
|
||
|
|
test_outgoing_references_filter_by_source_address(); // 12
|
||
|
|
|
||
|
|
std::cout << "\nResults: " << passed << "/" << (passed + failed) << " passed\n";
|
||
|
|
return failed == 0 ? 0 : 1;
|
||
|
|
}
|