TEST_F(ContextCreatorTest, ValidateMultipleEviction) {
AutoCurrentContext()->Initiate();
// Number of dependent contexts to be created
const size_t count = 100;
// Teardown lock, counter, and condition:
std::mutex lock;
std::condition_variable cond;
int counter = count;
// Obtain creator pointer:
AutoRequired<Creator> creator;
// Set up a signal manager at global context scope:
AutoRequired<GlobalSignal> signal;
{
// Array of objects to test destruction on, and corresponding collection of contexts:
std::shared_ptr<WaitMember> members[count];
// Create a few contexts:
for(int i = count; i--;) {
AutoCreateContext ctxt;
CurrentContextPusher pshr(ctxt);
// Trivial validation that the newly created context is an empty context:
ASSERT_EQ(static_cast<size_t>(0), ctxt->GetMemberCount()) << "A created context was not empty";
// Add in an object to test asynchronous destruction:
AutoRequired<WaitMember> obj;
members[i] = obj;
ASSERT_EQ(signal.get(), obj->m_signal.get()) << "Dependent context wiring did not correctly match to the enclosing scope";
// Add a notifier to signal a continue condition when we have everything we need:
ctxt->AddTeardownListener([&lock, &cond, &counter] {
(std::lock_guard<std::mutex>)lock,
counter--,
cond.notify_all();
});
// Kick off the context:
ctxt->Initiate();
}
// Signal all members and then release everything:
signal->Signal();
}
// Wait for all contexts to be destroyed
std::unique_lock<std::mutex> lk(lock);
bool wait_status = cond.wait_for(lk, std::chrono::seconds(1), [&counter] {return counter == 0;});
ASSERT_TRUE(wait_status) << "All teardown listeners didn't trigger, counter still at " << counter;
// Validate that everything expires:
ASSERT_EQ(static_cast<size_t>(0), creator->GetSize()) << "Not all contexts were evicted as expected";
}
TEST_F(CoreContextTest, UnlinkOnTeardown) {
std::weak_ptr<ClassThatPoints1> weakA;
std::shared_ptr<ClassThatPoints2> strongB;
AutoRequired<SimpleObject> so;
// Set up a subcontext with some cycles and external links:
{
// Main context that gets reset second
AutoCreateContext ctxt;
// Sibling context that we're also going to reset
AutoCreateContext otherContext;
otherContext->Inject<std::vector<int>>();
AutoRequired<ClassThatPoints1> a(ctxt);
AutoRequired<ClassThatPoints2> b(ctxt, otherContext);
weakA = a;
strongB = b;
ASSERT_TRUE(a->so.IsAutowired()) << "Root object pointer not correctly obtained";
ASSERT_TRUE(b->so.IsAutowired()) << "Root object pointer not correctly obtained";
ctxt->onTeardown +=
[weakA, strongB] (const CoreContext&) {
// Verify that nothing got screwed up at this point:
auto a = weakA.lock();
ASSERT_FALSE(weakA.expired()) << "Weak pointer expired prematurely";
ASSERT_EQ(strongB, a->b) << "Unlink occurred prematurely";
ASSERT_EQ(a, strongB->a) << "Unlink occured prematurely";
};
// Set the flag at the last possible and to ensure things still get torn down
ctxt->SetUnlinkOnTeardown(true);
}
ASSERT_TRUE(weakA.expired()) << "A reference was leaked even though unlinking was turned on";
ASSERT_TRUE(strongB->v.IsAutowired()) << "An Autowired field pointing to a foreign context was incorrectly unlinked";
ASSERT_EQ(so.get(), strongB->so.get()) << "An Autowired field was unlinked on teardown even though it pointed outside of a context";
}
