bool SoftwareTimerOrderingTestCase::run_() const
{
	constexpr auto totalSoftwareTimers = totalThreads;

	for (const auto& phase : priorityTestPhases)
	{
		SequenceAsserter sequenceAsserter;

		using TestSoftwareTimer = decltype(makeStaticSoftwareTimer(&SequenceAsserter::sequencePoint,
				std::ref(std::declval<SequenceAsserter&>()), std::declval<unsigned int>()));
		std::array<TestSoftwareTimer, totalSoftwareTimers> softwareTimers
		{{
				makeStaticSoftwareTimer(&SequenceAsserter::sequencePoint, std::ref(sequenceAsserter),
						static_cast<unsigned int>(phase.first[phase.second[0]].second)),
				makeStaticSoftwareTimer(&SequenceAsserter::sequencePoint, std::ref(sequenceAsserter),
						static_cast<unsigned int>(phase.first[phase.second[1]].second)),
				makeStaticSoftwareTimer(&SequenceAsserter::sequencePoint, std::ref(sequenceAsserter),
						static_cast<unsigned int>(phase.first[phase.second[2]].second)),
				makeStaticSoftwareTimer(&SequenceAsserter::sequencePoint, std::ref(sequenceAsserter),
						static_cast<unsigned int>(phase.first[phase.second[3]].second)),
				makeStaticSoftwareTimer(&SequenceAsserter::sequencePoint, std::ref(sequenceAsserter),
						static_cast<unsigned int>(phase.first[phase.second[4]].second)),
				makeStaticSoftwareTimer(&SequenceAsserter::sequencePoint, std::ref(sequenceAsserter),
						static_cast<unsigned int>(phase.first[phase.second[5]].second)),
				makeStaticSoftwareTimer(&SequenceAsserter::sequencePoint, std::ref(sequenceAsserter),
						static_cast<unsigned int>(phase.first[phase.second[6]].second)),
				makeStaticSoftwareTimer(&SequenceAsserter::sequencePoint, std::ref(sequenceAsserter),
						static_cast<unsigned int>(phase.first[phase.second[7]].second)),
				makeStaticSoftwareTimer(&SequenceAsserter::sequencePoint, std::ref(sequenceAsserter),
						static_cast<unsigned int>(phase.first[phase.second[8]].second)),
				makeStaticSoftwareTimer(&SequenceAsserter::sequencePoint, std::ref(sequenceAsserter),
						static_cast<unsigned int>(phase.first[phase.second[9]].second)),
		}};

		waitForNextTick();

		for (size_t i = 0; i < softwareTimers.size(); ++i)
			softwareTimers[i].start(TickClock::duration{maxPhasePriority + 1 - phase.first[phase.second[i]].first});

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

		for (const auto& softwareTimer : softwareTimers)
			while(softwareTimer.isRunning())
			{

			}

		if (sequenceAsserter.assertSequence(totalSoftwareTimers) == false)
			return false;
	}

	return true;
}
bool CallOnceOperationsTestCase::run_() const
{
#if DISTORTOS_CALLONCE_SUPPORTED == 1 || DOXYGEN == 1

	const auto contextSwitchCount = statistics::getContextSwitchCount();

	SequenceAsserter sequenceAsserter;
	OnceFlag onceFlag;

	std::array<DynamicThread, totalThreads> threads
	{{
			makeTestThread(testCasePriority_ - 1, sequenceAsserter, SequencePoints{0, 12}, onceFlag),
			makeTestThread(testCasePriority_ - 1, sequenceAsserter, SequencePoints{2, 13}, onceFlag),
			makeTestThread(testCasePriority_ - 1, sequenceAsserter, SequencePoints{3, 14}, onceFlag),
			makeTestThread(testCasePriority_ - 1, sequenceAsserter, SequencePoints{4, 15}, onceFlag),
			makeTestThread(testCasePriority_ - 1, sequenceAsserter, SequencePoints{5, 16}, onceFlag),
			makeTestThread(testCasePriority_ - 1, sequenceAsserter, SequencePoints{6, 17}, onceFlag),
			makeTestThread(testCasePriority_ - 1, sequenceAsserter, SequencePoints{7, 18}, onceFlag),
			makeTestThread(testCasePriority_ - 1, sequenceAsserter, SequencePoints{8, 19}, onceFlag),
			makeTestThread(testCasePriority_ - 1, sequenceAsserter, SequencePoints{9, 20}, onceFlag),
			makeTestThread(testCasePriority_ - 1, sequenceAsserter, SequencePoints{10, 21}, onceFlag),
	}};

	waitForNextTick();
	const auto start = TickClock::now();

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

	ThisThread::setPriority(testCasePriority_ - 2);

	bool invalidState {};
	for (size_t i = 1; i < threads.size(); ++i)
		if (threads[i].getState() != ThreadState::BlockedOnOnceFlag)
			invalidState = true;

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

	if (invalidState != false)
		return false;

	if (TickClock::now() - start != sleepForDuration + decltype(sleepForDuration){1})
		return false;

	if (sequenceAsserter.assertSequence(totalThreads * 2 + 2) == false)
		return false;

	constexpr auto totalContextSwitches = 2 * totalThreads + 3 + waitForNextTickContextSwitchCount;
	if (statistics::getContextSwitchCount() - contextSwitchCount != totalContextSwitches)
		return false;

#endif	// DISTORTOS_CALLONCE_SUPPORTED == 1 || DOXYGEN == 1

	return true;
}
bool ThreadSleepForTestCase::run_() const
{
	for (const auto& phase : priorityTestPhases)
	{
		SequenceAsserter sequenceAsserter;
		std::array<TickClock::duration, totalThreads> durationDeviations {{}};

		std::array<TestThread, totalThreads> threads
		{{
				makeTestThread(phase.first[phase.second[0]], sequenceAsserter, durationDeviations[0]),
				makeTestThread(phase.first[phase.second[1]], sequenceAsserter, durationDeviations[1]),
				makeTestThread(phase.first[phase.second[2]], sequenceAsserter, durationDeviations[2]),
				makeTestThread(phase.first[phase.second[3]], sequenceAsserter, durationDeviations[3]),
				makeTestThread(phase.first[phase.second[4]], sequenceAsserter, durationDeviations[4]),
				makeTestThread(phase.first[phase.second[5]], sequenceAsserter, durationDeviations[5]),
				makeTestThread(phase.first[phase.second[6]], sequenceAsserter, durationDeviations[6]),
				makeTestThread(phase.first[phase.second[7]], sequenceAsserter, durationDeviations[7]),
				makeTestThread(phase.first[phase.second[8]], sequenceAsserter, durationDeviations[8]),
				makeTestThread(phase.first[phase.second[9]], sequenceAsserter, durationDeviations[9]),
		}};

		{
			architecture::InterruptMaskingLock interruptMaskingLock;

			// wait for beginning of next tick - test threads should be started in the same tick
			ThisThread::sleepFor({});

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

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

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

		// sleepFor() always sleeps one tick longer
		for (const auto& durationDeviation : durationDeviations)
			if (durationDeviation != TickClock::duration{1})
				return false;
	}

	return true;
}
bool SignalsInterruptionTestCase::run_() const
{
    const auto contextSwitchCount = statistics::getContextSwitchCount();
    auto expectedContextSwitchCount = decltype(contextSwitchCount) {};

    for (const auto testStepType : testStepTypes)
    {
        SequenceAsserter sequenceAsserter;

        // initially no signals may be pending
        if (ThisThread::Signals::getPendingSignalSet().getBitset().any() == true)
            return false;

        TestStepStorage testStepStorage;
        auto& testStep = makeTestStep(testStepType, testStepStorage, sequenceAsserter);
        const auto testStepRunResult = testStep.run(sequenceAsserter);
        const auto testStepParameters = testStep.getParameters();
        testStep.~TestStep();

        if (testStepRunResult == false)
            return false;
        if (sequenceAsserter.assertSequence(testStepParameters.first) == false)
            return false;
        expectedContextSwitchCount += testStepParameters.second;
        if (statistics::getContextSwitchCount() - contextSwitchCount != expectedContextSwitchCount)
            return false;
    }

    // after the test no signals may be pending
    if (ThisThread::Signals::getPendingSignalSet().getBitset().any() == true)
        return false;

    if (statistics::getContextSwitchCount() - contextSwitchCount != expectedContextSwitchCount)
        return false;

    return true;
}
Пример #5
0
bool ThreadPriorityTestCase::run_() const
{
	for (const auto& phase : priorityTestPhases)
	{
		SequenceAsserter sequenceAsserter;

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

		{
			architecture::InterruptMaskingLock interruptMaskingLock;

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

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

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

	return true;
}
bool FifoQueuePriorityTestCase::run_() const
{
	const auto contextSwitchCount = statistics::getContextSwitchCount();
	std::remove_const<decltype(contextSwitchCount)>::type expectedContextSwitchCount {};
	constexpr size_t fifoQueueTypes {2};

	for (const auto& stage : stages)
		for (const auto& phase : priorityTestPhases)
		{
			StaticFifoQueueWrapper<totalThreads> fifoQueueWrapper;
			StaticRawFifoQueueWrapper<totalThreads> rawFifoQueueWrapper;
			using QueueWrapperHolder = estd::ReferenceHolder<const QueueWrapper>;
			const QueueWrapperHolder queueWrappers[fifoQueueTypes]
			{
					QueueWrapperHolder{fifoQueueWrapper},
					QueueWrapperHolder{rawFifoQueueWrapper},
			};

			for (auto& queueWrapperHolder : queueWrappers)
			{
				auto& queueWrapper = queueWrapperHolder.get();
				SequenceAsserter sequenceAsserter;

				const auto& threadFunction = std::get<0>(stage);
				std::array<TestThread, totalThreads> threads
				{{
						makeTestThread(threadFunction, 0, phase.first[phase.second[0]], sequenceAsserter, queueWrapper),
						makeTestThread(threadFunction, 1, phase.first[phase.second[1]], sequenceAsserter, queueWrapper),
						makeTestThread(threadFunction, 2, phase.first[phase.second[2]], sequenceAsserter, queueWrapper),
						makeTestThread(threadFunction, 3, phase.first[phase.second[3]], sequenceAsserter, queueWrapper),
						makeTestThread(threadFunction, 4, phase.first[phase.second[4]], sequenceAsserter, queueWrapper),
						makeTestThread(threadFunction, 5, phase.first[phase.second[5]], sequenceAsserter, queueWrapper),
						makeTestThread(threadFunction, 6, phase.first[phase.second[6]], sequenceAsserter, queueWrapper),
						makeTestThread(threadFunction, 7, phase.first[phase.second[7]], sequenceAsserter, queueWrapper),
						makeTestThread(threadFunction, 8, phase.first[phase.second[8]], sequenceAsserter, queueWrapper),
						makeTestThread(threadFunction, 9, phase.first[phase.second[9]], sequenceAsserter, queueWrapper),
				}};

				// execute Prepare
				if (std::get<1>(stage) != nullptr)
					std::get<1>(stage)(queueWrapper);

				bool result {true};

				for (auto& thread : threads)
				{
					thread.start();
					// 2 context switches: "into" the thread and "back" to main thread when test thread blocks on FIFO
					// queue
					expectedContextSwitchCount += 2;
					if (statistics::getContextSwitchCount() - contextSwitchCount != expectedContextSwitchCount)
						result = false;
				}

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

				for (size_t i = 0; i < threads.size(); ++i)
				{
					const auto triggerResult = std::get<2>(stage)(queueWrapper, i);
					if (triggerResult == false)
						result = false;
					// 2 context switches: into" the unblocked thread and "back" to main thread when test thread
					// terminates
					expectedContextSwitchCount += 2;
					if (statistics::getContextSwitchCount() - contextSwitchCount != expectedContextSwitchCount)
						result = false;
				}

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

				// execute FinalCheck
				if (std::get<3>(stage) != nullptr && std::get<3>(stage)(queueWrapper) == false)
					result = false;

				if (result == false || sequenceAsserter.assertSequence(totalThreads * 2) == false)
					return false;
			}
		}

	if (statistics::getContextSwitchCount() - contextSwitchCount != 2 * 4 * totalThreads * priorityTestPhases.size() *
			fifoQueueTypes)
		return false;

	return true;
}
Пример #7
0
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]),
					makeTestThread(now, phase.first[phase.second[8]], sequenceAsserter, timePointDeviations[8],
							sharedRets[8]),
					makeTestThread(now, phase.first[phase.second[9]], sequenceAsserter, timePointDeviations[9],
							sharedRets[9]),
			}};

			{
				architecture::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)
				if (sharedRet != 0)
					return false;
		}

		if (mallinfo().uordblks != allocatedMemory)	// dynamic memory must be deallocated after each test phase
			return false;
	}

	return true;
}
bool MutexPriorityTestCase::run_() const
{
	using Parameters = std::tuple<Mutex::Type, Mutex::Protocol, uint8_t>;
	static const Parameters parametersArray[]
	{
			Parameters{Mutex::Type::normal, Mutex::Protocol::none, {}},
			Parameters{Mutex::Type::normal, Mutex::Protocol::priorityProtect, UINT8_MAX},
			Parameters{Mutex::Type::normal, Mutex::Protocol::priorityInheritance, {}},
			Parameters{Mutex::Type::errorChecking, Mutex::Protocol::none, {}},
			Parameters{Mutex::Type::errorChecking, Mutex::Protocol::priorityProtect, UINT8_MAX},
			Parameters{Mutex::Type::errorChecking, Mutex::Protocol::priorityInheritance, {}},
			Parameters{Mutex::Type::recursive, Mutex::Protocol::none, {}},
			Parameters{Mutex::Type::recursive, Mutex::Protocol::priorityProtect, UINT8_MAX},
			Parameters{Mutex::Type::recursive, Mutex::Protocol::priorityInheritance, {}},
	};

	for (const auto& parameters : parametersArray)
		for (const auto& phase : priorityTestPhases)
		{
			SequenceAsserter sequenceAsserter;
			Mutex mutex {std::get<0>(parameters), std::get<1>(parameters), std::get<2>(parameters)};

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

			mutex.lock();

			{
				architecture::InterruptMaskingLock interruptMaskingLock;

				for (auto& thread : threads)
				{
					thread.start();
					// make sure each test threads blocks on mutex in the order of starting, even if current thread
					// inherits test thread's high priority
					ThisThread::sleepFor(TickClock::duration{1});
				}
			}

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

			mutex.unlock();

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

			if (invalidState != false)
				return false;

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

	return true;
}