stk::test Namespace Reference

Namespace of the test inventory. More...

Namespaces
namespace	blockpool
	Namespace of BlockMemoryPool test.
namespace	chain
	Namespace of Chain test.
namespace	condvar
	Namespace of ConditionVariable test.
namespace	event
	Namespace of Event test.
namespace	eventflags
	Namespace of EventFlags test.
namespace	stk
	Mock of GetTimeNowMs().
namespace	hrt
	Namespace of HRT test.
namespace	msgqueue
	Namespace of sync::MessageQueue / MessageQueueT test.
namespace	mutex
	Namespace of Mutex test.
namespace	pipe
	Namespace of Pipe test.
namespace	rwmutex
	Namespace of RWMutex test.
namespace	semaphore
	Namespace of Semaphore test.
namespace	sleep
	Namespace of Sleep test.
namespace	spinlock
	Namespace of SpinLock test.
namespace	switch_
	Namespace of Switch test.
namespace	timer
	Namespace of TimerHost test.

Classes
class	KernelMock
struct	AddTaskWhenStartedRelaxCpuContext
struct	TaskSuspendContext
struct	HrtTaskDeadlineMissedRelaxCpuContext
struct	SyncWaitRelaxCpuContext
struct	DelayContext
struct	SwitchToNextRelaxCpuContext
struct	SleepRelaxCpuContext
struct	SleepAllAndWakeRelaxCpuContext
struct	SleepAndWakeTicklessRelaxCpuContext
struct	EDFDynamicSchedulingContext
struct	PrioritySleepRelaxCpuContext
struct	SyncWaitWakeRelaxCpuContext
class	TestAssertPassed
	Throwable class for catching assertions from STK_ASSERT_HANDLER(). More...
class	PlatformTestMock
	IPlatform mock. More...
class	KernelServiceMock
	IKernelService mock. More...
class	TaskMock
	Task mock. More...
class	TaskMockW
	Task mock for SwitchStrategySmoothWeightedRoundRobin and similar algorithms. More...
struct	MutexMock
struct	SyncObjectMock
class	TestContext
	Common context for a test suite. More...

Functions
	TEST_GROUP (Kernel)
	TEST (Kernel, MaxTasks)
	TEST (Kernel, State)
	TEST (Kernel, InitDoubleFail)
	TEST (Kernel, AddTaskNoInit)
	TEST (Kernel, AddTask)
	TEST (Kernel, AddTaskInitStack)
	TEST (Kernel, AddTaskFailMaxOut)
	TEST (Kernel, AddTaskFailSameTask)
static void	AddTaskWhenStartedRelaxCpu ()
	TEST (Kernel, AddTaskWhenStarted)
	TEST (Kernel, AddTaskFailStaticStarted)
	TEST (Kernel, AddTaskFailHrtStarted)
	TEST (Kernel, RemoveTask)
	TEST (Kernel, RemoveTaskFailNull)
	TEST (Kernel, RemoveTaskFailUnsupported)
	TEST (Kernel, RemoveTaskFailStarted)
	TEST (Kernel, StartInvalidPeriodicity)
	TEST (Kernel, StartNotIntialized)
	TEST (Kernel, StartNoTasks)
	TEST (Kernel, Start)
	TEST (Kernel, StartBeginISR)
	TEST (Kernel, ContextSwitchOnSysTickISR)
	TEST (Kernel, ContextSwitchAccessModeChange)
	TEST (Kernel, ContextSwitchCorruptedFsmMode)
	TEST (Kernel, SingleTask)
template<class _SwitchStrategy>
static void	TestTaskExit ()
	TEST (Kernel, OnTaskExitRR)
	TEST (Kernel, OnTaskExitSWRR)
	TEST (Kernel, OnTaskExitFP31)
	TEST (Kernel, OnTaskExitUnknownOrNull)
	TEST (Kernel, OnTaskExitUnsupported)
	TEST (Kernel, OnTaskExitScheduleDynamicOnly)
	TEST (Kernel, OnTaskExitSchedule)
	TEST (Kernel, OnTaskNotFoundBySP)
	TEST (Kernel, OnTaskSkipFreedTask)
static void	TaskSuspendRelaxCpu ()
	TEST (Kernel, TaskSuspend)
	TEST (Kernel, Hrt)
	TEST (Kernel, HrtAddNonHrt)
	TEST (Kernel, HrtAddNotAllowedForNonHrtMode)
	TEST (Kernel, HrtSleepNotAllowed)
	TEST (Kernel, HrtTaskCompleted)
static void	HrtTaskDeadlineMissedRelaxCpu ()
	TEST (Kernel, HrtTaskDeadlineMissedRR)
	TEST (Kernel, HrtTaskDeadlineNotMissedRR)
	TEST (Kernel, HrtSkipSleepingNextRM)
template<class _SwitchStrategy>
static void	TestHrtTaskExitDuringSleepState ()
	TEST (Kernel, HrtTaskExitDuringSleepStateRR)
	TEST (Kernel, HrtTaskExitDuringSleepStateRM)
	TEST (Kernel, HrtTaskExitDuringSleepStateDM)
	TEST (Kernel, HrtTaskExitDuringSleepStateEDF)
	TEST (Kernel, HrtSleepingAwakeningStateChange)
	TEST (Kernel, HrtOnlyAPI)
	TEST (Kernel, SyncNotEnabledFailsOnWait)
	TEST (Kernel, SyncNoNullSyncObj)
	TEST (Kernel, SyncNoNullMutex)
	TEST (Kernel, SyncNoZeroWait)
	TEST (Kernel, SyncMutexMustBeLocked)
	TEST (Kernel, SyncTaskExitAfterWait)
static void	SyncWaitRelaxCpu ()
template<bool TTickless>
void	Test_SyncWait ()
	TEST (Kernel, SyncWait)
	TEST (Kernel, SyncWaitTickless)
	TEST (Kernel, SyncWaitTicklessDuration)
	TEST (Kernel, EnumTasks)
	TEST (Kernel, SuspendResumeTicklessOnly)
	TEST (Kernel, SuspendResume)
	TEST_GROUP (KernelService)
	TEST (KernelService, GetMsecToTicks)
static void	DelayRelaxCpu ()
	TEST (KernelService, Delay)
	TEST (KernelService, DelayMs)
	TEST (KernelService, InitStackFailure)
	TEST (KernelService, GetTid)
	TEST (KernelService, GetTickResolution)
	TEST (KernelService, GetTicks)
	TEST (KernelService, GetTimeNowMs)
	TEST (KernelService, GetTimeNowMsWith10UsecTick)
static void	SwitchToNextRelaxCpu ()
	TEST (KernelService, SwitchToNext)
	TEST (KernelService, SwitchToNextInactiveTask)
static void	SleepRelaxCpu ()
template<class _SwitchStrategy>
static void	TestTaskSleep (bool until)
	TEST (KernelService, SleepRR)
	TEST (KernelService, SleepSWRR)
	TEST (KernelService, SleepFP31)
	TEST (KernelService, SleepUntilRR)
	TEST (KernelService, SleepUntilSWRR)
	TEST (KernelService, SleepUntilFP31)
	TEST (KernelService, SleepMsRR)
	TEST (KernelService, SleepUntilMissDeadline)
static void	SleepAllAndWakeRelaxCpu ()
	TEST (KernelService, SleepAllAndWake)
static void	SleepAndWakeTicklessRelaxCpu ()
	TEST (KernelService, SleepAndWakeTickless)
	TEST_GROUP (KernelServiceIsrSafety)
	TEST (KernelServiceIsrSafety, Common)
	TEST (KernelService, SysTimer)
	TEST_GROUP (Basic)
	TEST (Basic, MinMax)
	TEST_GROUP (UserTask)
	TEST (UserTask, GetStackSize)
	TEST (UserTask, GetStackSizeBytes)
	TEST (UserTask, GetStackSpace)
	TEST (UserTask, GetWeight)
	TEST (UserTask, GetIdAndName)
	TEST (UserTask, TaskWUnsupportedHrt)
	TEST_GROUP (StackMemoryWrapper)
	TEST (StackMemoryWrapper, GetStack)
	TEST (StackMemoryWrapper, GetStackSize)
	TEST (StackMemoryWrapper, GetStackSizeBytes)
	TEST_GROUP (DList)
	TEST (DList, Empty)
	TEST (DList, LinkFront)
	TEST (DList, LinkBack)
	TEST (DList, PopFront)
	TEST (DList, PopBack)
	TEST (DList, Clear)
	TEST (DList, Iteration)
	TEST (DList, Relink)
	TEST_GROUP (SwitchStrategyEDF)
	TEST (SwitchStrategyEDF, GetFirstEmpty)
	TEST (SwitchStrategyEDF, GetNextEmpty)
	TEST (SwitchStrategyEDF, OnTaskDeadlineMissedNotSupported)
	TEST (SwitchStrategyEDF, PriorityNext)
	TEST (SwitchStrategyEDF, Algorithm)
	TEST (SwitchStrategyEDF, RelativeDeadlineEvolution)
static void	g_EDFDynamicSchedulingContextProcess ()
	TEST (SwitchStrategyEDF, DynamicScheduling)
	TEST_GROUP (SwitchStrategyFixedPriority)
	TEST (SwitchStrategyFixedPriority, GetFirstEmpty)
	TEST (SwitchStrategyFixedPriority, GetNextEmpty)
	TEST (SwitchStrategyFixedPriority, OnTaskDeadlineMissedNotSupported)
	TEST (SwitchStrategyFixedPriority, EndlessNext)
	TEST (SwitchStrategyFixedPriority, Algorithm)
static void	PrioritySleepRelaxCpu ()
	TEST (SwitchStrategyFixedPriority, Priority)
	TEST_GROUP (SwitchStrategyMonotonic)
	TEST (SwitchStrategyMonotonic, GetFirstEmpty)
	TEST (SwitchStrategyMonotonic, SleepNotSupported)
	TEST (SwitchStrategyMonotonic, OnTaskDeadlineMissedNotSupported)
	TEST (SwitchStrategyMonotonic, GetNextEmpty)
template<class _SwitchStrategy>
static void	TestPriorityNext ()
	TEST (SwitchStrategyMonotonic, PriorityNextRM)
	TEST (SwitchStrategyMonotonic, PriorityNextDM)
template<class _SwitchStrategy>
static void	TestAlgorithm ()
	TEST (SwitchStrategyMonotonic, AlgorithmRM)
	TEST (SwitchStrategyMonotonic, AlgorithmDM)
	TEST (SwitchStrategyMonotonic, FailedWCRT)
	TEST (SwitchStrategyMonotonic, SchedulableWCRT)
	TEST_GROUP (SwitchStrategyRoundRobin)
	TEST (SwitchStrategyRoundRobin, GetFirstEmpty)
	TEST (SwitchStrategyRoundRobin, GetNextEmpty)
	TEST (SwitchStrategyRoundRobin, OnTaskDeadlineMissedNotSupported)
	TEST (SwitchStrategyRoundRobin, EndlessNext)
	TEST (SwitchStrategyRoundRobin, Algorithm)
	TEST_GROUP (SwitchStrategySWRoundRobin)
	TEST (SwitchStrategySWRoundRobin, GetFirstEmpty)
	TEST (SwitchStrategySWRoundRobin, GetNextEmpty)
	TEST (SwitchStrategySWRoundRobin, OnTaskDeadlineMissedNotSupported)
	TEST (SwitchStrategySWRoundRobin, EndlessNext)
	TEST (SwitchStrategySWRoundRobin, Algorithm)
	TEST_GROUP (Sync)
	TEST (Sync, CriticalSection)
	TEST (Sync, IMutex_ScopedLock)
static void	SyncWaitWakeRelaxCpu ()
	TEST (Sync, SyncWait_Wake)
	TEST_GROUP (PeriodicTrigger)
	TEST (PeriodicTrigger, MustBeArmed)
	TEST (PeriodicTrigger, DoesNotFireBeforePeriod)
	TEST (PeriodicTrigger, FiresAtExactPeriod)
	TEST (PeriodicTrigger, PreservesRemainderAfterFire)
	TEST (PeriodicTrigger, AccumulatesAcrossMultiplePolls)
	TEST (PeriodicTrigger, ManualResetSyncsToCurrentTime)

Variables
static struct stk::test::AddTaskWhenStartedRelaxCpuContext	g_AddTaskWhenStartedRelaxCpuContext
static struct stk::test::TaskSuspendContext	g_TaskSuspendContext
static struct stk::test::HrtTaskDeadlineMissedRelaxCpuContext	g_HrtTaskDeadlineMissedRelaxCpuContext
static struct stk::test::SyncWaitRelaxCpuContext	g_SyncWaitRelaxCpuContext
static struct stk::test::DelayContext	g_DelayContext
static struct stk::test::SwitchToNextRelaxCpuContext	g_SwitchToNextRelaxCpuContext
static struct stk::test::SleepRelaxCpuContext	g_SleepRelaxCpuContext
static struct stk::test::SleepAllAndWakeRelaxCpuContext	g_SleepAllAndWakeRelaxCpuContext
static struct stk::test::SleepAndWakeTicklessRelaxCpuContext	g_SleepAndWakeTicklessRelaxCpuContext
static struct stk::test::EDFDynamicSchedulingContext	g_EDFDynamicSchedulingContext
static struct stk::test::PrioritySleepRelaxCpuContext	g_PrioritySleepRelaxCpuContext
static struct stk::test::SyncWaitWakeRelaxCpuContext	g_SyncWaitWakeRelaxCpuContext
IKernelService *	g_KernelService = NULL
int32_t	g_CriticalSectionState = false
	Critical section state.
bool	g_InsideISR = false
	ISR state.
EKernelPanicId	g_PanicValue = KERNEL_PANIC_NONE
	Panic value.
TestContext	g_TestContext
	Global instance of the TestContext.

Detailed Description

Namespace of the test inventory.

Function Documentation

AddTaskWhenStartedRelaxCpu()

void stk::test::AddTaskWhenStartedRelaxCpu ( )

static

Definition at line 229 of file stktest_kernel.cpp.

{
    g_AddTaskWhenStartedRelaxCpuContext.Process();
}

References g_AddTaskWhenStartedRelaxCpuContext.

Referenced by TEST().

Here is the caller graph for this function:

DelayRelaxCpu()

void stk::test::DelayRelaxCpu ( )

static

Definition at line 61 of file stktest_kernelservice.cpp.

{
    g_DelayContext.Process();
}

References g_DelayContext.

Referenced by TEST(), TEST(), and TEST_GROUP().

Here is the caller graph for this function:

g_EDFDynamicSchedulingContextProcess()

void stk::test::g_EDFDynamicSchedulingContextProcess ( )

static

Definition at line 280 of file stktest_switchstrategyedf.cpp.

{
    g_EDFDynamicSchedulingContext.Process();
}

References g_EDFDynamicSchedulingContext.

Referenced by TEST().

Here is the caller graph for this function:

HrtTaskDeadlineMissedRelaxCpu()

void stk::test::HrtTaskDeadlineMissedRelaxCpu ( )

static

Definition at line 1053 of file stktest_kernel.cpp.

{
    g_HrtTaskDeadlineMissedRelaxCpuContext.Process();
}

References g_HrtTaskDeadlineMissedRelaxCpuContext.

Referenced by TEST(), TEST(), and TEST().

Here is the caller graph for this function:

PrioritySleepRelaxCpu()

void stk::test::PrioritySleepRelaxCpu ( )

static

Definition at line 229 of file stktest_switchstrategyfpriority.cpp.

{
    g_PrioritySleepRelaxCpuContext.Process();
}

References g_PrioritySleepRelaxCpuContext.

Referenced by TEST().

Here is the caller graph for this function:

SleepAllAndWakeRelaxCpu()

void stk::test::SleepAllAndWakeRelaxCpu ( )

static

Definition at line 587 of file stktest_kernelservice.cpp.

{
    g_SleepAllAndWakeRelaxCpuContext.Process();
}

References g_SleepAllAndWakeRelaxCpuContext.

Referenced by TEST().

Here is the caller graph for this function:

SleepAndWakeTicklessRelaxCpu()

void stk::test::SleepAndWakeTicklessRelaxCpu ( )

static

Definition at line 635 of file stktest_kernelservice.cpp.

{
    g_SleepAndWakeTicklessRelaxCpuContext.Process();
}

References g_SleepAndWakeTicklessRelaxCpuContext.

Referenced by TEST().

Here is the caller graph for this function:

SleepRelaxCpu()

void stk::test::SleepRelaxCpu ( )

static

Definition at line 393 of file stktest_kernelservice.cpp.

{
    g_SleepRelaxCpuContext.Process();
}

References g_SleepRelaxCpuContext.

Referenced by TEST(), TEST(), and TestTaskSleep().

Here is the caller graph for this function:

SwitchToNextRelaxCpu()

void stk::test::SwitchToNextRelaxCpu ( )

static

Definition at line 276 of file stktest_kernelservice.cpp.

{
    g_SwitchToNextRelaxCpuContext.Process();
}

References g_SwitchToNextRelaxCpuContext.

Referenced by TEST(), and TEST().

Here is the caller graph for this function:

SyncWaitRelaxCpu()

void stk::test::SyncWaitRelaxCpu ( )

static

Definition at line 1469 of file stktest_kernel.cpp.

{
    g_SyncWaitRelaxCpuContext.Process();
}

References g_SyncWaitRelaxCpuContext.

Referenced by TEST(), and Test_SyncWait().

Here is the caller graph for this function:

SyncWaitWakeRelaxCpu()

void stk::test::SyncWaitWakeRelaxCpu ( )

static

Definition at line 74 of file stktest_sync.cpp.

{
    g_SyncWaitWakeRelaxCpuContext.Process();
}

References g_SyncWaitWakeRelaxCpuContext.

Referenced by TEST().

Here is the caller graph for this function:

TaskSuspendRelaxCpu()

void stk::test::TaskSuspendRelaxCpu ( )

static

Definition at line 864 of file stktest_kernel.cpp.

{
    g_TaskSuspendContext.Process();
}

References g_TaskSuspendContext.

Referenced by TEST().

Here is the caller graph for this function:

TEST() [1/143]

stk::test::TEST	(	Basic	,
		MinMax	)

Definition at line 25 of file stktest_misc.cpp.

{
    static_assert(stk::Min(10, 20) == 10, "Min failed at compile time");
    static_assert(stk::Max(10, 20) == 20, "Max failed at compile time");
 
    // basic & symmetry
    CHECK_EQUAL(1, stk::Min(1, 2));
    CHECK_EQUAL(1, stk::Min(2, 1));
 
    // negatives
    CHECK_EQUAL(-5, stk::Min(-5, -2));
    CHECK_EQUAL(-2, stk::Max(-5, -2));
 
    // equality
    CHECK_EQUAL(42, stk::Max(42, 42));
 
    // boundaries (assuming 32-bit ints)
    CHECK_EQUAL(2147483647, stk::Max(0, 2147483647));
 
    // support const vars
    {
        const int32_t a = 10;
        const int32_t b = 20;
        CHECK_EQUAL(10, stk::Min(a, b));
    }
 
    // no duplicate operation
    {
        int32_t x = 1;
        int32_t y = 5;
 
        // in a macro-based MIN(x++, y), x would become 3, with STK's template-based stk::Min, x should become 2
        int32_t result = stk::Min(x++, y);
 
        CHECK_EQUAL(1, result); // the value before increment
        CHECK_EQUAL(2, x);      // x should only have been incremented once
        CHECK_EQUAL(5, y);      // y remains untouched
    }
}

References stk::Max(), and stk::Min().

Here is the call graph for this function:

TEST() [2/143]

stk::test::TEST	(	DList	,
		Clear	)

Definition at line 318 of file stktest_misc.cpp.

{
    ListHead list;
    ListEntry e1(1), e2(2), e3(3);
 
    list.LinkBack(e1);
    list.LinkBack(e2);
    list.LinkBack(e3);
 
    list.Clear();
 
    CHECK_EQUAL_ZERO(list.GetSize());
    CHECK_TRUE(list.IsEmpty());
    CHECK_TRUE(NULL == list.GetFirst());
    CHECK_TRUE(NULL == list.GetLast());
}

TEST() [3/143]

stk::test::TEST	(	DList	,
		Empty	)

Definition at line 210 of file stktest_misc.cpp.

{
    ListHead list;
 
    CHECK_EQUAL_ZERO(list.GetSize());
    CHECK_TRUE(list.IsEmpty());
    CHECK_TRUE(NULL == list.GetFirst());
    CHECK_TRUE(NULL == list.GetLast());
 
    list.Clear();
}

TEST() [4/143]

stk::test::TEST	(	DList	,
		Iteration	)

Definition at line 335 of file stktest_misc.cpp.

{
    ListHead list;
    ListEntry e1(1), e2(2), e3(3);
 
    list.LinkBack(e1);
    list.LinkBack(e2);
    list.LinkBack(e3);
 
    ListHead::DLEntryType *itr = list.GetFirst();
    CHECK_EQUAL(&e1, itr);
 
    itr = itr->GetNext();
    CHECK_EQUAL(&e2, itr);
 
    itr = itr->GetNext();
    CHECK_EQUAL(&e3, itr);
 
    itr = itr->GetNext();
    CHECK_EQUAL(&e1, itr);
}

TEST() [5/143]

stk::test::TEST	(	DList	,
		LinkBack	)

Definition at line 243 of file stktest_misc.cpp.

{
    ListHead list;
    ListEntry e1(1), e2(2), e3(3);
 
    list.LinkBack(e1);
    CHECK_EQUAL(&e1, list.GetFirst());
    CHECK_EQUAL(&e1, list.GetLast());
    CHECK_EQUAL(&list, e1.GetHead());
 
    list.LinkBack(e2);
    CHECK_EQUAL(&e1, list.GetFirst());
    CHECK_EQUAL(&e2, list.GetLast());
 
    list.LinkBack(e3);
    CHECK_EQUAL(&e1, list.GetFirst());
    CHECK_EQUAL(&e3, list.GetLast());
 
    CHECK_EQUAL(3, list.GetSize());
}

TEST() [6/143]

stk::test::TEST	(	DList	,
		LinkFront	)

Definition at line 222 of file stktest_misc.cpp.

{
    ListHead list;
    ListEntry e1(1), e2(2), e3(3);
 
    list.LinkFront(e1);
    CHECK_EQUAL(&e1, list.GetFirst());
    CHECK_EQUAL(&e1, list.GetLast());
    CHECK_EQUAL(&list, e1.GetHead());
 
    list.LinkFront(e2);
    CHECK_EQUAL(&e2, list.GetFirst());
    CHECK_EQUAL(&e1, list.GetLast());
 
    list.LinkFront(e3);
    CHECK_EQUAL(&e3, list.GetFirst());
    CHECK_EQUAL(&e1, list.GetLast());
 
    CHECK_EQUAL(3, list.GetSize());
}

TEST() [7/143]

stk::test::TEST	(	DList	,
		PopBack	)

Definition at line 291 of file stktest_misc.cpp.

{
    ListHead list;
    ListEntry e1(1), e2(2), e3(3);
 
    list.LinkBack(e1);
    list.LinkBack(e2);
    list.LinkBack(e3);
 
    list.PopBack();
 
    CHECK_EQUAL(&e1, list.GetFirst());
    CHECK_EQUAL(&e2, list.GetLast());
 
    list.PopBack();
 
    CHECK_EQUAL(&e1, list.GetFirst());
    CHECK_EQUAL(&e1, list.GetLast());
 
    list.PopBack();
 
    CHECK_EQUAL_ZERO(list.GetSize());
    CHECK_TRUE(list.IsEmpty());
    CHECK_TRUE(NULL == list.GetFirst());
    CHECK_TRUE(NULL == list.GetLast());
}

TEST() [8/143]

stk::test::TEST	(	DList	,
		PopFront	)

Definition at line 264 of file stktest_misc.cpp.

{
    ListHead list;
    ListEntry e1(1), e2(2), e3(3);
 
    list.LinkBack(e1);
    list.LinkBack(e2);
    list.LinkBack(e3);
 
    list.PopFront();
 
    CHECK_EQUAL(&e2, list.GetFirst());
    CHECK_EQUAL(&e3, list.GetLast());
 
    list.PopFront();
 
    CHECK_EQUAL(&e3, list.GetFirst());
    CHECK_EQUAL(&e3, list.GetLast());
 
    list.PopFront();
 
    CHECK_EQUAL_ZERO(list.GetSize());
    CHECK_TRUE(list.IsEmpty());
    CHECK_TRUE(NULL == list.GetFirst());
    CHECK_TRUE(NULL == list.GetLast());
}

TEST() [9/143]

stk::test::TEST	(	DList	,
		Relink	)

Definition at line 357 of file stktest_misc.cpp.

{
    ListHead list;
    ListEntry e1(1), e2(2), e3(3);
 
    list.LinkBack(e1);
    list.LinkBack(e2);
    list.LinkBack(e3);
 
    ListHead list2;
    list.RelinkTo(list2);
 
    CHECK_EQUAL_ZERO(list.GetSize());
    CHECK_TRUE(list.IsEmpty());
    CHECK_TRUE(NULL == list.GetFirst());
    CHECK_TRUE(NULL == list.GetLast());
 
    CHECK_EQUAL(3, list2.GetSize());
    CHECK_EQUAL(&list2, e1.GetHead());
    CHECK_EQUAL(&list2, e2.GetHead());
    CHECK_EQUAL(&list2, e3.GetHead());
}

TEST() [10/143]

stk::test::TEST	(	Kernel	,
		AddTask	)

Definition at line 126 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    const ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
 
    CHECK_EQUAL_TEXT(0, strategy->GetSize(), "Expecting none kernel tasks");
 
    kernel.AddTask(&task);
 
    CHECK_EQUAL_TEXT(1, strategy->GetSize(), "Expecting 1 kernel task");
 
    IKernelTask *ktask = strategy->GetFirst();
    CHECK_TRUE_TEXT(ktask != NULL, "Expecting one kernel task");
 
    CHECK_TRUE_TEXT(ktask->GetUserTask() == &task, "Expecting just added user task");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetFirst(), stk::ITaskSwitchStrategy::GetSize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::IKernelTask::GetUserTask(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize().

Here is the call graph for this function:

TEST() [11/143]

stk::test::TEST	(	Kernel	,
		AddTaskFailHrtStarted	)

Definition at line 280 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
 
    kernel.Initialize();
    kernel.AddTask(&task1, 1, 1, 0);
    kernel.Start();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.AddTask(&task2, 1, 1, 0);
        CHECK_TEXT(false, "expecting to AddTask to fail when KERNEL_HRT");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [12/143]

stk::test::TEST	(	Kernel	,
		AddTaskFailMaxOut	)

Definition at line 159 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2, task3;
 
    kernel.Initialize();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.AddTask(&task1);
        kernel.AddTask(&task2);
        kernel.AddTask(&task3);
        CHECK_TEXT(false, "expecting to fail adding task because max is 2 but adding 3-rd");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize().

Here is the call graph for this function:

TEST() [13/143]

stk::test::TEST	(	Kernel	,
		AddTaskFailSameTask	)

Definition at line 181 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    kernel.Initialize();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.AddTask(&task);
        kernel.AddTask(&task);
        CHECK_TEXT(false, "expecting to fail adding the same task");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize().

Here is the call graph for this function:

TEST() [14/143]

stk::test::TEST	(	Kernel	,
		AddTaskFailStaticStarted	)

Definition at line 258 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.Start();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.AddTask(&task2);
        CHECK_TEXT(false, "expecting to AddTask to fail when non KERNEL_DYNAMIC");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [15/143]

stk::test::TEST	(	Kernel	,
		AddTaskInitStack	)

Definition at line 146 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
    kernel.AddTask(&task);
 
    CHECK_EQUAL(&task, platform->m_stack_info[STACK_USER_TASK].task);
    CHECK_EQUAL((Word)task.GetStack(), platform->m_stack_info[STACK_USER_TASK].stack->SP);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_info, stk::Stack::SP, stk::test::PlatformTestMock::StackInfo::stack, stk::STACK_USER_TASK, and stk::test::PlatformTestMock::StackInfo::task.

Here is the call graph for this function:

TEST() [16/143]

stk::test::TEST	(	Kernel	,
		AddTaskNoInit	)

Definition at line 108 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.AddTask(&task);
        CHECK_TEXT(false, "AddTask() did not fail");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), and g_TestContext.

Here is the call graph for this function:

TEST() [17/143]

stk::test::TEST	(	Kernel	,
		AddTaskWhenStarted	)

Definition at line 234 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    const ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.Start();
 
    CHECK_EQUAL_TEXT(1, strategy->GetSize(), "expecting task1 be added at this stage");
 
    g_AddTaskWhenStartedRelaxCpuContext.platform = (PlatformTestMock *)kernel.GetPlatform();
    g_AddTaskWhenStartedRelaxCpuContext.strategy = strategy;
    g_RelaxCpuHandler = AddTaskWhenStartedRelaxCpu;
 
    kernel.AddTask(&task2);
 
    CHECK_EQUAL_TEXT(2, strategy->GetSize(), "task2 must be added");
 
    // AddTask is calling Yield/SwitchToNext which takes 2 ticks
    CHECK_EQUAL_TEXT(2, g_AddTaskWhenStartedRelaxCpuContext.counter, "should complete within 2 ticks");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), AddTaskWhenStartedRelaxCpu(), g_AddTaskWhenStartedRelaxCpuContext, g_RelaxCpuHandler, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::ITaskSwitchStrategy::GetSize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [18/143]

stk::test::TEST	(	Kernel	,
		ContextSwitchAccessModeChange	)

Definition at line 530 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    TaskMock<ACCESS_PRIVILEGED> task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    // 1-st task
    CHECK_EQUAL(ACCESS_USER, platform->m_stack_active->mode);
 
    // ISR calls OnSysTick
    platform->ProcessTick();
 
    // 2-st task
    CHECK_EQUAL(ACCESS_PRIVILEGED, platform->m_stack_active->mode);
}

References stk::ACCESS_PRIVILEGED, stk::ACCESS_USER, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::Stack::mode, stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [19/143]

stk::test::TEST	(	Kernel	,
		ContextSwitchCorruptedFsmMode	)

Definition at line 552 of file stktest_kernel.cpp.

{
    KernelMock<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    // ISR calls OnSysTick
    platform->ProcessTick();
 
    g_TestContext.ExpectPanic(true);
 
    kernel.ForceUpdateInvalidFsmState(true);
    platform->ProcessTick();
    CHECK_EQUAL(KERNEL_PANIC_BAD_STATE, test::g_PanicValue);
 
    test::g_PanicValue = KERNEL_PANIC_NONE;
 
    kernel.ForceUpdateInvalidFsmState(false);
    platform->ProcessTick();
    CHECK_EQUAL(KERNEL_PANIC_BAD_STATE, test::g_PanicValue);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::test::KernelMock< TMode, TSize, TStrategy, TPlatform >::ForceUpdateInvalidFsmState(), g_PanicValue, g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::KERNEL_PANIC_BAD_STATE, stk::KERNEL_PANIC_NONE, stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [20/143]

stk::test::TEST	(	Kernel	,
		ContextSwitchOnSysTickISR	)

Definition at line 483 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&idle = platform->m_stack_idle, *&active = platform->m_stack_active;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    // ISR calls OnSysTick 1-st time
    {
        platform->ProcessTick();
 
        CHECK_TRUE(idle != NULL);
        CHECK_TRUE(active != NULL);
 
        // 1-st task is switched from Active and becomes Idle
        CHECK_EQUAL(idle->SP, (Word)task1.GetStack());
 
        // 2-nd task becomes Active
        CHECK_EQUAL(active->SP, (Word)task2.GetStack());
 
        // context switch requested
        CHECK_EQUAL(1, platform->m_context_switch_nr);
    }
 
    // ISR calls OnSysTick 2-nd time
    {
        platform->ProcessTick();
 
        CHECK_TRUE(idle != NULL);
        CHECK_TRUE(active != NULL);
 
        // 2-st task is switched from Active and becomes Idle
        CHECK_EQUAL(idle->SP, (Word)task2.GetStack());
 
        // 1-nd task becomes Active
        CHECK_EQUAL(active->SP, (Word)task1.GetStack());
 
        // context switch requested
        CHECK_EQUAL(2, platform->m_context_switch_nr);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_context_switch_nr, stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::m_stack_idle, stk::test::PlatformTestMock::ProcessTick(), stk::Stack::SP, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [21/143]

stk::test::TEST	(	Kernel	,
		EnumTasks	)

Definition at line 1548 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    ITask *tasks[2] = {};
    uint32_t i = 0;
 
    size_t count = kernel.EnumerateTasksT<2>([&](ITask *t) {
        CHECK_COMPARE(i, <, 2);
        tasks[i++] = t;
        return true; // continue
    });
 
    // must enumerate all
    CHECK_EQUAL(2, count);
 
    // check ordering
    CHECK_EQUAL(tasks[0], &task1);
    CHECK_EQUAL(tasks[1], &task2);
 
    // expect break of enumeration
    count = kernel.EnumerateTasksT<2>([&](ITask */*t*/) {
        return false; // break on first entry
    });
    CHECK_EQUAL(1, count);
 
    // expect only 1 iteration
    count = kernel.EnumerateTasksT<1>([&](ITask */*t*/) {
        return true;
    });
    CHECK_EQUAL(1, count);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::IKernel::EnumerateTasksT(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [22/143]

stk::test::TEST	(	Kernel	,
		Hrt	)

Definition at line 919 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC | KERNEL_HRT, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
    kernel.AddTask(&task1, 1, 1, 0);
    kernel.AddTask(&task2, 2, 1, 0);
    kernel.Start();
 
    platform->ProcessTick();
    CHECK_EQUAL(platform->m_stack_active->SP, (Word)task2.GetStack());
 
    platform->ProcessTick();
    CHECK_EQUAL(platform->m_stack_active->SP, (Word)task1.GetStack());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::ProcessTick(), stk::Stack::SP, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [23/143]

stk::test::TEST	(	Kernel	,
		HrtAddNonHrt	)

Definition at line 937 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC | KERNEL_HRT, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    kernel.Initialize();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.AddTask(&task);
        CHECK(false); // non-HRT AddTask not supported in HRT mode"
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize().

Here is the call graph for this function:

TEST() [24/143]

stk::test::TEST	(	Kernel	,
		HrtAddNotAllowedForNonHrtMode	)

Definition at line 957 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    kernel.Initialize();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.AddTask(&task, 1, 1, 0);
        CHECK(false); // HRT-related AddTask not supported in non-HRT mode
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize().

Here is the call graph for this function:

TEST() [25/143]

stk::test::TEST	(	Kernel	,
		HrtOnlyAPI	)

Definition at line 1205 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    // Obtain kernel task
    IKernelTask *ktask = kernel.GetSwitchStrategy()->GetFirst();
    CHECK_TRUE_TEXT(ktask != nullptr, "Kernel task must exist");
 
    try
    {
        g_TestContext.ExpectAssert(true);
        ktask->GetHrtRelativeDeadline();
        CHECK_TEXT(false, "HRT API can't be called in non-HRT mode");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    try
    {
        g_TestContext.ExpectAssert(true);
        ktask->GetHrtPeriodicity();
        CHECK_TEXT(false, "HRT API can't be called in non-HRT mode");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    try
    {
        g_TestContext.ExpectAssert(true);
        ktask->GetHrtDeadline();
        CHECK_TEXT(false, "HRT API can't be called in non-HRT mode");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::ITaskSwitchStrategy::GetFirst(), stk::IKernelTask::GetHrtDeadline(), stk::IKernelTask::GetHrtPeriodicity(), stk::IKernelTask::GetHrtRelativeDeadline(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [26/143]

stk::test::TEST	(	Kernel	,
		HrtSkipSleepingNextRM	)

Definition at line 1108 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 2, SwitchStrategyRM, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
    kernel.AddTask(&task1, 2, 2, 3);
    kernel.AddTask(&task2, 3, 3, 0);
    kernel.Start();
 
    g_HrtTaskDeadlineMissedRelaxCpuContext.platform = platform;
    g_RelaxCpuHandler = HrtTaskDeadlineMissedRelaxCpu;
 
    CHECK_EQUAL(platform->m_stack_active->SP, (Word)task2.GetStack());
    platform->ProcessTick();
    CHECK_EQUAL(platform->m_stack_active->SP, (Word)task2.GetStack());
    platform->ProcessTick();
    Yield();
    CHECK_EQUAL(platform->m_stack_active->SP, (Word)task1.GetStack());
 
    CHECK_FALSE(platform->m_hard_fault);
    CHECK_EQUAL(0, task1.m_deadline_missed);
    CHECK_EQUAL(0, task2.m_deadline_missed);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_HrtTaskDeadlineMissedRelaxCpuContext, g_RelaxCpuHandler, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), HrtTaskDeadlineMissedRelaxCpu(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::TaskMock< _AccessMode >::m_deadline_missed, stk::test::PlatformTestMock::m_hard_fault, stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::ProcessTick(), stk::Stack::SP, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), and stk::Yield().

Here is the call graph for this function:

TEST() [27/143]

stk::test::TEST	(	Kernel	,
		HrtSleepingAwakeningStateChange	)

Definition at line 1185 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
    kernel.AddTask(&task, 1, 1, 1);
    kernel.Start();
 
    // due to 1 tick delayed start of the task Kernel enters into a SLEEPING state
    CHECK_EQUAL(platform->m_stack_active, platform->m_stack_info[STACK_SLEEP_TRAP].stack);
 
    platform->ProcessTick();
 
    // after a tick task become active and Kernel enters into a AWAKENING state
    CHECK_EQUAL(platform->m_stack_idle, platform->m_stack_info[STACK_SLEEP_TRAP].stack);
    CHECK_EQUAL(platform->m_stack_active->SP, (Word)task.GetStack());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::m_stack_idle, stk::test::PlatformTestMock::m_stack_info, stk::test::PlatformTestMock::ProcessTick(), stk::Stack::SP, stk::test::PlatformTestMock::StackInfo::stack, stk::STACK_SLEEP_TRAP, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [28/143]

stk::test::TEST	(	Kernel	,
		HrtSleepNotAllowed	)

Definition at line 977 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC | KERNEL_HRT, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    kernel.Initialize();
    kernel.AddTask(&task, 1, 1, 0);
    kernel.Start();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        Sleep(1);
        CHECK(false); // IKernelService::Sleep not allowed in HRT mode
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    try
    {
        g_TestContext.ExpectAssert(true);
        SleepUntil(GetTicks() + 1);
        CHECK(false); // IKernelService::SleepUntil not allowed in HRT mode
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::GetTicks(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::Sleep(), stk::SleepUntil(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [29/143]

stk::test::TEST	(	Kernel	,
		HrtTaskCompleted	)

Definition at line 1011 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    const ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
    kernel.AddTask(&task, 1, 1, 0);
    kernel.Start();
 
    CHECK_TRUE(strategy->GetSize() != 0);
 
    platform->EventTaskExit(platform->m_stack_active);
    platform->ProcessTick();
 
    platform->ProcessTick();
 
    CHECK_EQUAL(0, strategy->GetSize());
 
    CHECK_EQUAL(IKernel::STATE_READY, kernel.GetState());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::test::PlatformTestMock::EventTaskExit(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::ITaskSwitchStrategy::GetSize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetState(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::ProcessTick(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), and stk::IKernel::STATE_READY.

Here is the call graph for this function:

TEST() [30/143]

stk::test::TEST	(	Kernel	,
		HrtTaskDeadlineMissedRR	)

Definition at line 1058 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
    kernel.AddTask(&task, 2, 1, 0);
    kernel.Start();
 
    g_HrtTaskDeadlineMissedRelaxCpuContext.platform = platform;
    g_RelaxCpuHandler = HrtTaskDeadlineMissedRelaxCpu;
 
    platform->ProcessTick();
 
    // task does not Yield() and thus next tick will overcome the deadline
    g_TestContext.ExpectAssert(true);
 
    // 2-nd tick goes outside the deadline
    platform->ProcessTick();
 
    CHECK_TRUE(platform->m_hard_fault);
    CHECK_EQUAL(2, task.m_deadline_missed);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_HrtTaskDeadlineMissedRelaxCpuContext, g_RelaxCpuHandler, g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), HrtTaskDeadlineMissedRelaxCpu(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::TaskMock< _AccessMode >::m_deadline_missed, stk::test::PlatformTestMock::m_hard_fault, stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [31/143]

stk::test::TEST	(	Kernel	,
		HrtTaskDeadlineNotMissedRR	)

Definition at line 1083 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
    kernel.AddTask(&task, 2, 1, 0);
    kernel.Start();
 
    g_HrtTaskDeadlineMissedRelaxCpuContext.platform = platform;
    g_RelaxCpuHandler = HrtTaskDeadlineMissedRelaxCpu;
 
    platform->ProcessTick();
 
    // task completes its work and yields to kernel, its workload is 1 ticks now that is within deadline 1
    Yield();
 
    // 2-nd tick continues scheduling normally
    platform->ProcessTick();
 
    CHECK_FALSE(platform->m_hard_fault);
    CHECK_EQUAL(0, task.m_deadline_missed);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_HrtTaskDeadlineMissedRelaxCpuContext, g_RelaxCpuHandler, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), HrtTaskDeadlineMissedRelaxCpu(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::TaskMock< _AccessMode >::m_deadline_missed, stk::test::PlatformTestMock::m_hard_fault, stk::test::PlatformTestMock::ProcessTick(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), and stk::Yield().

Here is the call graph for this function:

TEST() [32/143]

stk::test::TEST	(	Kernel	,
		HrtTaskExitDuringSleepStateDM	)

Definition at line 1175 of file stktest_kernel.cpp.

{
    TestHrtTaskExitDuringSleepState<SwitchStrategyDM>();
}

References TestHrtTaskExitDuringSleepState().

Here is the call graph for this function:

TEST() [33/143]

stk::test::TEST	(	Kernel	,
		HrtTaskExitDuringSleepStateEDF	)

Definition at line 1180 of file stktest_kernel.cpp.

{
    TestHrtTaskExitDuringSleepState<SwitchStrategyEDF>();
}

References TestHrtTaskExitDuringSleepState().

Here is the call graph for this function:

TEST() [34/143]

stk::test::TEST	(	Kernel	,
		HrtTaskExitDuringSleepStateRM	)

Definition at line 1170 of file stktest_kernel.cpp.

{
    TestHrtTaskExitDuringSleepState<SwitchStrategyRM>();
}

References TestHrtTaskExitDuringSleepState().

Here is the call graph for this function:

TEST() [35/143]

stk::test::TEST	(	Kernel	,
		HrtTaskExitDuringSleepStateRR	)

Definition at line 1165 of file stktest_kernel.cpp.

{
    TestHrtTaskExitDuringSleepState<SwitchStrategyRR>();
}

References TestHrtTaskExitDuringSleepState().

Here is the call graph for this function:

TEST() [36/143]

stk::test::TEST	(	Kernel	,
		InitDoubleFail	)

Definition at line 90 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.Initialize();
        kernel.Initialize();
        CHECK_TEXT(false, "duplicate Kernel::Initialize() did not fail");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References g_TestContext, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize().

Here is the call graph for this function:

TEST() [37/143]

stk::test::TEST	(	Kernel	,
		MaxTasks	)

Definition at line 57 of file stktest_kernel.cpp.

{
    const int32_t TASKS = 2;
    Kernel<KERNEL_STATIC, TASKS, SwitchStrategyRR, PlatformTestMock> kernel;
    const int32_t result = Kernel<KERNEL_STATIC, TASKS, SwitchStrategyRR, PlatformTestMock>::TASKS_MAX;
 
    CHECK_EQUAL(TASKS, result);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::TASKS_MAX.

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

Here is the caller graph for this function:

TEST() [38/143]

stk::test::TEST	(	Kernel	,
		OnTaskExitFP31	)

Definition at line 646 of file stktest_kernel.cpp.

{
    TestTaskExit<SwitchStrategyFP32>();
}

References TestTaskExit().

Here is the call graph for this function:

TEST() [39/143]

stk::test::TEST	(	Kernel	,
		OnTaskExitRR	)

Definition at line 636 of file stktest_kernel.cpp.

{
    TestTaskExit<SwitchStrategyRR>();
}

References TestTaskExit().

Here is the call graph for this function:

TEST() [40/143]

stk::test::TEST	(	Kernel	,
		OnTaskExitSchedule	)

Definition at line 731 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_PRIVILEGED> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&active = platform->m_stack_active;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    // task1 is active after Start
    CHECK_EQUAL(active->SP, (Word)task1.GetStack());
 
    kernel.ScheduleTaskRemoval(&task1);
 
    // ScheduleTaskRemoval does not change anything, just schedules removal on the next tick
    CHECK_EQUAL(active->SP, (Word)task1.GetStack());
 
    // task2 will become active now but kernel could not remove task1 because it was current one,
    // it will be removed on a next tick
    platform->ProcessTick();
 
    // task2 became the active
    CHECK_EQUAL(2, kernel.GetSwitchStrategy()->GetSize());
    CHECK_EQUAL(active->SP, (Word)task2.GetStack());
 
    platform->ProcessTick();
 
    // task1 was removed by the tick, task2 is the only active
    CHECK_EQUAL(1, kernel.GetSwitchStrategy()->GetSize());
    CHECK_EQUAL(active->SP, (Word)task2.GetStack());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::ITaskSwitchStrategy::GetSize(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::ProcessTick(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::ScheduleTaskRemoval(), stk::Stack::SP, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [41/143]

stk::test::TEST	(	Kernel	,
		OnTaskExitScheduleDynamicOnly	)

Definition at line 709 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_PRIVILEGED> task1;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.Start();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.ScheduleTaskRemoval(&task1);
        CHECK(false); // dynamic only
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::ScheduleTaskRemoval(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [42/143]

stk::test::TEST	(	Kernel	,
		OnTaskExitSWRR	)

Definition at line 641 of file stktest_kernel.cpp.

{
    TestTaskExit<SwitchStrategySWRR>();
}

References TestTaskExit().

Here is the call graph for this function:

TEST() [43/143]

stk::test::TEST	(	Kernel	,
		OnTaskExitUnknownOrNull	)

Definition at line 651 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_PRIVILEGED> task1;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack unk_stack;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.Start();
 
    // ISR calls OnSysTick (task1 = idle, task2 = active)
    platform->ProcessTick();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        platform->EventTaskExit(&unk_stack);
        CHECK_TEXT(false, "expecting to fail on unknown stack");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    try
    {
        g_TestContext.ExpectAssert(true);
        platform->EventTaskExit(NULL);
        CHECK_TEXT(false, "expecting to fail on NULL");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::test::PlatformTestMock::EventTaskExit(), g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [44/143]

stk::test::TEST	(	Kernel	,
		OnTaskExitUnsupported	)

Definition at line 690 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_PRIVILEGED> task1;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&active = platform->m_stack_active;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.Start();
 
    // ISR calls OnSysTick
    platform->ProcessTick();
 
    g_TestContext.ExpectPanic(true);
    platform->EventTaskExit(active);
    CHECK_EQUAL(KERNEL_PANIC_BAD_MODE, test::g_PanicValue);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::test::PlatformTestMock::EventTaskExit(), g_PanicValue, g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::KERNEL_PANIC_BAD_MODE, stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [45/143]

stk::test::TEST	(	Kernel	,
		OnTaskNotFoundBySP	)

Definition at line 766 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_PRIVILEGED> task1;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.Start();
 
    platform->ProcessTick();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        platform->EventTaskSwitch(0xdeadbeef);
        CHECK(false); // non existent task must not succeed
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::test::PlatformTestMock::EventTaskSwitch(), g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [46/143]

stk::test::TEST	(	Kernel	,
		OnTaskSkipFreedTask	)

Definition at line 791 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_PRIVILEGED> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&active = platform->m_stack_active;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    // task1 exited (will schedule its removal)
    platform->EventTaskExit(active);
 
    // 2 ticks to remove exited task1 from scheduling (1st switched to task2, 2nd cleans up task1 exit)
    platform->ProcessTick();
    platform->ProcessTick();
 
    try
    {
        g_TestContext.ExpectAssert(true);
 
        // we loop through all tasks in attempt to find non existent SP (0xdeadbeef)
        // by this FindTaskBySP() is invoked and will loop thorugh the exited task1's
        // slot
        platform->EventTaskSwitch(0xdeadbeef);
        CHECK(false); // exited task must be successfully skipped by FindTaskBySP()
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::test::PlatformTestMock::EventTaskExit(), stk::test::PlatformTestMock::EventTaskSwitch(), g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [47/143]

stk::test::TEST	(	Kernel	,
		RemoveTask	)

Definition at line 302 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    const ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
 
    kernel.RemoveTask(&task1);
    CHECK_EQUAL_TEXT(&task2, strategy->GetFirst()->GetUserTask(), "Expecting task2 as first");
 
    kernel.RemoveTask(&task1);
    CHECK_EQUAL_TEXT(&task2, strategy->GetFirst()->GetUserTask(), "Expecting task2 as first (duplicate task1 removal attempt)");
 
    kernel.RemoveTask(&task2);
    CHECK_EQUAL_TEXT(0, strategy->GetSize(), "Expecting none tasks");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetFirst(), stk::ITaskSwitchStrategy::GetSize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::IKernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [48/143]

stk::test::TEST	(	Kernel	,
		RemoveTaskFailNull	)

Definition at line 322 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
 
    kernel.Initialize();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.RemoveTask((ITask *)NULL);
        CHECK_TEXT(false, "expecting to fail with NULL argument");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [49/143]

stk::test::TEST	(	Kernel	,
		RemoveTaskFailStarted	)

Definition at line 362 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.RemoveTask(&task);
        CHECK_TEXT(false, "expecting to fail when Kernel has started");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [50/143]

stk::test::TEST	(	Kernel	,
		RemoveTaskFailUnsupported	)

Definition at line 341 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    kernel.Initialize();
    kernel.AddTask(&task);
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.RemoveTask(&task);
        CHECK_TEXT(false, "expecting to fail in KERNEL_STATIC mode");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [51/143]

stk::test::TEST	(	Kernel	,
		SingleTask	)

Definition at line 578 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_PRIVILEGED> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&idle = platform->m_stack_idle, *&active = platform->m_stack_active;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    // ISR calls OnSysTick
    platform->ProcessTick();
 
    // expect that with single task nothing changes
    CHECK_EQUAL((Stack *)NULL, idle);
    CHECK_EQUAL((Stack *)platform->m_stack_info[STACK_USER_TASK].stack, active);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::m_stack_idle, stk::test::PlatformTestMock::m_stack_info, stk::test::PlatformTestMock::ProcessTick(), stk::test::PlatformTestMock::StackInfo::stack, stk::STACK_USER_TASK, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [52/143]

stk::test::TEST	(	Kernel	,
		Start	)

Definition at line 450 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    const uint32_t periodicity = PERIODICITY_MAX - 1;
 
    kernel.Initialize(periodicity);
    kernel.AddTask(&task);
 
    kernel.Start();
 
    CHECK_TRUE(platform->m_started);
    CHECK_TRUE(g_KernelService != NULL);
    CHECK_TRUE(platform->m_stack_active != NULL);
    CHECK_EQUAL((Word)task.GetStack(), platform->m_stack_active->SP);
    CHECK_EQUAL(periodicity, platform->GetTickResolution());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_KernelService, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::test::PlatformTestMock::GetTickResolution(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::m_started, stk::PERIODICITY_MAX, stk::Stack::SP, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [53/143]

stk::test::TEST	(	Kernel	,
		StartBeginISR	)

Definition at line 469 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_PRIVILEGED> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    // expect that first task's access mode is requested by kernel
    CHECK_EQUAL(ACCESS_PRIVILEGED, platform->m_stack_active->mode);
}

References stk::ACCESS_PRIVILEGED, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::Stack::mode, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [54/143]

stk::test::TEST	(	Kernel	,
		StartInvalidPeriodicity	)

Definition at line 384 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.Initialize(0);
        CHECK_TEXT(false, "expecting to fail with 0 periodicity");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.Initialize(PERIODICITY_MAX + 1);
        CHECK_TEXT(false, "expecting to fail with too large periodicity");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::PERIODICITY_MAX.

Here is the call graph for this function:

TEST() [55/143]

stk::test::TEST	(	Kernel	,
		StartNoTasks	)

Definition at line 431 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
 
    kernel.Initialize();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.Start();
        CHECK_TEXT(false, "expecting to fail without tasks");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [56/143]

stk::test::TEST	(	Kernel	,
		StartNotIntialized	)

Definition at line 414 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.Start();
        CHECK_TEXT(false, "expecting to fail when not initialized");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References g_TestContext, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [57/143]

stk::test::TEST	(	Kernel	,
		State	)

Definition at line 66 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    CHECK_TRUE(platform != NULL);
 
    CHECK_TRUE(kernel.GetState() == IKernel::STATE_INACTIVE);
 
    kernel.Initialize();
 
    CHECK_TRUE(kernel.GetState() == IKernel::STATE_READY);
 
    CHECK_TRUE(IKernelService::GetInstance() != NULL);
    CHECK_TRUE(IKernelService::GetInstance() == platform->m_service);
 
    kernel.AddTask(&task);
    kernel.Start();
 
    CHECK_TRUE(kernel.GetState() == IKernel::STATE_RUNNING);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::IKernelService::GetInstance(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetState(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_service, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), stk::IKernel::STATE_INACTIVE, stk::IKernel::STATE_READY, and stk::IKernel::STATE_RUNNING.

Here is the call graph for this function:

TEST() [58/143]

stk::test::TEST	(	Kernel	,
		SuspendResume	)

Definition at line 1628 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC | KERNEL_TICKLESS, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    TaskMock<ACCESS_PRIVILEGED> task1;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.Start();
 
    platform->m_sleep_ticks = 9;
 
    Timeout ticks = stk::IKernelService::GetInstance()->Suspend();
    CHECK_EQUAL(9, ticks);
 
    CHECK_EQUAL(IKernel::STATE_SUSPENDED, kernel.GetState());
 
    stk::IKernelService::GetInstance()->Resume(ticks);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::IKernelService::GetInstance(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetState(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_sleep_ticks, stk::IKernelService::Resume(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), stk::IKernel::STATE_SUSPENDED, and stk::IKernelService::Suspend().

Here is the call graph for this function:

TEST() [59/143]

stk::test::TEST	(	Kernel	,
		SuspendResumeTicklessOnly	)

Definition at line 1587 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_PRIVILEGED> task1;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.Start();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        stk::IKernelService::GetInstance()->Suspend();
        CHECK_TEXT(false, "tickless only");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    // shall return 0 in release build
    g_TestContext.ExpectAssert(true);
    g_TestContext.RethrowAssertException(false);
    CHECK_EQUAL(0, stk::IKernelService::GetInstance()->Suspend());
    g_TestContext.ExpectAssert(false);
    g_TestContext.RethrowAssertException(true);
 
    try
    {
        g_TestContext.ExpectAssert(true);
        stk::IKernelService::GetInstance()->Resume(0);
        CHECK_TEXT(false, "tickless only");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::IKernelService::GetInstance(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::IKernelService::Resume(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), and stk::IKernelService::Suspend().

Here is the call graph for this function:

TEST() [60/143]

stk::test::TEST	(	Kernel	,
		SyncMutexMustBeLocked	)

Definition at line 1379 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC | KERNEL_SYNC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    MutexMock mutex;
    SyncObjectMock sobj;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        IKernelService::GetInstance()->Wait(&sobj, &mutex, 10);
        CHECK_TEXT(false, "mutex must be locked");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::IKernelService::GetInstance(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), and stk::IKernelService::Wait().

Here is the call graph for this function:

TEST() [61/143]

stk::test::TEST	(	Kernel	,
		SyncNoNullMutex	)

Definition at line 1330 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC | KERNEL_SYNC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    SyncObjectMock sobj;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        IKernelService::GetInstance()->Wait(&sobj, nullptr, 10);
        CHECK_TEXT(false, "mutex must not be NULL");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::IKernelService::GetInstance(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), and stk::IKernelService::Wait().

Here is the call graph for this function:

TEST() [62/143]

stk::test::TEST	(	Kernel	,
		SyncNoNullSyncObj	)

Definition at line 1306 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC | KERNEL_SYNC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    MutexMock mutex;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        IKernelService::GetInstance()->Wait(nullptr, &mutex, 10);
        CHECK_TEXT(false, "sync object must not be NULL");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::IKernelService::GetInstance(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), and stk::IKernelService::Wait().

Here is the call graph for this function:

TEST() [63/143]

stk::test::TEST	(	Kernel	,
		SyncNotEnabledFailsOnWait	)

Definition at line 1255 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    TaskMock<ACCESS_USER> task;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        IKernelService::GetInstance()->Wait(nullptr, nullptr, 0);
        CHECK_TEXT(false, "kernel does not support waiting without KERNEL_SYNC");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    // test return NULL
    g_TestContext.ExpectAssert(true);
    g_TestContext.RethrowAssertException(false);
    IWaitObject *wo = IKernelService::GetInstance()->Wait(nullptr, nullptr, 0);
    g_TestContext.RethrowAssertException(true);
    g_TestContext.ExpectAssert(false);
    CHECK_TRUE_TEXT(wo == nullptr, "expect NULL");
 
    try
    {
        g_TestContext.ExpectAssert(true);
        platform->EventTaskWait(0, nullptr, nullptr, 0);
        CHECK_TEXT(false, "kernel does not support waiting without KERNEL_SYNC");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    // test return NULL
    g_TestContext.ExpectAssert(true);
    g_TestContext.RethrowAssertException(false);
    wo = platform->EventTaskWait(0, nullptr, nullptr, 0);
    g_TestContext.RethrowAssertException(true);
    g_TestContext.ExpectAssert(false);
    CHECK_TRUE_TEXT(wo == nullptr, "expect NULL");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::test::PlatformTestMock::EventTaskWait(), g_TestContext, stk::IKernelService::GetInstance(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), and stk::IKernelService::Wait().

Here is the call graph for this function:

TEST() [64/143]

stk::test::TEST	(	Kernel	,
		SyncNoZeroWait	)

Definition at line 1354 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC | KERNEL_SYNC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    MutexMock mutex;
    SyncObjectMock sobj;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        IKernelService::GetInstance()->Wait(&sobj, &mutex, 0);
        CHECK_TEXT(false, "must not be zero wait");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::IKernelService::GetInstance(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), and stk::IKernelService::Wait().

Here is the call graph for this function:

TEST() [65/143]

stk::test::TEST	(	Kernel	,
		SyncTaskExitAfterWait	)

Definition at line 1404 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_SYNC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    TaskMock<ACCESS_USER> task;
 
    MutexMock mutex;
    SyncObjectMock sobj;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    {
        //MutexMock::ScopedLock guard(mutex);
 
        //IKernelService::GetInstance()->Wait(&sobj, &mutex, 10);
    }
 
    // task1 exited (will schedule its removal)
    platform->EventTaskExit(platform->m_stack_active);
 
    platform->ProcessTick();
 
    // should be still running here, next tick will result in task exit and kernel stop
    CHECK_EQUAL(IKernel::STATE_RUNNING, kernel.GetState());
 
    platform->ProcessTick();
 
    // should be stopped here
    CHECK_EQUAL(IKernel::STATE_READY, kernel.GetState());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::test::PlatformTestMock::EventTaskExit(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetState(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::ProcessTick(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), stk::IKernel::STATE_READY, and stk::IKernel::STATE_RUNNING.

Here is the call graph for this function:

TEST() [66/143]

stk::test::TEST	(	Kernel	,
		SyncWait	)

Definition at line 1503 of file stktest_kernel.cpp.

{
    Test_SyncWait<false>();
}

References Test_SyncWait().

Here is the call graph for this function:

TEST() [67/143]

stk::test::TEST	(	Kernel	,
		SyncWaitTickless	)

Definition at line 1508 of file stktest_kernel.cpp.

{
    Test_SyncWait<true>();
}

References Test_SyncWait().

Here is the call graph for this function:

TEST() [68/143]

stk::test::TEST	(	Kernel	,
		SyncWaitTicklessDuration	)

Definition at line 1513 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC | KERNEL_SYNC | KERNEL_TICKLESS, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    TaskMock<ACCESS_USER> task;
 
    MutexMock mutex;
    SyncObjectMock sobj;
 
    g_SyncWaitRelaxCpuContext.Reset();
    g_SyncWaitRelaxCpuContext.platform       = platform;
    g_SyncWaitRelaxCpuContext.check_tickless = 0; // check first tick
    g_RelaxCpuHandler = SyncWaitRelaxCpu;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    MutexMock::ScopedLock guard(mutex);
 
    // sleep_ticks should be equal to 2 on first OnTick call
    IWaitObject *wo = IKernelService::GetInstance()->Wait(&sobj, &mutex, 3);
 
    // in total 4 ticks must be elapsed, including sleep ticks
    CHECK_EQUAL(4, platform->m_ticks_count);
 
    // at this stage test should pass successfully by validating sleep_ticks in SyncWaitRelaxCpuContext::Process
 
    CHECK_EQUAL(GetTid(), wo->GetTid());
    CHECK_TRUE(wo != nullptr);
    CHECK_TRUE(wo->IsTimeout());
    CHECK_EQUAL(3, g_SyncWaitRelaxCpuContext.counter);
    CHECK_EQUAL(true, mutex.m_locked);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_RelaxCpuHandler, g_SyncWaitRelaxCpuContext, stk::IKernelService::GetInstance(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::GetTid(), stk::IWaitObject::GetTid(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::IWaitObject::IsTimeout(), stk::test::PlatformTestMock::m_ticks_count, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), SyncWaitRelaxCpu(), and stk::IKernelService::Wait().

Here is the call graph for this function:

TEST() [69/143]

stk::test::TEST	(	Kernel	,
		TaskSuspend	)

Definition at line 869 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&idle = platform->m_stack_idle, *&active = platform->m_stack_active;
    bool suspended = false;
 
    g_TaskSuspendContext.Clear();
    g_TaskSuspendContext.platform = platform;
    g_TaskSuspendContext.kernel   = &kernel;
    g_TaskSuspendContext.task1    = &task1;
    g_TaskSuspendContext.task2    = &task2;
    g_RelaxCpuHandler = TaskSuspendRelaxCpu;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    // task1 is active after Start
    CHECK_EQUAL(active->SP, (Word)task1.GetStack());
 
    // task1 is calling SuspendTask to suspend self
    kernel.SuspendTask(&task1, suspended);
    CHECK_TRUE(suspended);
 
    // task1 became active after we resumed it TaskSuspendContext::Process
    CHECK_EQUAL(active->SP, (Word)task1.GetStack());
 
    // task1 is calling SuspendTask for task2
    kernel.SuspendTask(&task2, suspended);
    CHECK_TRUE(suspended);
 
    // task2 is suspended
    platform->ProcessTick();
    CHECK_EQUAL(idle->SP, (Word)task2.GetStack());
 
    // task2 is suspended
    platform->ProcessTick();
    CHECK_EQUAL(idle->SP, (Word)task2.GetStack());
 
    // task1 is calling ResumeTask for task2
    kernel.ResumeTask(&task2);
 
    // task2 becomes active
    platform->ProcessTick();
    CHECK_EQUAL(active->SP, (Word)task2.GetStack());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_RelaxCpuHandler, g_TaskSuspendContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::m_stack_idle, stk::test::PlatformTestMock::ProcessTick(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::ResumeTask(), stk::Stack::SP, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::SuspendTask(), and TaskSuspendRelaxCpu().

Here is the call graph for this function:

TEST() [70/143]

stk::test::TEST	(	KernelService	,
		Delay	)

Definition at line 66 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    g_RelaxCpuHandler = DelayRelaxCpu;
    g_DelayContext.platform = kernel.GetPlatform();
 
    Delay(10);
 
    g_RelaxCpuHandler = NULL;
 
    CHECK_EQUAL(10, (int32_t)g_KernelService->GetTicks());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Delay(), DelayRelaxCpu(), g_DelayContext, g_KernelService, g_RelaxCpuHandler, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [71/143]

stk::test::TEST	(	KernelService	,
		DelayMs	)

Definition at line 85 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    kernel.Initialize(2000); // decrease resolution to 1 tick = 2 ms
    kernel.AddTask(&task);
    kernel.Start();
 
    g_RelaxCpuHandler = DelayRelaxCpu;
    g_DelayContext.platform = kernel.GetPlatform();
 
    DelayMs(10);
 
    g_RelaxCpuHandler = NULL;
 
    CHECK_EQUAL(5, (int32_t)g_KernelService->GetTicks());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::DelayMs(), DelayRelaxCpu(), g_DelayContext, g_KernelService, g_RelaxCpuHandler, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [72/143]

stk::test::TEST	(	KernelService	,
		GetMsecToTicks	)

Definition at line 28 of file stktest_kernelservice.cpp.

{
    KernelServiceMock mock;
    mock.m_ticks = 1;
 
    mock.m_resolution = 1000;
    CHECK_EQUAL(10, (int32_t)GetMsFromTicks(10, mock.GetTickResolution()));
 
    mock.m_resolution = 10000;
    CHECK_EQUAL(100, (int32_t)GetMsFromTicks(10, mock.GetTickResolution()));
}

References stk::GetMsFromTicks(), stk::test::KernelServiceMock::GetTickResolution(), stk::test::KernelServiceMock::m_resolution, and stk::test::KernelServiceMock::m_ticks.

Here is the call graph for this function:

TEST() [73/143]

stk::test::TEST	(	KernelService	,
		GetTickResolution	)

Definition at line 142 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    const uint32_t periodicity = PERIODICITY_DEFAULT + 1;
 
    kernel.Initialize(periodicity);
    kernel.AddTask(&task);
    kernel.Start();
 
    CHECK_EQUAL(periodicity, g_KernelService->GetTickResolution());
    CHECK_EQUAL(periodicity, stk::GetTickResolution());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_KernelService, stk::GetTickResolution(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::PERIODICITY_DEFAULT, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [74/143]

stk::test::TEST	(	KernelService	,
		GetTicks	)

Definition at line 156 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize(PERIODICITY_DEFAULT);
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    // ISR calls OnSysTick 1-st time
    platform->ProcessTick();
    CHECK_EQUAL(1, (int32_t)g_KernelService->GetTicks());
    CHECK_EQUAL(1, (int32_t)stk::GetTicks());
 
    // ISR calls OnSysTick 2-nd time
    platform->ProcessTick();
    CHECK_EQUAL(2, (int32_t)g_KernelService->GetTicks());
    CHECK_EQUAL(2, (int32_t)stk::GetTicks());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_KernelService, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::GetTicks(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::PERIODICITY_DEFAULT, stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [75/143]

stk::test::TEST	(	KernelService	,
		GetTid	)

Definition at line 125 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    platform->ProcessTick();
 
    // task/thread id is a pointer to the user task
    size_t tid = stk::GetTid();
    CHECK_EQUAL(tid, (size_t)&task);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::GetTid(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [76/143]

stk::test::TEST	(	KernelService	,
		GetTimeNowMs	)

Definition at line 178 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize(PERIODICITY_DEFAULT);
    kernel.AddTask(&task1);
    kernel.Start();
 
    CHECK_EQUAL(0, (int32_t)stk::GetTimeNowMs());
 
    // make 1000 ticks
    for (int32_t i = 0; i < 1000; ++i)
        platform->ProcessTick();
 
    // 1000 usec * 1000 ticks = 1000 ms
    CHECK_EQUAL(1000, (int32_t)stk::GetTimeNowMs());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::GetTimeNowMs(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::PERIODICITY_DEFAULT, stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [77/143]

stk::test::TEST	(	KernelService	,
		GetTimeNowMsWith10UsecTick	)

Definition at line 198 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    // set periodicity to 10 microsecond
    kernel.Initialize(10);
    kernel.AddTask(&task1);
    kernel.Start();
 
    CHECK_EQUAL(0, (int32_t)stk::GetTimeNowMs());
 
    // make 1000 ticks
    for (int32_t i = 0; i < 1000; ++i)
        platform->ProcessTick();
 
    // 10 usec * 1000 ticks = 10 ms
    CHECK_EQUAL(10, (int32_t)stk::GetTimeNowMs());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::GetTimeNowMs(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [78/143]

stk::test::TEST	(	KernelService	,
		InitStackFailure	)

Definition at line 104 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    platform->m_fail_InitStack = true;
 
    try
    {
        g_TestContext.ExpectAssert(true);
        kernel.Initialize();
        kernel.AddTask(&task);
        CHECK_TEXT(false, "AddTask() did not fail");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::test::PlatformTestMock::m_fail_InitStack.

Here is the call graph for this function:

TEST() [79/143]

stk::test::TEST	(	KernelService	,
		SleepAllAndWake	)

Definition at line 592 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    g_RelaxCpuHandler = SleepAllAndWakeRelaxCpu;
    g_SleepAllAndWakeRelaxCpuContext.platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    g_SleepAllAndWakeRelaxCpuContext.task1 = &task;
 
    // task1 calls Sleep
    Sleep(3);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_RelaxCpuHandler, g_SleepAllAndWakeRelaxCpuContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::Sleep(), SleepAllAndWakeRelaxCpu(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [80/143]

stk::test::TEST	(	KernelService	,
		SleepAndWakeTickless	)

Definition at line 640 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC | KERNEL_TICKLESS, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    g_RelaxCpuHandler = SleepAndWakeTicklessRelaxCpu;
    g_SleepAndWakeTicklessRelaxCpuContext.platform = platform;
 
    // task1 calls Sleep
    Sleep(3);
 
    // expect 4 ticks (1 + 3 sleep)
    CHECK_EQUAL(4, platform->m_ticks_count);
 
    // expect only 2 context switches (1st: Task=Idle, SleepCtx=Active, 2nd: Task=Active, SleepCtx=Idle)
    CHECK_EQUAL(2, platform->m_context_switch_nr);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_RelaxCpuHandler, g_SleepAndWakeTicklessRelaxCpuContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_context_switch_nr, stk::test::PlatformTestMock::m_ticks_count, stk::Sleep(), SleepAndWakeTicklessRelaxCpu(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [81/143]

stk::test::TEST	(	KernelService	,
		SleepFP31	)

Definition at line 452 of file stktest_kernelservice.cpp.

{
    TestTaskSleep<SwitchStrategyFP32>(false);
}

References TestTaskSleep().

Here is the call graph for this function:

TEST() [82/143]

stk::test::TEST	(	KernelService	,
		SleepMsRR	)

Definition at line 472 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&active = platform->m_stack_active;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    // on start Round-Robin selects the very first task
    CHECK_EQUAL_TEXT(active->SP, (size_t)task1.GetStack(), "expecting task1");
 
    // ISR calls OnSysTick (task1 = idle, task2 = active)
    platform->ProcessTick();
    CHECK_EQUAL_TEXT(active->SP, (size_t)task2.GetStack(), "expecting task2");
 
    g_RelaxCpuHandler = SleepRelaxCpu;
    g_SleepRelaxCpuContext.Clear();
    g_SleepRelaxCpuContext.platform = platform;
    g_SleepRelaxCpuContext.task1    = &task1;
    g_SleepRelaxCpuContext.task2    = &task2;
 
    // task2 calls Sleep to become idle
    SleepMs(2);
 
    // task2 slept 2 ticks and became active again when became a tail of previously active task1
    CHECK_EQUAL_TEXT(active->SP, (size_t)task2.GetStack(), "expecting task2 after sleep");
 
    // ISR calls OnSysTick (task1 = active, task2 = idle)
    platform->ProcessTick();
    CHECK_EQUAL_TEXT(active->SP, (size_t)task1.GetStack(), "expecting task1 after next tick");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_RelaxCpuHandler, g_SleepRelaxCpuContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::ProcessTick(), stk::SleepMs(), SleepRelaxCpu(), stk::Stack::SP, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [83/143]

stk::test::TEST	(	KernelService	,
		SleepRR	)

Definition at line 442 of file stktest_kernelservice.cpp.

{
    TestTaskSleep<SwitchStrategyRR>(false);
}

References TestTaskSleep().

Here is the call graph for this function:

TEST() [84/143]

stk::test::TEST	(	KernelService	,
		SleepSWRR	)

Definition at line 447 of file stktest_kernelservice.cpp.

{
    TestTaskSleep<SwitchStrategySWRR>(false);
}

References TestTaskSleep().

Here is the call graph for this function:

TEST() [85/143]

stk::test::TEST	(	KernelService	,
		SleepUntilFP31	)

Definition at line 467 of file stktest_kernelservice.cpp.

{
    TestTaskSleep<SwitchStrategyFP32>(true);
}

References TestTaskSleep().

Here is the call graph for this function:

TEST() [86/143]

stk::test::TEST	(	KernelService	,
		SleepUntilMissDeadline	)

Definition at line 508 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&active = platform->m_stack_active;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    // on start Round-Robin selects the very first task
    CHECK_EQUAL_TEXT(active->SP, (size_t)task1.GetStack(), "expecting task1");
 
    // ISR calls OnSysTick (task1 = idle, task2 = active)
    platform->ProcessTick();
    CHECK_EQUAL_TEXT(active->SP, (size_t)task2.GetStack(), "expecting task2");
 
    g_RelaxCpuHandler = SleepRelaxCpu;
    g_SleepRelaxCpuContext.Clear();
    g_SleepRelaxCpuContext.platform = platform;
    g_SleepRelaxCpuContext.task1    = &task1;
    g_SleepRelaxCpuContext.task2    = &task2;
 
    Ticks now = GetTicks();
 
    // task2 calls Sleep to become idle
    SleepUntil(now);
 
    CHECK_EQUAL(now, GetTicks());
 
    // task2 is still active as it did not sleep
    CHECK_EQUAL_TEXT(active->SP, (size_t)task2.GetStack(), "expecting task2 after sleep");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_RelaxCpuHandler, g_SleepRelaxCpuContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::GetTicks(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::ProcessTick(), SleepRelaxCpu(), stk::SleepUntil(), stk::Stack::SP, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [87/143]

stk::test::TEST	(	KernelService	,
		SleepUntilRR	)

Definition at line 457 of file stktest_kernelservice.cpp.

{
    TestTaskSleep<SwitchStrategyRR>(true);
}

References TestTaskSleep().

Here is the call graph for this function:

TEST() [88/143]

stk::test::TEST	(	KernelService	,
		SleepUntilSWRR	)

Definition at line 462 of file stktest_kernelservice.cpp.

{
    TestTaskSleep<SwitchStrategySWRR>(true);
}

References TestTaskSleep().

Here is the call graph for this function:

TEST() [89/143]

stk::test::TEST	(	KernelService	,
		SwitchToNext	)

Definition at line 281 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&active = platform->m_stack_active;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    // task1 is scheduled first by RR
    CHECK_EQUAL(active->SP, (size_t)task1.GetStack());
 
    // ISR calls OnSysTick (task1 = idle, task2 = active)
    platform->ProcessTick();
    CHECK_EQUAL(active->SP, (size_t)task2.GetStack());
 
    g_RelaxCpuHandler = SwitchToNextRelaxCpu;
    g_SwitchToNextRelaxCpuContext.Clear();
    g_SwitchToNextRelaxCpuContext.platform = platform;
    g_SwitchToNextRelaxCpuContext.task1    = &task1;
    g_SwitchToNextRelaxCpuContext.task2    = &task2;
 
    // task1 calls SwitchToNext (to test path: IKernelService::SwitchToNext -> IPlatform::SwitchToNext -> Kernel::SwitchToNext)
    Yield();
    CHECK_EQUAL(1, platform->m_switch_to_next_nr);
 
    // task2 is active again
    CHECK_EQUAL(active->SP, (size_t)task2.GetStack());
 
    // task2 calls SwitchToNext
    platform->EventTaskSwitch(active->SP);
 
    // task1 calls SwitchToNext (task1 = active, task2 = idle)
    platform->EventTaskSwitch(active->SP + 1); // add shift to test IsMemoryOfSP
 
    // after a switch task 2 is active again
    CHECK_EQUAL(active->SP, (size_t)task2.GetStack());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::test::PlatformTestMock::EventTaskSwitch(), g_RelaxCpuHandler, g_SwitchToNextRelaxCpuContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::m_switch_to_next_nr, stk::test::PlatformTestMock::ProcessTick(), stk::Stack::SP, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), SwitchToNextRelaxCpu(), and stk::Yield().

Here is the call graph for this function:

TEST() [90/143]

stk::test::TEST	(	KernelService	,
		SwitchToNextInactiveTask	)

Definition at line 323 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&active = platform->m_stack_active;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    // task1 is scheduled first by RR
    CHECK_EQUAL(active->SP, (size_t)task1.GetStack());
 
    // ISR calls OnSysTick (task1 = idle, task2 = active)
    platform->ProcessTick();
    CHECK_EQUAL(active->SP, (size_t)task2.GetStack());
 
    g_RelaxCpuHandler = SwitchToNextRelaxCpu;
    g_SwitchToNextRelaxCpuContext.Clear();
    g_SwitchToNextRelaxCpuContext.platform = platform;
    g_SwitchToNextRelaxCpuContext.task1    = nullptr;
    g_SwitchToNextRelaxCpuContext.task2    = nullptr;
 
    platform->EventTaskSwitch(platform->m_stack_idle->SP + 1); // add shift to test IsMemoryOfSP
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::test::PlatformTestMock::EventTaskSwitch(), g_RelaxCpuHandler, g_SwitchToNextRelaxCpuContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::m_stack_idle, stk::test::PlatformTestMock::ProcessTick(), stk::Stack::SP, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), and SwitchToNextRelaxCpu().

Here is the call graph for this function:

TEST() [91/143]

stk::test::TEST	(	KernelService	,
		SysTimer	)

Definition at line 742 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    platform->m_systimer_count = 99;
    platform->m_systimer_freq  = 1000;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    uint32_t freq = stk::GetSysTimerFrequency();
    uint64_t count = stk::GetSysTimerCount();
 
    CHECK_EQUAL(1000, freq);
    CHECK_EQUAL(99, count);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::GetSysTimerCount(), stk::GetSysTimerFrequency(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_systimer_count, stk::test::PlatformTestMock::m_systimer_freq, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [92/143]

stk::test::TEST	(	KernelServiceIsrSafety	,
		Common	)

Definition at line 682 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    g_DelayContext.platform = kernel.GetPlatform();
 
    try
    {
        g_TestContext.ExpectAssert(true);
        Sleep(10);
        CHECK_TEXT(false, "Sleep is not allowed inside ISR");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    try
    {
        g_TestContext.ExpectAssert(true);
        SleepUntil(GetTicks() + 10);
        CHECK_TEXT(false, "SleepUntil is not allowed inside ISR");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    try
    {
        g_TestContext.ExpectAssert(true);
        Delay(10);
        CHECK_TEXT(false, "Delay is not allowed inside ISR");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    try
    {
        g_TestContext.ExpectAssert(true);
        Yield();
        CHECK_TEXT(false, "Yield is not allowed inside ISR");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Delay(), g_DelayContext, g_TestContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::GetTicks(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::Sleep(), stk::SleepUntil(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), and stk::Yield().

Here is the call graph for this function:

TEST() [93/143]

stk::test::TEST	(	PeriodicTrigger	,
		AccumulatesAcrossMultiplePolls	)

Definition at line 126 of file stktest_time.cpp.

{
    time::PeriodicTrigger trigger(PERIOD, true);
 
    stk::SetTimeNowMsec(40);
    CHECK_FALSE(trigger.Poll());
 
    stk::SetTimeNowMsec(80);
    CHECK_FALSE(trigger.Poll());
 
    stk::SetTimeNowMsec(110);
    CHECK_TRUE(trigger.Poll()); // Total 110ms accumulated
}

References stk::time::PeriodicTrigger::Poll(), stk::test::stk::SetTimeNowMsec(), and TEST().

Here is the call graph for this function:

TEST() [94/143]

stk::test::TEST	(	PeriodicTrigger	,
		DoesNotFireBeforePeriod	)

Definition at line 87 of file stktest_time.cpp.

{
    time::PeriodicTrigger trigger(PERIOD, true);
 
    stk::SetTimeNowMsec(50);
    CHECK_FALSE(trigger.Poll());
}

References stk::time::PeriodicTrigger::Poll(), stk::test::stk::SetTimeNowMsec(), and TEST().

Here is the call graph for this function:

TEST() [95/143]

stk::test::TEST	(	PeriodicTrigger	,
		FiresAtExactPeriod	)

Definition at line 95 of file stktest_time.cpp.

{
    time::PeriodicTrigger trigger(PERIOD, true);
 
    stk::SetTimeNowMsec(100);
    CHECK_TRUE(trigger.Poll());
}

References stk::time::PeriodicTrigger::Poll(), stk::test::stk::SetTimeNowMsec(), and TEST().

Here is the call graph for this function:

TEST() [96/143]

stk::test::TEST	(	PeriodicTrigger	,
		ManualResetSyncsToCurrentTime	)

Definition at line 140 of file stktest_time.cpp.

{
    time::PeriodicTrigger trigger(PERIOD, true);
 
    stk::SetTimeNowMsec(80);
    CHECK_FALSE(trigger.Poll()); // Accumulated 80ms
 
    // Re-constructing or manually resetting m_prev/m_elapsed
    // allows a "hard reset" to the current mock time.
    trigger = time::PeriodicTrigger(PERIOD, true);
 
    stk::SetTimeNowMsec(150);
    // Delta is only 70ms (150 - 80) since m_prev was set to 80 during reset/re-init.
    CHECK_FALSE(trigger.Poll());
}

References stk::time::PeriodicTrigger::Poll(), stk::test::stk::SetTimeNowMsec(), and TEST().

Here is the call graph for this function:

TEST() [97/143]

stk::test::TEST	(	PeriodicTrigger	,
		MustBeArmed	)

Definition at line 68 of file stktest_time.cpp.

{
    time::PeriodicTrigger trigger(PERIOD, false);
 
    stk::SetTimeNowMsec(50);
 
    try
    {
        g_TestContext.ExpectAssert(true);
        CHECK_FALSE(trigger.Poll());
        CHECK_TRUE(false); // Poll() must fail
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References g_TestContext, stk::time::PeriodicTrigger::Poll(), stk::test::stk::SetTimeNowMsec(), and TEST().

Here is the call graph for this function:

TEST() [98/143]

stk::test::TEST	(	PeriodicTrigger	,
		PreservesRemainderAfterFire	)

Definition at line 103 of file stktest_time.cpp.

{
    time::PeriodicTrigger trigger(PERIOD, true);
 
    // 1. Move to 150ms.
    // m_elapsed becomes 150. Poll() returns true.
    // m_elapsed becomes 150 - 100 = 50ms (the remainder).
    stk::SetTimeNowMsec(150);
    CHECK_TRUE(trigger.Poll());
 
    // 2. Move to 190ms.
    // Time delta is 40ms (190 - 150).
    // m_elapsed = 50 (remainder) + 40 (delta) = 90ms.
    stk::SetTimeNowMsec(190);
    CHECK_FALSE(trigger.Poll());
 
    // 3. Move to 205ms.
    // Time delta is 15ms (205 - 190).
    // m_elapsed = 90 + 15 = 105ms. Fires!
    stk::SetTimeNowMsec(205);
    CHECK_TRUE(trigger.Poll());
}

References stk::time::PeriodicTrigger::Poll(), stk::test::stk::SetTimeNowMsec(), and TEST().

Here is the call graph for this function:

TEST() [99/143]

stk::test::TEST	(	StackMemoryWrapper	,
		GetStack	)

Definition at line 169 of file stktest_misc.cpp.

{
    StackMemoryWrapper<STACK_SIZE_MIN>::MemoryType memory;
    StackMemoryWrapper<STACK_SIZE_MIN> wrapper(&memory);
 
    CHECK_TRUE(NULL != wrapper.GetStack());
    CHECK_EQUAL((Word *)&memory, wrapper.GetStack());
}

References stk::StackMemoryWrapper< _StackSize >::GetStack().

Here is the call graph for this function:

TEST() [100/143]

stk::test::TEST	(	StackMemoryWrapper	,
		GetStackSize	)

Definition at line 178 of file stktest_misc.cpp.

{
    StackMemoryWrapper<STACK_SIZE_MIN>::MemoryType memory;
    StackMemoryWrapper<STACK_SIZE_MIN> wrapper(&memory);
 
    CHECK_EQUAL(STACK_SIZE_MIN, wrapper.GetStackSize());
    CHECK_EQUAL(sizeof(memory) / sizeof(Word), wrapper.GetStackSize());
}

References stk::StackMemoryWrapper< _StackSize >::GetStackSize(), and stk::STACK_SIZE_MIN.

Here is the call graph for this function:

TEST() [101/143]

stk::test::TEST	(	StackMemoryWrapper	,
		GetStackSizeBytes	)

Definition at line 187 of file stktest_misc.cpp.

{
    StackMemoryWrapper<STACK_SIZE_MIN>::MemoryType memory;
    StackMemoryWrapper<STACK_SIZE_MIN> wrapper(&memory);
 
    CHECK_EQUAL(STACK_SIZE_MIN * sizeof(Word), wrapper.GetStackSizeBytes());
    CHECK_EQUAL(sizeof(memory), wrapper.GetStackSizeBytes());
}

References stk::StackMemoryWrapper< _StackSize >::GetStackSizeBytes(), and stk::STACK_SIZE_MIN.

Here is the call graph for this function:

TEST() [102/143]

stk::test::TEST	(	SwitchStrategyEDF	,
		Algorithm	)

Definition at line 124 of file stktest_switchstrategyedf.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 3, SwitchStrategyEDF, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2, task3;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
 
    // --- Stage 1: Add first task -----------------------------------------
 
    kernel.AddTask(&task1, 300, 300, 0);
 
    IKernelTask *next = strategy->GetFirst();
 
    // Single task -> always returned
    for (int32_t i = 0; i < 5; i++)
    {
        next = strategy->GetNext();
        CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "single task must always be selected");
    }
 
    // --- Stage 2: Add second task ----------------------------------------
 
    kernel.AddTask(&task2, 200, 200, 0); // earlier deadline than task1
 
    // EDF must pick the task with earliest relative deadline
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "task2 with earlier deadline should preempt task1");
 
    // Still highest-priority task keeps running until removed or asleep
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "task2 remains earliest-deadline task");
 
    // --- Stage 3: Add third task -----------------------------------------
 
    kernel.AddTask(&task3, 100, 100, 0); // earliest deadline
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "task3 with earliest deadline should run first");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "task3 continues to run as earliest-deadline task");
 
    // --- Stage 4: Remove tasks -------------------------------------------
 
    kernel.RemoveTask(&task3);
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "task2 becomes earliest-deadline after task3 removal");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "task2 continues as earliest-deadline task");
 
    kernel.RemoveTask(&task2);
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "task1 remains as only task");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetFirst(), stk::ITaskSwitchStrategy::GetNext(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::IKernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [103/143]

stk::test::TEST	(	SwitchStrategyEDF	,
		DynamicScheduling	)

Definition at line 285 of file stktest_switchstrategyedf.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 3, SwitchStrategyEDF, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2, task3;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
 
    // Add periodic tasks: (periodicity, deadline, start_delay)
    kernel.AddTask(&task1, 4, 4, 0); // task1: period 5
    kernel.AddTask(&task2, 3, 3, 0); // task2: period 3
    kernel.AddTask(&task3, 2, 2, 0); // task3: period 2
 
    kernel.Start();
 
    g_EDFDynamicSchedulingContext.platform = platform;
    g_EDFDynamicSchedulingContext.task1 = &task1;
    g_EDFDynamicSchedulingContext.task2 = &task2;
    g_EDFDynamicSchedulingContext.task3 = &task3;
    g_RelaxCpuHandler = g_EDFDynamicSchedulingContextProcess;
 
    // simulate ticks
    g_EDFDynamicSchedulingContextProcess();
 
    CHECK_EQUAL_TEXT(3, g_EDFDynamicSchedulingContext.checked, "all 3 tasks must be switched");
    CHECK_FALSE(platform->m_hard_fault);
    CHECK_EQUAL(0, task1.m_deadline_missed);
    CHECK_EQUAL(0, task2.m_deadline_missed);
    CHECK_EQUAL(0, task3.m_deadline_missed);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_EDFDynamicSchedulingContext, g_EDFDynamicSchedulingContextProcess(), g_RelaxCpuHandler, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::TaskMock< _AccessMode >::m_deadline_missed, stk::test::PlatformTestMock::m_hard_fault, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [104/143]

stk::test::TEST	(	SwitchStrategyEDF	,
		GetFirstEmpty	)

Definition at line 29 of file stktest_switchstrategyedf.cpp.

{
    SwitchStrategyEDF rr;
 
    try
    {
        g_TestContext.ExpectAssert(true);
        rr.GetFirst();
        CHECK_TEXT(false, "expecting assertion when empty");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References g_TestContext, and stk::SwitchStrategyEDF::GetFirst().

Here is the call graph for this function:

TEST() [105/143]

stk::test::TEST	(	SwitchStrategyEDF	,
		GetNextEmpty	)

Definition at line 46 of file stktest_switchstrategyedf.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategyEDF, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
 
    kernel.AddTask(&task1);
    kernel.RemoveTask(&task1);
    CHECK_EQUAL(0, strategy->GetSize());
 
    // expect to return NULL which puts core into a sleep mode, current is ignored by this strategy
    CHECK_EQUAL(0, strategy->GetNext());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetNext(), stk::ITaskSwitchStrategy::GetSize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [106/143]

stk::test::TEST	(	SwitchStrategyEDF	,
		OnTaskDeadlineMissedNotSupported	)

Definition at line 62 of file stktest_switchstrategyedf.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategyEDF, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
    kernel.AddTask(&task1);
 
    try
    {
        g_TestContext.ExpectAssert(true);
        strategy->OnTaskDeadlineMissed(strategy->GetFirst());
        CHECK_TEXT(false, "expecting assertion - OnTaskDeadlineMissed not supported");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    // we need this workaround to pass 100% coverage test by blocking the exception
    g_TestContext.ExpectAssert(true);
    g_TestContext.RethrowAssertException(false);
    strategy->OnTaskDeadlineMissed(strategy->GetFirst());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::ITaskSwitchStrategy::GetFirst(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::ITaskSwitchStrategy::OnTaskDeadlineMissed().

Here is the call graph for this function:

TEST() [107/143]

stk::test::TEST	(	SwitchStrategyEDF	,
		PriorityNext	)

Definition at line 89 of file stktest_switchstrategyedf.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 3, SwitchStrategyEDF, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2, task3;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
 
    // periodicity, deadline, start_delay
    kernel.AddTask(&task1, 300, 300, 0); // latest deadline
    kernel.AddTask(&task2, 200, 200, 0);
    kernel.AddTask(&task3, 100, 100, 0); // earliest deadline
 
    // EDF must select the task with the earliest relative deadline
    IKernelTask *next = strategy->GetNext();
 
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "EDF must select task with earliest relative deadline");
 
    // Repeated GetNext must still select the same task
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "EDF must continue selecting earliest-deadline task");
 
    // Remove earliest-deadline task
    kernel.RemoveTask(&task3);
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "after removal, task2 has earliest relative deadline");
 
    // Remove next earliest
    kernel.RemoveTask(&task2);
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "only remaining task must be selected");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetNext(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::IKernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [108/143]

stk::test::TEST	(	SwitchStrategyEDF	,
		RelativeDeadlineEvolution	)

Definition at line 183 of file stktest_switchstrategyedf.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 1, SwitchStrategyEDF, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
 
    kernel.Initialize();
 
    // period = 10, deadline = 5, start_delay = 0
    kernel.AddTask(&task, 10, 5, 0);
 
    kernel.Start();
 
    // Obtain kernel task
    IKernelTask *ktask = kernel.GetSwitchStrategy()->GetFirst();
    CHECK_TRUE_TEXT(ktask != nullptr, "Kernel task must exist");
 
    // --- At release -------------------------------------------------------
 
    // duration = 0
    // relative_deadline = deadline
    CHECK_EQUAL_TEXT(5, ktask->GetHrtRelativeDeadline(), "at release: relative deadline must equal deadline");
 
    // --- Tick 1 -----------------------------------------------------------
 
    platform->ProcessTick(); // duration = 1
    CHECK_EQUAL_TEXT(4, ktask->GetHrtRelativeDeadline(), "after 1 tick: relative deadline must decrease by 1");
 
    // --- Tick 2 -----------------------------------------------------------
 
    platform->ProcessTick(); // duration = 2
    CHECK_EQUAL_TEXT(3, ktask->GetHrtRelativeDeadline(), "after 2 ticks: relative deadline must decrease by 2");
 
    // --- Tick 3 -----------------------------------------------------------
 
    platform->ProcessTick(); // duration = 3
    CHECK_EQUAL_TEXT(2, ktask->GetHrtRelativeDeadline(), "after 3 ticks: relative deadline must decrease by 3");
 
    // --- Tick 4 -----------------------------------------------------------
 
    platform->ProcessTick(); // duration = 4
    CHECK_EQUAL_TEXT(1, ktask->GetHrtRelativeDeadline(), "after 4 ticks: relative deadline must be 1");
 
    // --- Tick 5 (deadline boundary) --------------------------------------
 
    platform->ProcessTick(); // duration = 5
    CHECK_EQUAL_TEXT(0, ktask->GetHrtRelativeDeadline(), "at deadline: relative deadline must be zero");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetFirst(), stk::IKernelTask::GetHrtRelativeDeadline(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [109/143]

stk::test::TEST	(	SwitchStrategyFixedPriority	,
		Algorithm	)

Definition at line 127 of file stktest_switchstrategyfpriority.cpp.

{
    // Create kernel with 3 tasks
    Kernel<KERNEL_DYNAMIC, 3, SwitchStrategyFP32, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2, task3;
 
    kernel.Initialize();
 
    // Add tasks
    kernel.AddTask(&task1);
 
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    IKernelTask *next = strategy->GetFirst();
 
    // --- Stage 1: 1 task only ---------------------------------------------
 
    // Always returns the same task
    for (int32_t i = 0; i < 5; i++)
    {
        next = strategy->GetNext();
        CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "Single task must always be selected");
    }
 
    // --- Stage 2: add second task -----------------------------------------
 
    kernel.AddTask(&task2);
 
    next = strategy->GetNext(); // should still return task1 as task2 will be scheduled after this call
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "Next task should be task1");
    next = strategy->GetNext(); // should return task2
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "Next task should be task2");
    next = strategy->GetNext(); // should wrap around to task1
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "Next task should wrap to task1");
 
    // --- Stage 3: add third task ------------------------------------------
 
    kernel.AddTask(&task3);
 
    // Expected sequence: task1 -> task2 -> task3 -> task1 ...
    next = strategy->GetNext(); // task2
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "Next task should be task2");
    next = strategy->GetNext(); // task3
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "Next task should be task3");
    next = strategy->GetNext(); // task1
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "Next task should wrap to task1");
 
    // --- Stage 4: remove a task -------------------------------------------
 
    kernel.RemoveTask(&task2);
 
    // Expected sequence: task1 -> task3 -> task1 -> task3 ...
    next = strategy->GetNext(); // task3
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "Next task should be task3 after removal");
    next = strategy->GetNext(); // task1
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "Next task should be task1 after removal");
    next = strategy->GetNext(); // task3
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "Next task should wrap to task3");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetFirst(), stk::ITaskSwitchStrategy::GetNext(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::IKernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [110/143]

stk::test::TEST	(	SwitchStrategyFixedPriority	,
		EndlessNext	)

Definition at line 89 of file stktest_switchstrategyfpriority.cpp.

{
    Kernel<KERNEL_DYNAMIC, 3, SwitchStrategyFP32, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2, task3;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.AddTask(&task3);
 
    IKernelTask *first = strategy->GetFirst();
    CHECK_EQUAL_TEXT(&task1, first->GetUserTask(), "expecting first task1");
 
    IKernelTask *next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "expecting next task1");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "expecting next task2");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "expecting next task3");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "expecting next task1 again (endless looping)");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "expecting next task2 again (endless looping)");
 
    kernel.RemoveTask(&task2);
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "expecting next task3 again (endless looping)");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "expecting next task1 again (endless looping)");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetFirst(), stk::ITaskSwitchStrategy::GetNext(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::IKernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [111/143]

stk::test::TEST	(	SwitchStrategyFixedPriority	,
		GetFirstEmpty	)

Definition at line 29 of file stktest_switchstrategyfpriority.cpp.

{
    SwitchStrategyFP32 rr;
 
    try
    {
        g_TestContext.ExpectAssert(true);
        rr.GetFirst();
        CHECK_TEXT(false, "expecting assertion when empty");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References g_TestContext, and stk::SwitchStrategyFixedPriority< MAX_PRIORITIES >::GetFirst().

Here is the call graph for this function:

TEST() [112/143]

stk::test::TEST	(	SwitchStrategyFixedPriority	,
		GetNextEmpty	)

Definition at line 46 of file stktest_switchstrategyfpriority.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategyFP32, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
 
    kernel.AddTask(&task1);
    kernel.RemoveTask(&task1);
    CHECK_EQUAL(0, strategy->GetSize());
 
    // expect to return NULL which puts core into a sleep mode, current is ignored by this strategy
    CHECK_EQUAL(0, strategy->GetNext());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetNext(), stk::ITaskSwitchStrategy::GetSize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [113/143]

stk::test::TEST	(	SwitchStrategyFixedPriority	,
		OnTaskDeadlineMissedNotSupported	)

Definition at line 62 of file stktest_switchstrategyfpriority.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategyFP32, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
    kernel.AddTask(&task1);
 
    try
    {
        g_TestContext.ExpectAssert(true);
        strategy->OnTaskDeadlineMissed(strategy->GetFirst());
        CHECK_TEXT(false, "expecting assertion - OnTaskDeadlineMissed not supported");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    // we need this workaround to pass 100% coverage test by blocking the exception
    g_TestContext.ExpectAssert(true);
    g_TestContext.RethrowAssertException(false);
    strategy->OnTaskDeadlineMissed(strategy->GetFirst());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::ITaskSwitchStrategy::GetFirst(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::ITaskSwitchStrategy::OnTaskDeadlineMissed().

Here is the call graph for this function:

TEST() [114/143]

stk::test::TEST	(	SwitchStrategyFixedPriority	,
		Priority	)

Definition at line 234 of file stktest_switchstrategyfpriority.cpp.

{
    Kernel<KERNEL_STATIC, 2, SwitchStrategyFixedPriority<5>, PlatformTestMock> kernel;
    TaskMockW<1, ACCESS_USER> task1; // low priority
    TaskMockW<2, ACCESS_USER> task2; // high priority
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&active = platform->m_stack_active;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    CHECK_EQUAL_TEXT(active->SP, (size_t)task2.GetStack(), "expecting high-priority task2 on start");
 
    platform->ProcessTick();
    CHECK_EQUAL_TEXT(active->SP, (size_t)task2.GetStack(), "expecting task2");
 
    g_RelaxCpuHandler = PrioritySleepRelaxCpu;
    g_PrioritySleepRelaxCpuContext.Clear();
    g_PrioritySleepRelaxCpuContext.platform = platform;
    g_PrioritySleepRelaxCpuContext.task1    = &task1;
    g_PrioritySleepRelaxCpuContext.task2    = &task2;
 
    // task2 calls Sleep to become idle
    Sleep(2);
 
    // task2 is active again
    CHECK_EQUAL_TEXT(active->SP, (size_t)task2.GetStack(), "expecting high-priority task2 again after it slept");
 
    // ISR calls OnSysTick, higher priority task2 is scheduled
    platform->ProcessTick();
    CHECK_EQUAL_TEXT(active->SP, (size_t)task2.GetStack(), "expecting high-priority task2 again");
 
    g_RelaxCpuHandler = NULL;
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_PrioritySleepRelaxCpuContext, g_RelaxCpuHandler, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, PrioritySleepRelaxCpu(), stk::test::PlatformTestMock::ProcessTick(), stk::Sleep(), stk::Stack::SP, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [115/143]

stk::test::TEST	(	SwitchStrategyMonotonic	,
		AlgorithmDM	)

Definition at line 245 of file stktest_switchstrategymonotonic.cpp.

{
    TestAlgorithm<SwitchStrategyDM>();
}

References TestAlgorithm().

Here is the call graph for this function:

TEST() [116/143]

stk::test::TEST	(	SwitchStrategyMonotonic	,
		AlgorithmRM	)

Definition at line 240 of file stktest_switchstrategymonotonic.cpp.

{
    TestAlgorithm<SwitchStrategyRM>();
}

References TestAlgorithm().

Here is the call graph for this function:

TEST() [117/143]

stk::test::TEST	(	SwitchStrategyMonotonic	,
		FailedWCRT	)

Definition at line 250 of file stktest_switchstrategymonotonic.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 2, SwitchStrategyRM, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    const SwitchStrategyRM *strategy = static_cast<const SwitchStrategyRM *>(kernel.GetSwitchStrategy());
 
    kernel.Initialize();
 
    // Overload CPU: C/T > RMUB
    kernel.AddTask(&task1, 50, 50, 0); // 100% CPU
    kernel.AddTask(&task2, 60, 30, 0); // additional load
 
    auto result = SchedulabilityCheck::IsSchedulableWCRT<2>(strategy);
 
    CHECK_EQUAL(100, result.info[0].cpu_load.total);
    CHECK_EQUAL(150, result.info[1].cpu_load.total);
 
    CHECK_FALSE_TEXT(result, "Task set should be unschedulable according to WCRT");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::SchedulabilityCheck::IsSchedulableWCRT().

Here is the call graph for this function:

TEST() [118/143]

stk::test::TEST	(	SwitchStrategyMonotonic	,
		GetFirstEmpty	)

Definition at line 29 of file stktest_switchstrategymonotonic.cpp.

{
    SwitchStrategyRM rr;
 
    try
    {
        g_TestContext.ExpectAssert(true);
        rr.GetFirst();
        CHECK_TEXT(false, "expecting assertion when empty");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References g_TestContext, and stk::SwitchStrategyMonotonic< _Type >::GetFirst().

Here is the call graph for this function:

TEST() [119/143]

stk::test::TEST	(	SwitchStrategyMonotonic	,
		GetNextEmpty	)

Definition at line 113 of file stktest_switchstrategymonotonic.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategyRM, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
 
    kernel.AddTask(&task1);
    kernel.RemoveTask(&task1);
    CHECK_EQUAL(0, strategy->GetSize());
 
    try
    {
        g_TestContext.ExpectAssert(true);
        strategy->GetNext();
        CHECK_TEXT(false, "expecting assertion when empty");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::ITaskSwitchStrategy::GetNext(), stk::ITaskSwitchStrategy::GetSize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [120/143]

stk::test::TEST	(	SwitchStrategyMonotonic	,
		OnTaskDeadlineMissedNotSupported	)

Definition at line 86 of file stktest_switchstrategymonotonic.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategyRM, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
    kernel.AddTask(&task1);
 
    try
    {
        g_TestContext.ExpectAssert(true);
        strategy->OnTaskDeadlineMissed(strategy->GetFirst());
        CHECK_TEXT(false, "expecting assertion - OnTaskDeadlineMissed not supported");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    // we need this workaround to pass 100% coverage test by blocking the exception
    g_TestContext.ExpectAssert(true);
    g_TestContext.RethrowAssertException(false);
    strategy->OnTaskDeadlineMissed(strategy->GetFirst());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::ITaskSwitchStrategy::GetFirst(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::ITaskSwitchStrategy::OnTaskDeadlineMissed().

Here is the call graph for this function:

TEST() [121/143]

stk::test::TEST	(	SwitchStrategyMonotonic	,
		PriorityNextDM	)

Definition at line 177 of file stktest_switchstrategymonotonic.cpp.

{
    TestPriorityNext<SwitchStrategyDM>();
}

References TestPriorityNext().

Here is the call graph for this function:

TEST() [122/143]

stk::test::TEST	(	SwitchStrategyMonotonic	,
		PriorityNextRM	)

Definition at line 172 of file stktest_switchstrategymonotonic.cpp.

{
    TestPriorityNext<SwitchStrategyRM>();
}

References TestPriorityNext().

Here is the call graph for this function:

TEST() [123/143]

stk::test::TEST	(	SwitchStrategyMonotonic	,
		SchedulableWCRT	)

Definition at line 270 of file stktest_switchstrategymonotonic.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 3, SwitchStrategyRM, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2, task3, task4;
    const SwitchStrategyRM *strategy = static_cast<const SwitchStrategyRM *>(kernel.GetSwitchStrategy());
 
    kernel.Initialize();
 
    // --- Stage 1: Schedulable tasks ---------------------------------------
 
    // Task parameters: T = task period, C = execution time
    kernel.AddTask(&task1, 40, 20, 0);  // task1: C=20, T=40
    kernel.AddTask(&task2, 100, 30, 0); // task2: C=30, T=100
    kernel.AddTask(&task3, 200, 10, 0); // task3: C=10, T=200
 
    auto result = SchedulabilityCheck::IsSchedulableWCRT<3>(strategy);
    CHECK_TEXT(result, "Task set should be schedulable according to WCRT");
 
    CHECK_EQUAL(50, result.info[0].cpu_load.total);
    CHECK_EQUAL(80, result.info[1].cpu_load.total);
    CHECK_EQUAL(85, result.info[2].cpu_load.total);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::SchedulabilityCheck::IsSchedulableWCRT().

Here is the call graph for this function:

TEST() [124/143]

stk::test::TEST	(	SwitchStrategyMonotonic	,
		SleepNotSupported	)

Definition at line 46 of file stktest_switchstrategymonotonic.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategyRM, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
    kernel.AddTask(&task1);
 
    try
    {
        g_TestContext.ExpectAssert(true);
        strategy->OnTaskSleep(strategy->GetFirst());
        CHECK_TEXT(false, "expecting assertion - OnTaskSleep not supported");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    try
    {
        g_TestContext.ExpectAssert(true);
        strategy->OnTaskWake(strategy->GetFirst());
        CHECK_TEXT(false, "expecting assertion - OnTaskWake not supported");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    // we need this workaround to pass 100% coverage test by blocking the exception
    g_TestContext.ExpectAssert(true);
    g_TestContext.RethrowAssertException(false);
    strategy->OnTaskSleep(strategy->GetFirst());
    strategy->OnTaskWake(strategy->GetFirst());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::ITaskSwitchStrategy::GetFirst(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::ITaskSwitchStrategy::OnTaskSleep(), and stk::ITaskSwitchStrategy::OnTaskWake().

Here is the call graph for this function:

TEST() [125/143]

stk::test::TEST	(	SwitchStrategyRoundRobin	,
		Algorithm	)

Definition at line 127 of file stktest_switchstrategyroundrobin.cpp.

{
    // Create kernel with 3 tasks
    Kernel<KERNEL_DYNAMIC, 3, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2, task3;
 
    kernel.Initialize();
 
    // Add tasks
    kernel.AddTask(&task1);
 
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    IKernelTask *next = strategy->GetFirst();
 
    // --- Stage 1: 1 task only ---------------------------------------------
 
    // Always returns the same task
    for (int32_t i = 0; i < 5; i++)
    {
        next = strategy->GetNext();
        CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "Single task must always be selected");
    }
 
    // --- Stage 2: add second task -----------------------------------------
 
    kernel.AddTask(&task2);
 
    next = strategy->GetNext(); // should still return task1 as task2 will be scheduled after this call
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "Next task should be task1");
    next = strategy->GetNext(); // should return task2
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "Next task should be task2");
    next = strategy->GetNext(); // should wrap around to task1
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "Next task should wrap to task1");
 
    // --- Stage 3: add third task ------------------------------------------
 
    kernel.AddTask(&task3);
 
    // Expected sequence: task1 -> task2 -> task3 -> task1 ...
    next = strategy->GetNext(); // task2
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "Next task should be task2");
    next = strategy->GetNext(); // task3
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "Next task should be task3");
    next = strategy->GetNext(); // task1
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "Next task should wrap to task1");
 
    // --- Stage 4: remove a task -------------------------------------------
 
    kernel.RemoveTask(&task2);
 
    // Expected sequence: task1 -> task3 -> task1 -> task3 ...
    next = strategy->GetNext(); // task3
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "Next task should be task3 after removal");
    next = strategy->GetNext(); // task1
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "Next task should be task1 after removal");
    next = strategy->GetNext(); // task3
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "Next task should wrap to task3");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetFirst(), stk::ITaskSwitchStrategy::GetNext(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::IKernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [126/143]

stk::test::TEST	(	SwitchStrategyRoundRobin	,
		EndlessNext	)

Definition at line 89 of file stktest_switchstrategyroundrobin.cpp.

{
    Kernel<KERNEL_DYNAMIC, 3, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2, task3;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.AddTask(&task3);
 
    IKernelTask *first = strategy->GetFirst();
    CHECK_EQUAL_TEXT(&task1, first->GetUserTask(), "expecting first task1");
 
    IKernelTask *next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "expecting next task1");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "expecting next task2");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "expecting next task3");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "expecting next task1 again (endless looping)");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "expecting next task2 again (endless looping)");
 
    kernel.RemoveTask(&task2);
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "expecting next task3 again (endless looping)");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "expecting next task1 again (endless looping)");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetFirst(), stk::ITaskSwitchStrategy::GetNext(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::IKernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [127/143]

stk::test::TEST	(	SwitchStrategyRoundRobin	,
		GetFirstEmpty	)

Definition at line 29 of file stktest_switchstrategyroundrobin.cpp.

{
    SwitchStrategyRR rr;
 
    try
    {
        g_TestContext.ExpectAssert(true);
        rr.GetFirst();
        CHECK_TEXT(false, "expecting assertion when empty");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References g_TestContext, and stk::SwitchStrategyRoundRobin::GetFirst().

Here is the call graph for this function:

TEST() [128/143]

stk::test::TEST	(	SwitchStrategyRoundRobin	,
		GetNextEmpty	)

Definition at line 46 of file stktest_switchstrategyroundrobin.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
 
    kernel.AddTask(&task1);
    kernel.RemoveTask(&task1);
    CHECK_EQUAL(0, strategy->GetSize());
 
    // expect to return NULL which puts core into a sleep mode, current is ignored by this strategy
    CHECK_EQUAL(0, strategy->GetNext());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetNext(), stk::ITaskSwitchStrategy::GetSize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [129/143]

stk::test::TEST	(	SwitchStrategyRoundRobin	,
		OnTaskDeadlineMissedNotSupported	)

Definition at line 62 of file stktest_switchstrategyroundrobin.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
    kernel.AddTask(&task1);
 
    try
    {
        g_TestContext.ExpectAssert(true);
        strategy->OnTaskDeadlineMissed(strategy->GetFirst());
        CHECK_TEXT(false, "expecting assertion - OnTaskDeadlineMissed not supported");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    // we need this workaround to pass 100% coverage test by blocking the exception
    g_TestContext.ExpectAssert(true);
    g_TestContext.RethrowAssertException(false);
    strategy->OnTaskDeadlineMissed(strategy->GetFirst());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::ITaskSwitchStrategy::GetFirst(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::ITaskSwitchStrategy::OnTaskDeadlineMissed().

Here is the call graph for this function:

TEST() [130/143]

stk::test::TEST	(	SwitchStrategySWRoundRobin	,
		Algorithm	)

Definition at line 160 of file stktest_switchstrategyswroundrobin.cpp.

{
    Kernel<KERNEL_DYNAMIC, 3, SwitchStrategySWRR, PlatformTestMock> kernel;
    TaskMockW<1, ACCESS_USER> task1; // weight 1
    TaskMockW<2, ACCESS_USER> task2; // weight 2
    TaskMockW<3, ACCESS_USER> task3; // weight 3
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.AddTask(&task3);
 
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
    IKernelTask *next = strategy->GetFirst();
 
    // scheduling stats
    int32_t count1 = 0, count2 = 0, count3 = 0;
 
    // Run enough steps to reach stable proportions
    const int32_t steps = 120; // increased steps for better statistical stability
    for (int32_t i = 0; i < steps; i++)
    {
        next = strategy->GetNext();
 
        if (next->GetUserTask() == &task1) ++count1;
        else if (next->GetUserTask() == &task2) ++count2;
        else if (next->GetUserTask() == &task3) ++count3;
        else CHECK_TEXT(false, "Unknown task selected");
    }
 
    const int32_t w1 = 1, w2 = 2, w3 = 3;
    const int32_t total_w = w1 + w2 + w3;
 
    const int32_t exp1 = (steps * w1) / total_w; // integer expected counts
    const int32_t exp2 = (steps * w2) / total_w;
    const int32_t exp3 = steps - exp1 - exp2;    // ensure sum == steps
 
    // Relative tolerance (fraction). 25% is conservative for small sample sizes.
    const float tol_frac = 0.25f;
 
    auto within_tol = [&](int expected, int actual, float frac) -> bool
    {
        int tol = (int)(expected * frac) + 1; // +1 to avoid zero tolerance for small expected
        int diff = expected > actual ? expected - actual : actual - expected;
        return diff <= tol;
    };
 
    CHECK_TRUE_TEXT(within_tol(exp1, count1, tol_frac), "Task1 proportion off (weight 1)");
    CHECK_TRUE_TEXT(within_tol(exp2, count2, tol_frac), "Task2 proportion off (weight 2)");
    CHECK_TRUE_TEXT(within_tol(exp3, count3, tol_frac), "Task3 proportion off (weight 3)");
 
    // Validate non-starvation: each must get at least one selection
    CHECK_TEXT(count1 > 0, "Task1 must run at least once");
    CHECK_TEXT(count2 > 0, "Task2 must run at least once");
    CHECK_TEXT(count3 > 0, "Task3 must run at least once");
 
    // Remove highest-weight task, check proportions adjust to 1:2
    kernel.RemoveTask(&task3);
 
    // reset counters and sample again
    count1 = count2 = 0;
 
    // advance next once to avoid stuck reference (optional)
    next = strategy->GetNext();
 
    for (int32_t i = 0; i < steps; i++)
    {
        next = strategy->GetNext();
 
        if      (next->GetUserTask() == &task1) ++count1;
        else if (next->GetUserTask() == &task2) ++count2;
        else    CHECK_TEXT(false, "Unknown task selected after removal");
    }
 
    const int32_t nw1 = 1, nw2 = 2;
    const int32_t ntotal = nw1 + nw2;
    const int32_t nexp1 = (steps * nw1) / ntotal;
    const int32_t nexp2 = steps - nexp1;
 
    CHECK_TRUE_TEXT(within_tol(nexp1, count1, tol_frac), "Task1 proportion off after removal");
    CHECK_TRUE_TEXT(within_tol(nexp2, count2, tol_frac), "Task2 proportion off after removal");
 
    CHECK_TEXT(count1 > 0, "Task1 must run after removal");
    CHECK_TEXT(count2 > 0, "Task2 must run after removal");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetFirst(), stk::ITaskSwitchStrategy::GetNext(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::IKernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [131/143]

stk::test::TEST	(	SwitchStrategySWRoundRobin	,
		EndlessNext	)

Definition at line 89 of file stktest_switchstrategyswroundrobin.cpp.

{
    Kernel<KERNEL_DYNAMIC, 3, SwitchStrategySWRR, PlatformTestMock> kernel;
    TaskMockW<1, ACCESS_USER> task1, task2, task3;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
 
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    IKernelTask *next = strategy->GetFirst();
 
    // --- Stage 1: 1 task only ---------------------------------------------
 
    // The scheduler must ALWAYS return task1
    for (int32_t i = 0; i < 10; i++)
    {
        next = strategy->GetNext();
        CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "Single task must always be selected");
    }
 
    // --- Stage 2: add second task -----------------------------------------
 
    kernel.AddTask(&task2);
 
    // Both tasks must appear, and none should be starved
    bool seen1 = false;
    bool seen2 = false;
    for (int i = 0; i < 10; i++)
    {
        next = strategy->GetNext();
        if (next->GetUserTask() == &task1) seen1 = true;
        if (next->GetUserTask() == &task2) seen2 = true;
    }
    CHECK_TEXT(seen1, "Task1 must be selected after adding Task2");
    CHECK_TEXT(seen2, "Task2 must be selected after adding Task2");
 
    // --- Stage 3: add third task ------------------------------------------
 
    kernel.AddTask(&task3);
 
    seen1 = seen2 = false;
    bool seen3 = false;
    for (int32_t i = 0; i < 20; i++)
    {
        next = strategy->GetNext();
        if (next->GetUserTask() == &task1) seen1 = true;
        if (next->GetUserTask() == &task2) seen2 = true;
        if (next->GetUserTask() == &task3) seen3 = true;
    }
 
    CHECK_TEXT(seen1, "Task1 must run after adding Task3");
    CHECK_TEXT(seen2, "Task2 must run after adding Task3");
    CHECK_TEXT(seen3, "Task3 must run after adding Task3");
 
    // --- Stage 4: remove task1 --------------------------------------------
 
    kernel.RemoveTask(&task1);
 
    seen2 = seen3 = false;
    for (int32_t i = 0; i < 10; i++)
    {
        next = strategy->GetNext();
        if (next->GetUserTask() == &task2) seen2 = true;
        if (next->GetUserTask() == &task3) seen3 = true;
        CHECK_TEXT(next->GetUserTask() != &task1, "Task1 must not be selected after removal");
    }
    CHECK_TEXT(seen2, "Task2 must run after removing Task1");
    CHECK_TEXT(seen3, "Task3 must run after removing Task1");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetFirst(), stk::ITaskSwitchStrategy::GetNext(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::IKernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [132/143]

stk::test::TEST	(	SwitchStrategySWRoundRobin	,
		GetFirstEmpty	)

Definition at line 29 of file stktest_switchstrategyswroundrobin.cpp.

{
    SwitchStrategySWRR rr;
 
    try
    {
        g_TestContext.ExpectAssert(true);
        rr.GetFirst();
        CHECK_TEXT(false, "expecting assertion when empty");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References g_TestContext, and stk::SwitchStrategySmoothWeightedRoundRobin::GetFirst().

Here is the call graph for this function:

TEST() [133/143]

stk::test::TEST	(	SwitchStrategySWRoundRobin	,
		GetNextEmpty	)

Definition at line 46 of file stktest_switchstrategyswroundrobin.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategySWRR, PlatformTestMock> kernel;
    TaskMockW<1, ACCESS_USER> task1;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
 
    kernel.AddTask(&task1);
    kernel.RemoveTask(&task1);
    CHECK_EQUAL(0, strategy->GetSize());
 
    // expect to return NULL which puts core into a sleep mode, current is ignored by this strategy
    CHECK_EQUAL(0, strategy->GetNext());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetNext(), stk::ITaskSwitchStrategy::GetSize(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Here is the call graph for this function:

TEST() [134/143]

stk::test::TEST	(	SwitchStrategySWRoundRobin	,
		OnTaskDeadlineMissedNotSupported	)

Definition at line 62 of file stktest_switchstrategyswroundrobin.cpp.

{
    Kernel<KERNEL_DYNAMIC, 1, SwitchStrategySWRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
    kernel.AddTask(&task1);
 
    try
    {
        g_TestContext.ExpectAssert(true);
        strategy->OnTaskDeadlineMissed(strategy->GetFirst());
        CHECK_TEXT(false, "expecting assertion - OnTaskDeadlineMissed not supported");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
 
    // we need this workaround to pass 100% coverage test by blocking the exception
    g_TestContext.ExpectAssert(true);
    g_TestContext.RethrowAssertException(false);
    strategy->OnTaskDeadlineMissed(strategy->GetFirst());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_TestContext, stk::ITaskSwitchStrategy::GetFirst(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::ITaskSwitchStrategy::OnTaskDeadlineMissed().

Here is the call graph for this function:

TEST() [135/143]

stk::test::TEST	(	Sync	,
		CriticalSection	)

Definition at line 25 of file stktest_sync.cpp.

{
    CHECK_EQUAL(0, test::g_CriticalSectionState);
    {
        sync::ScopedCriticalSection cs;
        CHECK_EQUAL(1, test::g_CriticalSectionState);
    }
    CHECK_EQUAL(0, test::g_CriticalSectionState);
}

References g_CriticalSectionState.

TEST() [136/143]

stk::test::TEST	(	Sync	,
		IMutex_ScopedLock	)

Definition at line 35 of file stktest_sync.cpp.

{
    MutexMock mutex;
    {
        MutexMock::ScopedLock guard(mutex);
        CHECK_TRUE(mutex.m_locked);
    }
    CHECK_FALSE(mutex.m_locked);
}

TEST() [137/143]

stk::test::TEST	(	Sync	,
		SyncWait_Wake	)

Definition at line 79 of file stktest_sync.cpp.

{
    Kernel<KERNEL_STATIC | KERNEL_SYNC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    TaskMock<ACCESS_USER> task;
 
    MutexMock mutex;
    SyncObjectMock sobj;
 
    g_SyncWaitWakeRelaxCpuContext.platform = platform;
    g_SyncWaitWakeRelaxCpuContext.sobj     = &sobj;
    g_RelaxCpuHandler = SyncWaitWakeRelaxCpu;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    MutexMock::ScopedLock guard(mutex);
 
    // short wait in order to get wait object for a Wake testing
    IWaitObject *wo = IKernelService::GetInstance()->Wait(&sobj, &mutex, 10);
    CHECK_TRUE(wo != nullptr); // expect wait object in return after timeout
 
    // woken by WakeOne() on 5th tick, became active on 6th (see SyncWaitWakeRelaxCpuContext::Process)
    CHECK_EQUAL(6, g_SyncWaitWakeRelaxCpuContext.counter);
    CHECK_FALSE(wo->IsTimeout()); // expect no timeout
    CHECK_EQUAL(true, mutex.m_locked); // expect locked mutex after Wait return
 
    g_SyncWaitWakeRelaxCpuContext.counter  = 0;
    g_SyncWaitWakeRelaxCpuContext.wake_all = true;
 
    // repeat for WakeAll()
    wo = IKernelService::GetInstance()->Wait(&sobj, &mutex, 10);
    CHECK_TRUE(wo != nullptr); // expect wait object in return after timeout
 
    // woken by WakeAll() on 7th tick, became active on 8th (see SyncWaitWakeRelaxCpuContext::Process)
    CHECK_EQUAL(8, g_SyncWaitWakeRelaxCpuContext.counter);
    CHECK_FALSE(wo->IsTimeout()); // expect no timeout
    CHECK_EQUAL(true, mutex.m_locked); // expect locked mutex after Wait return
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_RelaxCpuHandler, g_SyncWaitWakeRelaxCpuContext, stk::IKernelService::GetInstance(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::IWaitObject::IsTimeout(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start(), SyncWaitWakeRelaxCpu(), and stk::IKernelService::Wait().

Here is the call graph for this function:

TEST() [138/143]

stk::test::TEST	(	UserTask	,
		GetIdAndName	)

Definition at line 132 of file stktest_misc.cpp.

{
    TaskMock<ACCESS_USER> task;
    TaskMockW<1, ACCESS_USER> taskw;
 
    CHECK_EQUAL((Word)&task, task.GetId());
    CHECK_EQUAL((Word)&taskw, taskw.GetId());
 
    // expect NULL name by default
    CHECK_EQUAL((const char *)NULL, task.GetTraceName());
    CHECK_EQUAL((const char *)NULL, taskw.GetTraceName());
}

References stk::Task< _StackSize, _AccessMode >::GetId(), stk::TaskW< _Weight, _StackSize, _AccessMode >::GetId(), stk::Task< _StackSize, _AccessMode >::GetTraceName(), and stk::TaskW< _Weight, _StackSize, _AccessMode >::GetTraceName().

Here is the call graph for this function:

TEST() [139/143]

stk::test::TEST	(	UserTask	,
		GetStackSize	)

Definition at line 75 of file stktest_misc.cpp.

{
    TaskMock<ACCESS_USER> task;
    TaskMockW<1, ACCESS_USER> taskw;
 
    CHECK_EQUAL(TaskMock<ACCESS_USER>::STACK_SIZE, task.GetStackSize());
    CHECK_EQUAL(TaskMock<ACCESS_USER>::STACK_SIZE, taskw.GetStackSize());
}

References stk::Task< _StackSize, _AccessMode >::GetStackSize(), stk::TaskW< _Weight, _StackSize, _AccessMode >::GetStackSize(), and stk::Task< STACK_SIZE_MIN, _AccessMode >::STACK_SIZE.

Here is the call graph for this function:

TEST() [140/143]

stk::test::TEST	(	UserTask	,
		GetStackSizeBytes	)

Definition at line 84 of file stktest_misc.cpp.

{
    TaskMock<ACCESS_USER> task;
    TaskMockW<1, ACCESS_USER> taskw;
 
    CHECK_EQUAL(TaskMock<ACCESS_USER>::STACK_SIZE * sizeof(Word), task.GetStackSizeBytes());
    CHECK_EQUAL(TaskMock<ACCESS_USER>::STACK_SIZE * sizeof(Word), taskw.GetStackSizeBytes());
}

References stk::Task< _StackSize, _AccessMode >::GetStackSizeBytes(), stk::TaskW< _Weight, _StackSize, _AccessMode >::GetStackSizeBytes(), and stk::Task< STACK_SIZE_MIN, _AccessMode >::STACK_SIZE.

Here is the call graph for this function:

TEST() [141/143]

stk::test::TEST	(	UserTask	,
		GetStackSpace	)

Definition at line 93 of file stktest_misc.cpp.

{
    Kernel<KERNEL_STATIC, 1, SwitchStrategyRR, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task;
 
    // not initialized with STK_STACK_MEMORY_FILLER
    CHECK_EQUAL(0, task.GetStackSpace());
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    size_t space = task.GetStackSpace();
 
    // initialized with STK_STACK_MEMORY_FILLER, all free
    CHECK_EQUAL(TaskMock<ACCESS_USER>::STACK_SIZE, space);
 
    // write something to bottom
    task.GetStack()[task.GetStackSize() - 1] = 0x12345678;
    task.GetStack()[task.GetStackSize() - 2] = 0x12345678;
 
    space = task.GetStackSpace();
 
    // consumed 1 Word
    CHECK_EQUAL(TaskMock<ACCESS_USER>::STACK_SIZE - 2, space);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::Task< _StackSize, _AccessMode >::GetStackSize(), stk::IStackMemory::GetStackSpace(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::Task< STACK_SIZE_MIN, _AccessMode >::STACK_SIZE, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Here is the call graph for this function:

TEST() [142/143]

stk::test::TEST	(	UserTask	,
		GetWeight	)

Definition at line 120 of file stktest_misc.cpp.

{
    TaskMock<ACCESS_USER> task;
    TaskMockW<10, ACCESS_USER> taskw;
 
    // TaskMock inherits Task and Task does not support weights (1)
    CHECK_EQUAL(1, task.GetWeight());
 
    // TaskMockW supports weights as it inherits TaskW
    CHECK_EQUAL(10, taskw.GetWeight());
}

References stk::Task< _StackSize, _AccessMode >::GetWeight(), and stk::TaskW< _Weight, _StackSize, _AccessMode >::GetWeight().

Here is the call graph for this function:

TEST() [143/143]

stk::test::TEST	(	UserTask	,
		TaskWUnsupportedHrt	)

Definition at line 145 of file stktest_misc.cpp.

{
    TaskMockW<10, ACCESS_USER> taskw;
 
    try
    {
        g_TestContext.ExpectAssert(true);
        // on next tick kernel will attempt to remove pending task and will check its deadline
        taskw.OnDeadlineMissed(0);
        CHECK_TEXT(false, "expecting assertion - task with weights do not support HRT");
    }
    catch (TestAssertPassed &pass)
    {
        CHECK(true);
        g_TestContext.ExpectAssert(false);
    }
}

References g_TestContext, and stk::TaskW< _Weight, _StackSize, _AccessMode >::OnDeadlineMissed().

Here is the call graph for this function:

TEST_GROUP() [1/14]

stk::test::TEST_GROUP

(

Basic

)

Definition at line 19 of file stktest_misc.cpp.

{
    void setup() {}
    void teardown() {}
};

TEST_GROUP() [2/14]

stk::test::TEST_GROUP

(

DList

)

Definition at line 196 of file stktest_misc.cpp.

{
    void setup() {}
    void teardown() {}
 
    struct ListEntry : public stk::util::DListEntry<ListEntry, true>
    {
        int32_t m_id;
        ListEntry(int32_t id) : m_id(id) {}
    };
 
    typedef stk::util::DListHead<ListEntry, true> ListHead;
};

TEST_GROUP() [3/14]

stk::test::TEST_GROUP

(

Kernel

)

Definition at line 45 of file stktest_kernel.cpp.

{
    void setup() {}
    void teardown()
    {
        g_TestContext.RethrowAssertException(true);
        g_TestContext.ExpectAssert(false);
        g_TestContext.ExpectPanic(false);
        test::g_PanicValue = KERNEL_PANIC_NONE;
    }
};

References g_PanicValue, g_TestContext, and stk::KERNEL_PANIC_NONE.

Referenced by TEST_GROUP().

Here is the caller graph for this function:

TEST_GROUP() [4/14]

stk::test::TEST_GROUP

(

KernelService

)

Definition at line 19 of file stktest_kernelservice.cpp.

{
    void setup() {}
    void teardown()
    {
        g_RelaxCpuHandler = NULL;
    }
};

References g_RelaxCpuHandler.

TEST_GROUP() [5/14]

stk::test::TEST_GROUP

(

KernelServiceIsrSafety

)

Definition at line 667 of file stktest_kernelservice.cpp.

{
    void setup()
    {
        g_RelaxCpuHandler = DelayRelaxCpu;
        g_InsideISR = true;
    }
    void teardown()
    {
        g_InsideISR = false;
        g_DelayContext.Clear();
        g_RelaxCpuHandler = NULL;
    }
};

References DelayRelaxCpu(), g_DelayContext, g_InsideISR, and g_RelaxCpuHandler.

Here is the call graph for this function:

TEST_GROUP() [6/14]

stk::test::TEST_GROUP

(

PeriodicTrigger

)

Definition at line 58 of file stktest_time.cpp.

{
    enum { PERIOD = 100 };
 
    void setup()
    {
        stk::SetTimeNowMsec(0);
    }
};

References stk::test::stk::SetTimeNowMsec(), and TEST_GROUP().

Here is the call graph for this function:

TEST_GROUP() [7/14]

stk::test::TEST_GROUP

(

StackMemoryWrapper

)

Definition at line 163 of file stktest_misc.cpp.

{
    void setup() {}
    void teardown() {}
};

TEST_GROUP() [8/14]

stk::test::TEST_GROUP

(

SwitchStrategyEDF

)

Definition at line 19 of file stktest_switchstrategyedf.cpp.

{
    void setup() {}
    void teardown()
    {
        g_TestContext.ExpectAssert(false);
        g_TestContext.RethrowAssertException(true);
    }
};

References g_TestContext.

TEST_GROUP() [9/14]

stk::test::TEST_GROUP

(

SwitchStrategyFixedPriority

)

Definition at line 19 of file stktest_switchstrategyfpriority.cpp.

{
    void setup() {}
    void teardown()
    {
        g_TestContext.ExpectAssert(false);
        g_TestContext.RethrowAssertException(true);
    }
};

References g_TestContext.

TEST_GROUP() [10/14]

stk::test::TEST_GROUP

(

SwitchStrategyMonotonic

)

Definition at line 19 of file stktest_switchstrategymonotonic.cpp.

{
    void setup() {}
    void teardown()
    {
        g_TestContext.ExpectAssert(false);
        g_TestContext.RethrowAssertException(true);
    }
};

References g_TestContext.

TEST_GROUP() [11/14]

stk::test::TEST_GROUP

(

SwitchStrategyRoundRobin

)

Definition at line 19 of file stktest_switchstrategyroundrobin.cpp.

{
    void setup() {}
    void teardown()
    {
        g_TestContext.ExpectAssert(false);
        g_TestContext.RethrowAssertException(true);
    }
};

References g_TestContext.

TEST_GROUP() [12/14]

stk::test::TEST_GROUP

(

SwitchStrategySWRoundRobin

)

Definition at line 19 of file stktest_switchstrategyswroundrobin.cpp.

{
    void setup() {}
    void teardown()
    {
        g_TestContext.ExpectAssert(false);
        g_TestContext.RethrowAssertException(true);
    }
};

References g_TestContext.

TEST_GROUP() [13/14]

stk::test::TEST_GROUP

(

Sync

)

Definition at line 19 of file stktest_sync.cpp.

{
    void setup() {}
    void teardown() {}
};

TEST_GROUP() [14/14]

stk::test::TEST_GROUP

(

UserTask

)

Definition at line 69 of file stktest_misc.cpp.

{
    void setup() {}
    void teardown() {}
};

Test_SyncWait()

template<bool TTickless>

void stk::test::Test_SyncWait

(

)

Definition at line 1475 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_STATIC | KERNEL_SYNC | (TTickless ? KERNEL_TICKLESS : 0), 1, SwitchStrategyRR, PlatformTestMock> kernel;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    TaskMock<ACCESS_USER> task;
 
    MutexMock mutex;
    SyncObjectMock sobj;
 
    g_SyncWaitRelaxCpuContext.Reset();
    g_SyncWaitRelaxCpuContext.platform = platform;
    g_RelaxCpuHandler = SyncWaitRelaxCpu;
 
    kernel.Initialize();
    kernel.AddTask(&task);
    kernel.Start();
 
    MutexMock::ScopedLock guard(mutex);
 
    IWaitObject *wo = IKernelService::GetInstance()->Wait(&sobj, &mutex, 2);
 
    CHECK_EQUAL(GetTid(), wo->GetTid()); // expect the same thread id as WaitObject belongs to the caller's task
    CHECK_TRUE(wo != nullptr); // expect wait object in return after timeout
    CHECK_TRUE(wo->IsTimeout()); // expect timeout
    CHECK_EQUAL(2, g_SyncWaitRelaxCpuContext.counter); // expect 2 ticks after timeout
    CHECK_EQUAL(true, mutex.m_locked); // expect locked mutex after Wait return
}

References g_RelaxCpuHandler, g_SyncWaitRelaxCpuContext, stk::IKernelService::GetInstance(), stk::GetTid(), stk::IWaitObject::GetTid(), stk::IWaitObject::IsTimeout(), stk::KERNEL_STATIC, stk::KERNEL_SYNC, stk::KERNEL_TICKLESS, SyncWaitRelaxCpu(), and stk::IKernelService::Wait().

Referenced by TEST(), and TEST().

Here is the call graph for this function:

Here is the caller graph for this function:

TestAlgorithm()

template<class _SwitchStrategy>

void stk::test::TestAlgorithm ( )

static

Definition at line 183 of file stktest_switchstrategymonotonic.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 3, _SwitchStrategy, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2, task3;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
 
    // --- Stage 1: Add first task -----------------------------------------
 
    kernel.AddTask(&task1, 300, 300, 0);
 
    IKernelTask *next = strategy->GetFirst();
 
    // Single task -> always returned
    for (int32_t i = 0; i < 5; i++)
    {
        next = strategy->GetNext();
        CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "Single task must always be selected");
    }
 
    // --- Stage 2: Add second task ----------------------------------------
 
    kernel.AddTask(&task2, 200, 200, 0); // higher priority than task1
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "Higher priority task2 should preempt task1");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "Highest priority task always runs");
 
    // --- Stage 3: Add third task -----------------------------------------
 
    kernel.AddTask(&task3, 100, 100, 0); // highest priority
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "Highest priority task3 should run first");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "Highest priority task always runs");
 
    // --- Stage 4: Remove a task ------------------------------------------
 
    kernel.RemoveTask(&task3);
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "task2 becomes highest priority after task3 removal");
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "task2 remains highest priority");
 
    kernel.RemoveTask(&task2);
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "task1 remains as only task");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetFirst(), stk::ITaskSwitchStrategy::GetNext(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::IKernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Referenced by TEST(), and TEST().

Here is the call graph for this function:

Here is the caller graph for this function:

TestHrtTaskExitDuringSleepState()

template<class _SwitchStrategy>

void stk::test::TestHrtTaskExitDuringSleepState ( )

static

Definition at line 1135 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 2, _SwitchStrategy, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    const _SwitchStrategy *strategy = static_cast<const _SwitchStrategy *>(kernel.GetSwitchStrategy());
 
    kernel.Initialize();
    kernel.AddTask(&task1, 1, 2, 0);
    kernel.AddTask(&task2, 1, 2, 2);
    kernel.Start();
 
    // task1 is the first
    CHECK_EQUAL((Word)task1.GetStack(), platform->m_stack_active->SP);
 
    // task returns (exiting) without calling SwitchToNext
    platform->EventTaskExit(platform->m_stack_active);
 
    platform->ProcessTick(); // schedules task removal but task2 is still sleeping
 
    // here scheduler is sleeping because task1 was sent to infinite sleep until removal and task2 is still pending
 
    platform->ProcessTick(); // task2 is still sleeping
    platform->ProcessTick(); // switched to task2
 
    CHECK_EQUAL((Word)task2.GetStack(), platform->m_stack_active->SP);
 
    CHECK_EQUAL(1, strategy->GetSize());
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::test::PlatformTestMock::EventTaskExit(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::ProcessTick(), stk::Stack::SP, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Referenced by TEST(), TEST(), TEST(), and TEST().

Here is the call graph for this function:

Here is the caller graph for this function:

TestPriorityNext()

template<class _SwitchStrategy>

void stk::test::TestPriorityNext ( )

static

Definition at line 139 of file stktest_switchstrategymonotonic.cpp.

{
    Kernel<KERNEL_DYNAMIC | KERNEL_HRT, 3, _SwitchStrategy, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2, task3;
    ITaskSwitchStrategy *strategy = kernel.GetSwitchStrategy();
 
    kernel.Initialize();
 
    kernel.AddTask(&task1, 300, 300, 0);
    kernel.AddTask(&task3, 100, 100, 0);
    kernel.AddTask(&task2, 200, 200, 0);
 
    // Highest priority task must be selected first
    IKernelTask *next = strategy->GetFirst();
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "task3 must be selected as highest priority");
 
    // GetNext must always return highest-priority READY task
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task3, next->GetUserTask(), "Highest priority task must repeat (no round-robin)");
 
    // Remove highest priority
    kernel.RemoveTask(&task3);
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task2, next->GetUserTask(), "task2 becomes highest priority after task3 removal");
 
    // Remove next highest
    kernel.RemoveTask(&task2);
 
    next = strategy->GetNext();
    CHECK_EQUAL_TEXT(&task1, next->GetUserTask(), "task1 remains as only task");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::ITaskSwitchStrategy::GetFirst(), stk::ITaskSwitchStrategy::GetNext(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetSwitchStrategy(), stk::IKernelTask::GetUserTask(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::RemoveTask().

Referenced by TEST(), and TEST().

Here is the call graph for this function:

Here is the caller graph for this function:

TestTaskExit()

template<class _SwitchStrategy>

void stk::test::TestTaskExit ( )

static

Definition at line 598 of file stktest_kernel.cpp.

{
    Kernel<KERNEL_DYNAMIC, 2, _SwitchStrategy, PlatformTestMock> kernel;
    TaskMock<ACCESS_PRIVILEGED> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&idle = platform->m_stack_idle, *&active = platform->m_stack_active;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    // ISR calls OnSysTick (task1 = idle, task2 = active)
    platform->ProcessTick();
 
    // task2 exited (will schedule its removal)
    platform->EventTaskExit(active);
 
    // ISR calls OnSysTick (task2 = idle, task1 = active)
    platform->ProcessTick();
 
    // task1 exited (will schedule its removal)
    platform->EventTaskExit(active);
 
    // ISR calls OnSysTick
    platform->ProcessTick();
 
    // last task is removed
    platform->ProcessTick();
    platform->ProcessTick();
 
    // no Idle tasks left
    CHECK_EQUAL((Stack *)NULL, idle);
 
    // Exit trap stack is provided for a long jump to the end of Kernel::Start()
    CHECK_EQUAL(platform->m_exit_trap, active);
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), stk::test::PlatformTestMock::EventTaskExit(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_exit_trap, stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::m_stack_idle, stk::test::PlatformTestMock::ProcessTick(), and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Referenced by TEST(), TEST(), and TEST().

Here is the call graph for this function:

Here is the caller graph for this function:

TestTaskSleep()

template<class _SwitchStrategy>

void stk::test::TestTaskSleep ( bool until )

static

Definition at line 399 of file stktest_kernelservice.cpp.

{
    Kernel<KERNEL_STATIC, 2, _SwitchStrategy, PlatformTestMock> kernel;
    TaskMock<ACCESS_USER> task1, task2;
    PlatformTestMock *platform = static_cast<PlatformTestMock *>(kernel.GetPlatform());
    Stack *&active = platform->m_stack_active;
 
    kernel.Initialize();
    kernel.AddTask(&task1);
    kernel.AddTask(&task2);
    kernel.Start();
 
    // on start Round-Robin selects the very first task
    CHECK_EQUAL_TEXT(active->SP, (size_t)task1.GetStack(), "expecting task1");
 
    // ISR calls OnSysTick (task1 = idle, task2 = active)
    platform->ProcessTick();
    CHECK_EQUAL_TEXT(active->SP, (size_t)task2.GetStack(), "expecting task2");
 
    g_RelaxCpuHandler = SleepRelaxCpu;
    g_SleepRelaxCpuContext.Clear();
    g_SleepRelaxCpuContext.platform = platform;
    g_SleepRelaxCpuContext.task1    = &task1;
    g_SleepRelaxCpuContext.task2    = &task2;
 
    // task2 calls Sleep to become idle
    if (until)
    {
        SleepUntil(GetTicks() + 2);
    }
    else
    {
        Sleep(2);
    }
 
    // task2 slept 2 ticks and became active again when became a tail of previously active task1
    CHECK_EQUAL_TEXT(active->SP, (size_t)task2.GetStack(), "expecting task2 after sleep");
 
    // ISR calls OnSysTick (task1 = active, task2 = idle)
    platform->ProcessTick();
    CHECK_EQUAL_TEXT(active->SP, (size_t)task1.GetStack(), "expecting task1 after next tick");
}

References stk::Kernel< TMode, TSize, TStrategy, TPlatform >::AddTask(), g_RelaxCpuHandler, g_SleepRelaxCpuContext, stk::Kernel< TMode, TSize, TStrategy, TPlatform >::GetPlatform(), stk::Task< _StackSize, _AccessMode >::GetStack(), stk::GetTicks(), stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Initialize(), stk::test::PlatformTestMock::m_stack_active, stk::test::PlatformTestMock::ProcessTick(), stk::Sleep(), SleepRelaxCpu(), stk::SleepUntil(), stk::Stack::SP, and stk::Kernel< TMode, TSize, TStrategy, TPlatform >::Start().

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

g_AddTaskWhenStartedRelaxCpuContext

struct stk::test::AddTaskWhenStartedRelaxCpuContext stk::test::g_AddTaskWhenStartedRelaxCpuContext

static

Referenced by AddTaskWhenStartedRelaxCpu(), and TEST().

g_CriticalSectionState

int32_t stk::test::g_CriticalSectionState = false

extern

Critical section state.

Definition at line 19 of file stktest.cpp.

Referenced by stk::hw::CriticalSection::Enter(), stk::hw::CriticalSection::Exit(), and TEST().

g_DelayContext

struct stk::test::DelayContext stk::test::g_DelayContext

static

Referenced by DelayRelaxCpu(), TEST(), TEST(), TEST(), and TEST_GROUP().

g_EDFDynamicSchedulingContext

struct stk::test::EDFDynamicSchedulingContext stk::test::g_EDFDynamicSchedulingContext

static

Referenced by g_EDFDynamicSchedulingContextProcess(), and TEST().

g_HrtTaskDeadlineMissedRelaxCpuContext

struct stk::test::HrtTaskDeadlineMissedRelaxCpuContext stk::test::g_HrtTaskDeadlineMissedRelaxCpuContext

static

Referenced by HrtTaskDeadlineMissedRelaxCpu(), TEST(), TEST(), and TEST().

g_InsideISR

bool stk::test::g_InsideISR = false

extern

ISR state.

Definition at line 21 of file stktest.cpp.

Referenced by stk::hw::IsInsideISR(), and TEST_GROUP().

g_KernelService

IKernelService * stk::test::g_KernelService = NULL

extern

Definition at line 18 of file stktest.cpp.

Referenced by stk::IKernelService::GetInstance(), stk::test::PlatformTestMock::Initialize(), stk::test::stk::SetTimeNowMsec(), TEST(), TEST(), TEST(), TEST(), TEST(), and stk::test::PlatformTestMock::~PlatformTestMock().

g_PanicValue

EKernelPanicId stk::test::g_PanicValue = KERNEL_PANIC_NONE

extern

Panic value.

Definition at line 20 of file stktest.cpp.

Referenced by STK_PANIC_HANDLER_DEFAULT(), TEST(), TEST(), and TEST_GROUP().

g_PrioritySleepRelaxCpuContext

struct stk::test::PrioritySleepRelaxCpuContext stk::test::g_PrioritySleepRelaxCpuContext

static

Referenced by PrioritySleepRelaxCpu(), and TEST().

g_SleepAllAndWakeRelaxCpuContext

struct stk::test::SleepAllAndWakeRelaxCpuContext stk::test::g_SleepAllAndWakeRelaxCpuContext

static

Referenced by SleepAllAndWakeRelaxCpu(), and TEST().

g_SleepAndWakeTicklessRelaxCpuContext

struct stk::test::SleepAndWakeTicklessRelaxCpuContext stk::test::g_SleepAndWakeTicklessRelaxCpuContext

static

Referenced by SleepAndWakeTicklessRelaxCpu(), and TEST().

g_SleepRelaxCpuContext

struct stk::test::SleepRelaxCpuContext stk::test::g_SleepRelaxCpuContext

static

Referenced by SleepRelaxCpu(), TEST(), TEST(), and TestTaskSleep().

g_SwitchToNextRelaxCpuContext

struct stk::test::SwitchToNextRelaxCpuContext stk::test::g_SwitchToNextRelaxCpuContext

static

Referenced by SwitchToNextRelaxCpu(), TEST(), and TEST().

g_SyncWaitRelaxCpuContext

struct stk::test::SyncWaitRelaxCpuContext stk::test::g_SyncWaitRelaxCpuContext

static

Referenced by SyncWaitRelaxCpu(), TEST(), and Test_SyncWait().

g_SyncWaitWakeRelaxCpuContext

struct stk::test::SyncWaitWakeRelaxCpuContext stk::test::g_SyncWaitWakeRelaxCpuContext

static

Referenced by SyncWaitWakeRelaxCpu(), and TEST().

g_TaskSuspendContext

struct stk::test::TaskSuspendContext stk::test::g_TaskSuspendContext

static

Referenced by TaskSuspendRelaxCpu(), and TEST().

g_TestContext

TestContext stk::test::g_TestContext

extern

Global instance of the TestContext.

Definition at line 16 of file stktest.cpp.

Referenced by STK_ASSERT_HANDLER(), STK_PANIC_HANDLER_DEFAULT(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST_GROUP(), TEST_GROUP(), TEST_GROUP(), TEST_GROUP(), TEST_GROUP(), and TEST_GROUP().