TEST_F(AutoPacketFactoryTest, MultipleInstanceAddition) {
AutoCurrentContext ctxt;
AutoRequired<AutoPacketFactory> factory;
ctxt->Initiate();
bool ary[2] = {};
for (size_t i = 0; i < 2; i++)
*factory += [i, &ary] (int) {
ary[i] = true;
};
auto packet = factory->NewPacket();
packet->Decorate(101);
ASSERT_TRUE(ary[0]) << "First of two identically typed AutoFilter lambdas was not called";
ASSERT_TRUE(ary[1]) << "Second of two identically typed AutoFilter lambdas was not called";
}
TEST_F(BoostPriorityTest, VerifyCanBoostPriority) {
AutoCurrentContext ctxt;
// Create two spinners and kick them off at the same time:
AutoRequired<JustIncrementsANumber<ThreadPriority::BelowNormal>> lower;
AutoRequired<JustIncrementsANumber<ThreadPriority::Normal>> higher;
ctxt->Initiate();
// We want all of our threads to run on ONE cpu for awhile, and then we want to put it back at exit
DWORD_PTR originalAffinity, systemAffinity;
GetProcessAffinityMask(GetCurrentProcess(), &originalAffinity, &systemAffinity);
SetProcessAffinityMask(GetCurrentProcess(), 1);
auto onreturn = MakeAtExit([originalAffinity] {
SetProcessAffinityMask(GetCurrentProcess(), originalAffinity);
});
// Poke the conditional variable a lot:
AutoRequired<std::mutex> contended;
for(size_t i = 100; i--;) {
// We sleep while holding contention lock to force waiting threads into the sleep queue. The reason we have to do
// this is due to the way that mutex is implemented under the hood. The STL mutex uses a high-frequency variable
// and attempts to perform a CAS (check-and-set) on this variable. If it succeeds, the lock is obtained; if it
// fails, it will put the thread into a non-ready state by calling WaitForSingleObject on Windows or one of the
// mutex_lock methods on Unix.
//
// When a thread can't be run, it's moved from the OS's ready queue to the sleep queue. The scheduler knows that
// the thread can be moved back to the ready queue if a particular object is signalled, but in the case of a lock,
// only one of the threads waiting on the object can actually be moved to the ready queue. It's at THIS POINT that
// the operating system consults the thread priority--if only thread can be moved over, then the highest priority
// thread will wind up in the ready queue every time.
//
// Thread priority does _not_ necessarily influence the amount of time the scheduler allocates allocated to a ready
// thread with respect to other threads of the same process. This is why we hold the lock for a full millisecond,
// in order to force the thread over to the sleep queue and ensure that the priority resolution mechanism is
// directly tested.
std::lock_guard<std::mutex> lk(*contended);
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
// Need to terminate before we try running a comparison.
ctxt->SignalTerminate();
ASSERT_LE(lower->val, higher->val) << "A lower-priority thread was moved out of the sleep queue more frequently than a high-priority thread";
}
TEST_F(CoreContextTest, InitiateAssertsSignals) {
AutoCurrentContext outer;
auto teardown = std::make_shared<bool>(false);
{
AutoCreateContext ctxt;
auto initiated = std::make_shared<bool>(false);
auto running = std::make_shared<bool>(false);
auto shutdown = std::make_shared<bool>(false);
ctxt->onInitiated += [initiated] { *initiated = true; };
ctxt->onRunning += [running] { *running = true; };
ctxt->onShutdown += [shutdown] { *shutdown = true; };
ctxt->onTeardown += [teardown] (const CoreContext&) { *teardown = true; };
ctxt->Initiate();
ASSERT_TRUE(*initiated) << "Initiation signal not asserted on context startup";
ASSERT_FALSE(*running) << "Running signal asserted before the outer context was started";
ASSERT_FALSE(*shutdown) << "Termination signal asserted prematurely";
*initiated = false;
outer->Initiate();
ASSERT_FALSE(*initiated) << "Initiation signal was redundantly asserted";
ASSERT_TRUE(*running) << "Running signal not asserted when the outer context was started";
ASSERT_FALSE(*shutdown) << "Termination signal asserted prematurely";
*running = false;
ctxt->Initiate();
ASSERT_FALSE(*initiated) << "Initiation signal redundantly asserted";
ASSERT_FALSE(*running) << "Running signal redundantly asserted";
ASSERT_FALSE(*shutdown) << "Termination signal asserted unexpectedly";
ctxt->SignalShutdown();
ASSERT_FALSE(*initiated) << "Initiation signal not asserted during teardown";
ASSERT_FALSE(*running) << "Running signal asserted improperly on teardown";
ASSERT_TRUE(*shutdown) << "Termination signal not asserted as expected";
ASSERT_FALSE(*teardown) << "Teardown handler notified prematurely";
}
ASSERT_TRUE(*teardown) << "Teardown handler not correctly notified on context teardown";
}
TEST_F(CoreContextTest, AppropriateShutdownInterleave) {
// Need both an outer and an inner context
AutoCurrentContext ctxtOuter;
AutoCreateContext ctxtInner;
// Need to inject types at both scopes
AutoRequired<ExplicitlyHoldsOutstandingCount> outer(ctxtOuter);
AutoRequired<ExplicitlyHoldsOutstandingCount> inner(ctxtInner);
// Start both contexts up
ctxtOuter->Initiate();
ctxtInner->Initiate();
// Now shut down the outer context. Hand off to an async, we want this to block.
std::thread holder{
[ctxtOuter] {
ctxtOuter->SignalShutdown(true);
}
};
auto holderClean = MakeAtExit([&holder] { holder.join(); });
// Need to ensure that both outstanding counters are reset at some point:
{
auto cleanup = MakeAtExit([&] {
outer->Proceed();
inner->Proceed();
});
// Outer entry should have called "stop":
auto future = outer->calledStop.get_future();
ASSERT_EQ(
std::future_status::ready,
future.wait_for(std::chrono::seconds(5))
) << "Outer scope's OnStop method was incorrectly blocked by a child context member taking a long time to shut down";
}
// Both contexts should be stopped now:
ASSERT_TRUE(ctxtOuter->Wait(std::chrono::seconds(5))) << "Outer context did not tear down in a timely fashion";
ASSERT_TRUE(ctxtOuter->IsQuiescent()) << "Quiescence not achieved by outer context after shutdown";
ASSERT_TRUE(ctxtInner->Wait(std::chrono::seconds(5))) << "Inner context did not tear down in a timely fashion";
}
TEST_F(PostConstructTest, ThrowingAutoInit) {
AutoCurrentContext ctxt;
ASSERT_FALSE(ctxt->IsShutdown());
ASSERT_THROW(AutoRequired<ThrowsInAutoInit>{}, std::runtime_error);
ASSERT_TRUE(ctxt->IsShutdown());
}
TEST_F(CoreContextTest, InitiateMultipleChildren) {
AutoCurrentContext testCtxt;
testCtxt->Initiate();
// Initiate all children
{
auto outerCtxt = testCtxt->Create<void>();
auto child1 = outerCtxt->Create<void>();
auto child2 = outerCtxt->Create<void>();
auto child3 = outerCtxt->Create<void>();
child1->Initiate();
child2->Initiate();
child3->Initiate();
outerCtxt->Initiate();
ASSERT_TRUE(child1->IsRunning());
ASSERT_TRUE(child2->IsRunning());
ASSERT_TRUE(child3->IsRunning());
outerCtxt->SignalShutdown(true);
}
// Don't initiate middle child
{
auto outerCtxt = testCtxt->Create<void>();
auto child1 = outerCtxt->Create<void>();
auto child2 = outerCtxt->Create<void>();
auto child3 = outerCtxt->Create<void>();
child1->Initiate();
child3->Initiate();
outerCtxt->Initiate();
ASSERT_TRUE(child1->IsRunning());
ASSERT_FALSE(child2->IsInitiated());
ASSERT_TRUE(child3->IsRunning());
outerCtxt->SignalShutdown(true);
}
// Don't initiate middle child and initiate parent first
{
auto outerCtxt = testCtxt->Create<void>();
auto child1 = outerCtxt->Create<void>();
auto child2 = outerCtxt->Create<void>();
auto child3 = outerCtxt->Create<void>();
outerCtxt->Initiate();
child1->Initiate();
child3->Initiate();
ASSERT_TRUE(child1->IsRunning());
ASSERT_FALSE(child2->IsInitiated());
ASSERT_TRUE(child3->IsRunning());
outerCtxt->SignalShutdown(true);
}
}
