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); } }