Method run_

test/Thread/ThreadSleepUntilTestCase.cpp:96–163

+---------------------------------------------------------------------------------------------------------------------*/

bool ThreadSleepUntilTestCase::run_() const
{
	const auto allocatedMemory = mallinfo().uordblks;

	for (const auto& phase : priorityTestPhases)
	{
		{
			SequenceAsserter sequenceAsserter;
			std::array<TickClock::duration, totalThreads> timePointDeviations {{}};
			std::array<int, totalThreads> sharedRets {{}};
			const auto now = TickClock::now();

			std::array<DynamicThread, totalThreads> threads
			{{
					makeTestThread(now, phase.first[phase.second[0]], sequenceAsserter, timePointDeviations[0],
							sharedRets[0]),
					makeTestThread(now, phase.first[phase.second[1]], sequenceAsserter, timePointDeviations[1],
							sharedRets[1]),
					makeTestThread(now, phase.first[phase.second[2]], sequenceAsserter, timePointDeviations[2],
							sharedRets[2]),
					makeTestThread(now, phase.first[phase.second[3]], sequenceAsserter, timePointDeviations[3],
							sharedRets[3]),
					makeTestThread(now, phase.first[phase.second[4]], sequenceAsserter, timePointDeviations[4],
							sharedRets[4]),
					makeTestThread(now, phase.first[phase.second[5]], sequenceAsserter, timePointDeviations[5],
							sharedRets[5]),
					makeTestThread(now, phase.first[phase.second[6]], sequenceAsserter, timePointDeviations[6],
							sharedRets[6]),
					makeTestThread(now, phase.first[phase.second[7]], sequenceAsserter, timePointDeviations[7],
							sharedRets[7]),
			}};

			{
				const InterruptMaskingLock interruptMaskingLock;

				for (auto& thread : threads)
					thread.start();
			}

			bool invalidState {};
			for (const auto& thread : threads)
				if (thread.getState() != ThreadState::sleeping)
					invalidState = true;

			for (auto& thread : threads)
				thread.join();

			if (invalidState != false)
				return false;

			if (sequenceAsserter.assertSequence(totalThreads) == false)
				return false;

			for (const auto& timePointDeviation : timePointDeviations)
				if (timePointDeviation != TickClock::duration{})
					return false;

			for (const auto& sharedRet : sharedRets)