#include <catch2/catch_test_macros.hpp>
#include "InMemoryBackend.h"
#include "LifecycleManager.h"
#include "ObjectManager.h"
#include <memory>
// ---------------------------------------------------------------------------
// Step 6 — Pin/Unpin and the cascade
//
// LifecycleManager owns object lifetime. Pin/Unpin adjust reference_count;
// Monitor/Unmonitor adjust handle_count. Both decrement paths call into
// TryCollect, which gates GC on the joint condition (both counters zero)
// and, for MULTIGROUP entries, cascades through CascadeMultigroup to
// unpin every Relation registered under their snapshot subtree.
// ---------------------------------------------------------------------------
namespace
{
std::unique_ptr<nt::ObjectManager::object_type> make_type(OBJECT_TYPE label)
{
auto t = std::make_unique<nt::ObjectManager::object_type>();
t->label = label;
t->methods = { OPEN, CLOSE };
return t;
}
}
TEST_CASE("Pin and Unpin adjust reference_count symmetrically",
"[step6][lifecycle][pin]")
{
nt::InMemoryBackend store;
nt::ObjectManager om;
nt::LifecycleManager lm(om, store);
om.Register({"r1"}, std::make_unique<nt::ObjectManager::Relation>(), make_type(RELATION));
auto* entry = om.Find({"r1"});
REQUIRE(entry->head->reference_count == 0);
lm.Pin(entry);
lm.Pin(entry);
REQUIRE(entry->head->reference_count == 2);
lm.Unpin(entry);
REQUIRE(entry->head->reference_count == 1);
// Still alive at ref_count=1.
REQUIRE(om.Find({"r1"}) != nullptr);
}
TEST_CASE("Pin on nullptr is a no-op", "[step6][lifecycle][pin]")
{
nt::InMemoryBackend store;
nt::ObjectManager om;
nt::LifecycleManager lm(om, store);
REQUIRE_NOTHROW(lm.Pin(nullptr));
REQUIRE_NOTHROW(lm.Unpin(nullptr));
}
TEST_CASE("Unpin below zero does not underflow", "[step6][lifecycle][pin]")
{
nt::InMemoryBackend store;
nt::ObjectManager om;
nt::LifecycleManager lm(om, store);
om.Register({"r1"}, std::make_unique<nt::ObjectManager::Relation>(), make_type(RELATION));
auto* entry = om.Find({"r1"});
lm.Unpin(entry);
REQUIRE(entry->head->reference_count == 0);
}
TEST_CASE("GC is gated on both counters reaching zero", "[step6][lifecycle][gc]")
{
nt::InMemoryBackend store;
nt::ObjectManager om;
nt::LifecycleManager lm(om, store);
om.Register({"r1"}, std::make_unique<nt::ObjectManager::Relation>(), make_type(RELATION));
auto* entry = om.Find({"r1"});
lm.Monitor(entry);
lm.Pin(entry);
// handle_count=1, ref_count=1.
lm.Unpin(entry); // ref_count → 0, but handle_count still 1.
REQUIRE(om.Find({"r1"}) != nullptr);
lm.Pin(entry);
lm.Unmonitor(entry); // handle_count → 0, but ref_count still 1.
REQUIRE(om.Find({"r1"}) != nullptr);
lm.Unpin(entry); // both zero → GC.
REQUIRE(om.Find({"r1"}) == nullptr);
}
TEST_CASE("Unmonitor that brings both counters to zero collects the entry",
"[step6][lifecycle][gc]")
{
nt::InMemoryBackend store;
nt::ObjectManager om;
nt::LifecycleManager lm(om, store);
om.Register({"r1"}, std::make_unique<nt::ObjectManager::Relation>(), make_type(RELATION));
auto* entry = om.Find({"r1"});
lm.Monitor(entry);
REQUIRE(entry->head->handle_count == 1);
lm.Unmonitor(entry);
REQUIRE(om.Find({"r1"}) == nullptr);
}
TEST_CASE("IsEligibleForGC reflects the joint-zero rule",
"[step6][lifecycle][gc]")
{
nt::InMemoryBackend store;
nt::ObjectManager om;
nt::LifecycleManager lm(om, store);
om.Register({"r1"}, std::make_unique<nt::ObjectManager::Relation>(), make_type(RELATION));
auto* entry = om.Find({"r1"});
REQUIRE(lm.IsEligibleForGC(entry));
lm.Pin(entry);
REQUIRE_FALSE(lm.IsEligibleForGC(entry));
}
TEST_CASE("CascadeMultigroup unpins child Relations on snapshot collection",
"[step6][lifecycle][cascade]")
{
nt::InMemoryBackend store;
nt::ObjectManager om;
nt::LifecycleManager lm(om, store);
om.Register({"system", "snapshots", "H1"},
std::make_unique<nt::ObjectManager::Multigroup>(), make_type(MULTIGROUP));
auto* mg_entry = om.Find({"system", "snapshots", "H1"});
for (const auto& n : { std::string{"foo"}, std::string{"bar"} })
{
om.Register({"system", "snapshots", "H1", "relations", n},
std::make_unique<nt::ObjectManager::Relation>(),
make_type(RELATION));
// The parent Multigroup's pin on each child, mirroring what
// register_snapshot does in the C API layer.
lm.Pin(om.Find({"system", "snapshots", "H1", "relations", n}));
}
REQUIRE(om.Find({"system", "snapshots", "H1", "relations", "foo"}) != nullptr);
REQUIRE(om.Find({"system", "snapshots", "H1", "relations", "bar"}) != nullptr);
// One external pin on the Multigroup (e.g. a branch). Release it: cascade.
lm.Pin(mg_entry);
lm.Unpin(mg_entry);
REQUIRE(om.Find({"system", "snapshots", "H1"}) == nullptr);
REQUIRE(om.Find({"system", "snapshots", "H1", "relations", "foo"}) == nullptr);
REQUIRE(om.Find({"system", "snapshots", "H1", "relations", "bar"}) == nullptr);
}
TEST_CASE("Cascade survives a child with an open handle",
"[step6][lifecycle][cascade]")
{
nt::InMemoryBackend store;
nt::ObjectManager om;
nt::LifecycleManager lm(om, store);
om.Register({"system", "snapshots", "H2"},
std::make_unique<nt::ObjectManager::Multigroup>(), make_type(MULTIGROUP));
auto* mg_entry = om.Find({"system", "snapshots", "H2"});
om.Register({"system", "snapshots", "H2", "relations", "live"},
std::make_unique<nt::ObjectManager::Relation>(),
make_type(RELATION));
auto* child = om.Find({"system", "snapshots", "H2", "relations", "live"});
lm.Pin(child); // parent's pin
lm.Monitor(child); // simulate an open handle on the child
// Drop the Multigroup's external ref: cascade unpins child (ref → 0),
// but handle_count is still 1 — child must survive.
lm.Pin(mg_entry);
lm.Unpin(mg_entry);
REQUIRE(om.Find({"system", "snapshots", "H2"}) == nullptr);
REQUIRE(om.Find({"system", "snapshots", "H2", "relations", "live"}) != nullptr);
// Closing the handle now releases the child.
lm.Unmonitor(child);
REQUIRE(om.Find({"system", "snapshots", "H2", "relations", "live"}) == nullptr);
}
