/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
StatusType result_inst_1,result_inst_4,result_inst_5,result_inst_6,result_inst_7;
TaskStateType result_inst_3;
SCHEDULING_CHECK_INIT(1);
result_inst_1 = ActivateTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(4 , E_OK , result_inst_1);
SCHEDULING_CHECK_INIT(5);
result_inst_4 = GetTaskState(t2,&result_inst_3);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(5 , WAITING , result_inst_3);
SCHEDULING_CHECK_AND_EQUAL_INT(5 , E_OK , result_inst_4);
SCHEDULING_CHECK_INIT(6);
result_inst_5 = ActivateTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(6 , E_OS_LIMIT , result_inst_5);
SCHEDULING_CHECK_INIT(7);
result_inst_6 = ChainTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(7 , E_OS_LIMIT , result_inst_6);
SCHEDULING_CHECK_INIT(8);
result_inst_7 = SetEvent(t2,Event2);
SCHEDULING_CHECK_AND_EQUAL_INT(10 , E_OK , result_inst_7);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_pretask_instance2(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4, result_inst_5;
TaskType task_id;
TaskStateType task_state;
EventMaskType event_mask;
AlarmBaseType alarm_base;
TickType tik;
SCHEDULING_CHECK_INIT(15);
result_inst_1 = GetTaskID(&task_id);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(15,INVALID_TASK , task_id);
SCHEDULING_CHECK_AND_EQUAL_INT(15,E_OK , result_inst_1);
SCHEDULING_CHECK_INIT(16);
result_inst_2 = GetTaskState(task_id, &task_state);
SCHEDULING_CHECK_AND_EQUAL_INT(17,E_OS_ID , result_inst_2);
SCHEDULING_CHECK_INIT(18);
result_inst_3 = GetEvent(task_id,&event_mask);
SCHEDULING_CHECK_AND_EQUAL_INT(19,E_OS_ID , result_inst_3);
SCHEDULING_CHECK_INIT(20);
result_inst_4 = GetAlarmBase(Alarm1, &alarm_base);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(20,OSMAXALLOWEDVALUE_Counter1, (int)(alarm_base.maxallowedvalue));
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(20,OSTICKSPERBASE_Counter1, (int)(alarm_base.ticksperbase));
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(20,OSMINCYCLE_Counter1, (int)(alarm_base.mincycle));
SCHEDULING_CHECK_AND_EQUAL_INT(20,E_OK , result_inst_4);
SCHEDULING_CHECK_INIT(21);
result_inst_5 = GetAlarm(Alarm1,&tik);
SCHEDULING_CHECK_AND_EQUAL_INT(21,E_OK , result_inst_5);
}
/* Standard posttask hook
*
* $Req: artf1225 $
*/
void PostTaskHook(void)
{
TaskType task;
StatusType rc;
TaskStateType state;
#ifdef USEPOSTTASKHOOK
/* PostTaskHook() should be called with cat2 interrupts locked.
*
* $Req: artf1110 $
*
* Following code will trigger the cat2 ISR here but it should not actually run. Dismiss it later.
* Safe to do this because PostTaskHook() is never called from an ISR and so won't mess with the cat2 ISR in
* the tests.
*
* In mosts tests the ISR running is logged, and this would cause the test to fail
* because there should be no expect ISR log entries at this point.
*/
SET_TESTEVENT("PostTaskHook");
testing_trigger_isr();
/* Task should now be RUNNING when the hook is called
*
* $Req: artf1140
*/
rc = GetTaskID(&task); /* $Req: artf1139 $ */
if(rc != E_OK) {
test_failed(OS_HERE);
}
if(task == INVALID_TASK) { /* $Req: artf1118 $ */
test_failed(OS_HERE);
}
GetTaskState(task, &state); /* $Req: artf1141 $ */
if(rc != E_OK) {
test_failed(OS_HERE);
}
if(state != RUNNING) { /* $Req: artf1118 $ */
test_failed(OS_HERE);
}
#ifdef INCLUDE_HANDLE_NAME_MAP
SET_TESTEVENT(TaskType2string(task));
#else
SET_TESTEVENT("A task");
#endif
#ifdef USEPRETASKHOOK
/* If there is a pretask hook then make sure the posttask hook gets called in a paired sequence */
if(pretaskhook_task != task) {
test_failed(OS_HERE);
}
else {
pretaskhook_task = 0;
}
#endif
testing_dismiss_isr();
#else
test_failed(OS_HERE);
#endif
}
void __attribute__((__interrupt__)) _INT0Interrupt(void)
{
TaskStateType State;
EnterISR();
IEC0bits.INT0IE = 0;
GetTaskState(TASK2_ID, &State);
if (State == SUSPENDED)
ActivateTask(TASK2_ID);
LeaveISR();
}
void PreTaskHook( void ) {
StatusType rv;
TaskType task;
TaskStateType state;
printf("prehook\r\n");
rv = GetTaskID(&task);
assert( rv == E_OK );
LDEBUG_PRINTF("## PreTaskHook, taskid=%d\n",task);
rv = GetTaskState(task,&state);
assert( rv == E_OK );
assert( state == TASK_STATE_RUNNING );
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t2_instance(void)
{
StatusType result_inst_2, result_inst_3;
TaskStateType result_inst_1;
SCHEDULING_CHECK_INIT(5);
result_inst_2 = GetTaskState(t1,&result_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(5,READY , result_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(5,E_OK , result_inst_2);
SCHEDULING_CHECK_INIT(6);
result_inst_3 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(6,E_OK , result_inst_3);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
StatusType result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6, result_inst_7, result_inst_8, result_inst_9, result_inst_10, result_inst_11;
TaskStateType result_inst_3_5;
SCHEDULING_CHECK_INIT(1);
result_inst_2 = ActivateTask(INVALID_TASK);
SCHEDULING_CHECK_AND_EQUAL_INT(1,E_OS_ID, result_inst_2);
SCHEDULING_CHECK_INIT(2);
result_inst_3 = GetTaskState(INVALID_TASK,&result_inst_3_5);
SCHEDULING_CHECK_AND_EQUAL_INT(2,E_OS_ID, result_inst_3);
SCHEDULING_CHECK_INIT(3);
result_inst_4 = ChainTask(INVALID_TASK);
SCHEDULING_CHECK_AND_EQUAL_INT(3,E_OS_ID, result_inst_4);
SCHEDULING_CHECK_INIT(4);
result_inst_5 = ActivateTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(4,E_OK, result_inst_5);
SCHEDULING_CHECK_INIT(5);
result_inst_6 = Schedule();
SCHEDULING_CHECK_AND_EQUAL_INT(9,E_OK, result_inst_6);
SCHEDULING_CHECK_INIT(10);
result_inst_7 = GetResource(RES_SCHEDULER);
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OK, result_inst_7);
SCHEDULING_CHECK_INIT(11);
result_inst_8 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(11,E_OS_RESOURCE, result_inst_8);
SCHEDULING_CHECK_INIT(12);
result_inst_9 = ChainTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(12,E_OS_RESOURCE, result_inst_9);
SCHEDULING_CHECK_INIT(13);
result_inst_10 = Schedule();
SCHEDULING_CHECK_AND_EQUAL_INT(13,E_OS_RESOURCE, result_inst_10);
SCHEDULING_CHECK_INIT(14);
result_inst_11 = ReleaseResource(RES_SCHEDULER);
SCHEDULING_CHECK_AND_EQUAL_INT(14,E_OK, result_inst_11);
sendSoftwareIt(0, SOFT_IRQ0);
SCHEDULING_CHECK_STEP(19);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
StatusType result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6, result_inst_7, result_inst_8, result_inst_9;
TaskStateType result_inst_3_5;
SCHEDULING_CHECK_INIT(1);
result_inst_2 = ActivateTask(INVALID_TASK);
SCHEDULING_CHECK_AND_EQUAL_INT(1,E_OS_ID, result_inst_2);
SCHEDULING_CHECK_INIT(2);
result_inst_3 = GetTaskState(INVALID_TASK,&result_inst_3_5);
SCHEDULING_CHECK_AND_EQUAL_INT(2,E_OS_ID, result_inst_3);
SCHEDULING_CHECK_INIT(3);
result_inst_4 = ChainTask(INVALID_TASK);
SCHEDULING_CHECK_AND_EQUAL_INT(3,E_OS_ID, result_inst_4);
SCHEDULING_CHECK_INIT(4);
result_inst_5 = ActivateTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(8,E_OK, result_inst_5);
SCHEDULING_CHECK_INIT(9);
result_inst_6 = GetResource(RES_SCHEDULER);
SCHEDULING_CHECK_AND_EQUAL_INT(9,E_OK, result_inst_6);
SCHEDULING_CHECK_INIT(10);
result_inst_7 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OS_RESOURCE, result_inst_7);
SCHEDULING_CHECK_INIT(11);
result_inst_8 = ChainTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(11,E_OS_RESOURCE, result_inst_8);
SCHEDULING_CHECK_INIT(12);
result_inst_9 = ReleaseResource(RES_SCHEDULER);
SCHEDULING_CHECK_AND_EQUAL_INT(12,E_OK, result_inst_9);
tpl_send_it1();
SCHEDULING_CHECK_STEP(17);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
StatusType result_inst_1, result_inst_3, result_inst_4;
TaskStateType result_inst_2;
SCHEDULING_CHECK_INIT(1);
result_inst_1 = SetRelAlarm(Alarm1, 0, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(1,E_OK, result_inst_1);
WaitActivationOneShotAlarm(Alarm1);
SCHEDULING_CHECK_INIT(2);
result_inst_3 = GetTaskState(t2, &result_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(2,READY, result_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT(2,E_OK, result_inst_3);
SCHEDULING_CHECK_INIT(3);
result_inst_4 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(3,E_OK, result_inst_4);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_error_instance(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6;
TaskType task_id;
TaskStateType task_state;
EventMaskType event_mask;
AlarmBaseType alarm_base;
TickType tik;
SCHEDULING_CHECK_INIT(4);
result_inst_1 = GetActiveApplicationMode();
SCHEDULING_CHECK_AND_EQUAL_INT(4,OSDEFAULTAPPMODE , result_inst_1);
SCHEDULING_CHECK_INIT(5);
result_inst_2 = GetTaskID(&task_id);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(5,E_OK , result_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT(5,t1 , task_id);
SCHEDULING_CHECK_INIT(6);
result_inst_3 = GetTaskState(task_id, &task_state);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(6,E_OK , result_inst_3);
SCHEDULING_CHECK_AND_EQUAL_INT(6,RUNNING , task_state);
SCHEDULING_CHECK_INIT(7);
result_inst_4 = GetEvent(task_id,&event_mask);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(7,E_OK , result_inst_2);
SCHEDULING_CHECK_AND_EQUAL_INT(7,E_OK , result_inst_2);
SCHEDULING_CHECK_INIT(8);
result_inst_5 = GetAlarmBase(Alarm1, &alarm_base);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(8,OSMAXALLOWEDVALUE_Counter1, (int)(alarm_base.maxallowedvalue));
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(8,OSTICKSPERBASE_Counter1, (int)(alarm_base.ticksperbase));
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(8,OSMINCYCLE_Counter1, (int)(alarm_base.mincycle));
SCHEDULING_CHECK_AND_EQUAL_INT(8,E_OK , result_inst_5);
SCHEDULING_CHECK_INIT(9);
result_inst_6 = GetAlarm(Alarm1,&tik);
SCHEDULING_CHECK_AND_EQUAL_INT(9,E_OK , result_inst_6);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_posttask_instance3(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3;
TaskType task_id;
TaskStateType task_state;
EventMaskType event_mask;
SCHEDULING_CHECK_INIT(33);
result_inst_1 = GetTaskID(&task_id);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(33,t1 , task_id);
SCHEDULING_CHECK_AND_EQUAL_INT(33,E_OK , result_inst_1);
SCHEDULING_CHECK_INIT(34);
result_inst_2 = GetTaskState(task_id, &task_state);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(34,RUNNING , task_state);
SCHEDULING_CHECK_AND_EQUAL_INT(34,E_OK , result_inst_2);
SCHEDULING_CHECK_INIT(35);
result_inst_3 = GetEvent(task_id,&event_mask);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(35,Event1 , event_mask);
SCHEDULING_CHECK_AND_EQUAL_INT(35,E_OK , result_inst_3);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_pretask_instance3(void)
{
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4, result_inst_5;
TaskType task_id;
TaskStateType task_state;
EventMaskType event_mask;
AlarmBaseType alarm_base;
TickType tik;
SCHEDULING_CHECK_INIT(25);
result_inst_1 = GetTaskID(&task_id);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(25,t1 , task_id);
SCHEDULING_CHECK_AND_EQUAL_INT(25,E_OK , result_inst_1);
SCHEDULING_CHECK_INIT(26);
result_inst_2 = GetTaskState(task_id, &task_state);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(26,RUNNING , task_state);
SCHEDULING_CHECK_AND_EQUAL_INT(26,E_OK , result_inst_2);
SCHEDULING_CHECK_INIT(27);
result_inst_3 = GetEvent(task_id,&event_mask);
SCHEDULING_CHECK_AND_EQUAL_INT(27,E_OK , result_inst_3);
SCHEDULING_CHECK_INIT(28);
result_inst_4 = GetAlarmBase(Alarm1, &alarm_base);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(28,OSMAXALLOWEDVALUE_Counter1, (int)(alarm_base.maxallowedvalue));
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(28,OSTICKSPERBASE_Counter1, (int)(alarm_base.ticksperbase));
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(28,OSMINCYCLE_Counter1, (int)(alarm_base.mincycle));
SCHEDULING_CHECK_AND_EQUAL_INT(28,E_OK , result_inst_4);
SCHEDULING_CHECK_INIT(29);
result_inst_5 = GetAlarm(Alarm1,&tik);
SCHEDULING_CHECK_AND_EQUAL_INT(30,E_OS_NOFUNC , result_inst_5);
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
AlarmBaseType AlarmBaseType_inst_1;
EventMaskType EventMaskType_inst_1;
StatusType result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6, result_inst_7, result_inst_8, result_inst_9, result_inst_10, result_inst_11, result_inst_12, result_inst_13, result_inst_14, result_inst_15, result_inst_16, result_inst_17, result_inst_18, result_inst_19;
TaskStateType TaskStateType_inst_1;
TaskType TaskType_inst_1;
TickType TickType_inst_1;
SCHEDULING_CHECK_STEP(1);
SCHEDULING_CHECK_STEP(2);
SuspendAllInterrupts();
SCHEDULING_CHECK_INIT(3);
result_inst_2 = ActivateTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(4,E_OS_DISABLEDINT, result_inst_2);
SCHEDULING_CHECK_INIT(5);
result_inst_3 = TerminateTask();
SCHEDULING_CHECK_AND_EQUAL_INT(6,E_OS_DISABLEDINT, result_inst_3);
SCHEDULING_CHECK_INIT(7);
result_inst_4 = ChainTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(8,E_OS_DISABLEDINT, result_inst_4);
SCHEDULING_CHECK_INIT(9);
result_inst_5 = Schedule();
SCHEDULING_CHECK_AND_EQUAL_INT(10,E_OS_DISABLEDINT, result_inst_5);
SCHEDULING_CHECK_INIT(11);
result_inst_6 = GetTaskID(&TaskType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(12,E_OS_DISABLEDINT, result_inst_6);
SCHEDULING_CHECK_INIT(13);
result_inst_7 = GetTaskState(t2, &TaskStateType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(14,E_OS_DISABLEDINT, result_inst_7);
SCHEDULING_CHECK_INIT(15);
result_inst_8 = GetResource(Resource1);
SCHEDULING_CHECK_AND_EQUAL_INT(16,E_OS_DISABLEDINT, result_inst_8);
SCHEDULING_CHECK_INIT(17);
result_inst_9 = ReleaseResource(Resource1);
SCHEDULING_CHECK_AND_EQUAL_INT(18,E_OS_DISABLEDINT, result_inst_9);
SCHEDULING_CHECK_INIT(19);
result_inst_10 = SetEvent(t2, Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(20,E_OS_DISABLEDINT, result_inst_10);
SCHEDULING_CHECK_INIT(21);
result_inst_11 = ClearEvent(Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(22,E_OS_DISABLEDINT, result_inst_11);
SCHEDULING_CHECK_INIT(23);
result_inst_12 = GetEvent(t2, &EventMaskType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(24,E_OS_DISABLEDINT, result_inst_12);
SCHEDULING_CHECK_INIT(25);
result_inst_13 = WaitEvent(Event1);
SCHEDULING_CHECK_AND_EQUAL_INT(26,E_OS_DISABLEDINT, result_inst_13);
SCHEDULING_CHECK_INIT(27);
result_inst_14 = GetAlarmBase(Alarm1, &AlarmBaseType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(28,E_OS_DISABLEDINT, result_inst_14);
SCHEDULING_CHECK_INIT(29);
result_inst_15 = GetAlarm(Alarm1, &TickType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(30,E_OS_DISABLEDINT, result_inst_15);
SCHEDULING_CHECK_INIT(31);
result_inst_16 = SetRelAlarm(Alarm1, 1, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(32,E_OS_DISABLEDINT, result_inst_16);
SCHEDULING_CHECK_INIT(33);
result_inst_17 = SetAbsAlarm(Alarm1, 1, 0);
SCHEDULING_CHECK_AND_EQUAL_INT(34,E_OS_DISABLEDINT, result_inst_17);
SCHEDULING_CHECK_INIT(35);
result_inst_18 = CancelAlarm(Alarm1);
SCHEDULING_CHECK_AND_EQUAL_INT(36,E_OS_DISABLEDINT, result_inst_18);
SCHEDULING_CHECK_INIT(37);
result_inst_19 = GetActiveApplicationMode();
SCHEDULING_CHECK_AND_EQUAL_INT(38,OSDEFAULTAPPMODE, result_inst_19);
SCHEDULING_CHECK_STEP(39);
ResumeAllInterrupts();
}
/* Error hook for all tests
*
* $Req: artf1222 $
*/
void ErrorHook(StatusType rc)
{
#ifdef USEERRORHOOK
#ifdef EXPECTSERRORS
TaskType from_task;
ISRType from_isr;
TaskStateType state;
if(in_error_hook) {
test_failed(OS_HERE); /* Error hook not permitted to be called recursively $Req: artf1112 $ */
}
in_error_hook = 1U;
SET_TESTEVENT("ErrorHook");
#ifdef OS_EXTENDED_STATUS
/* Test for recursive error hook call by making a legal call which generates an error */
GetTaskState(0, &state);
#endif
/* $Req: artf1140 $ */
GetTaskID(&from_task);
from_isr = GetISRID();
if(from_isr == INVALID_ISR) {
if(from_task == INVALID_TASK) {
SET_TESTEVENT("<No runnable>"); /* Not sure how to get an error hook called if no task or ISR running.. */
}
else { /* Must be a task that caused the error hook to run since there is no ISR running */
#ifdef INCLUDE_HANDLE_NAME_MAP
SET_TESTEVENT(TaskType2string(from_task));
#else
SET_TESTEVENT("<A task>");
#endif
/* ErrorHook() should be called with cat2 interrupts locked.
*
* $Req: artf1110 $
*
* Following code will trigger the cat2 ISR here but it should not actually run. Dismiss it immediately.
*
* Only do this if the error hook is called from outside an ISR because otherwise this would mess up
* the only cat2 ISR. In mosts tests the ISR running is logged, and this would cause the test to fail
* because there should be no expect ISR log entries at this point.
*/
testing_trigger_isr();
testing_dismiss_isr();
}
}
else { /* An ISR must be running; this takes precedence over a task: the error must have
* been raised in the ISR since the task can't be running (all ISRs have higher priorities
* than all tasks)
*/
#ifdef INCLUDE_HANDLE_NAME_MAP
SET_TESTEVENT(ISRType2string(from_isr));
#else
SET_TESTEVENT("<An ISR>");
#endif
}
/* If E_OS_MISSING end called then the task is still valid and still RUNNING when the error hook called */
if(rc == E_OS_MISSINGEND) { /* $Req: artf1041 $ */
if(from_task == INVALID_TASK) {
test_failed(OS_HERE);
}
else {
GetTaskState(from_task, &state);
if(state != RUNNING) {
test_failed(OS_HERE);
}
}
}
/* OSErrorGetServiceId() callable from ErrorHook()
*
* $Req: artf1114 $
* $Req: artf1228 $
*/
SET_TESTEVENT(OSServiceIdType2string(OSErrorGetServiceId(), "<Unknown service ID>"));
SET_TESTEVENT(StatusType2string(rc, "<Unknown StatusType code>"));
set_error_hook_parameters(OSErrorGetServiceId());
in_error_hook = 0U;
#else /* don't expect errors */
test_failed(OS_HERE);
#endif
#else
/* don't use error hook
*
* $Req: artf1223 $
*/
test_failed(OS_HERE);
#endif
}
void PostTaskHook(void)
{
static uint8 count = 0;
StatusType ret;
TaskType TaskID;
TaskStateType TaskState;
switch (count)
{
case 0:
/* increment post task hook call count */
count++;
Sequence(5);
/* \treq EH_04 nmf B1B2E1E2 se Check PreTaskHook/PostTaskHook:
* Force rescheduling
*
* \result PreTaskHook is called before executing the new task,
* but after the transition to running state. PostTaskHook is called
* after existing the current task but before leaving the task's
* running state.
*/
ret = GetTaskID(&TaskID);
ASSERT(EH_04, ret != E_OK);
ASSERT(EH_04, TaskID != Task1);
Sequence(6);
ret = GetTaskState(Task1, &TaskState);
ASSERT(OTHER, ret != E_OK);
ASSERT(OTHER, TaskState != RUNNING);
Sequence(7);
ret = GetTaskState(Task2, &TaskState);
ASSERT(OTHER, ret != E_OK);
ASSERT(OTHER, TaskState != READY);
break;
case 1:
/* increment post task hook call count */
count++;
Sequence(14);
/* \treq EH_04 nmf B1B2E1E2 se Check PreTaskHook/PostTaskHook:
* Force rescheduling
*
* \result PreTaskHook is called before executing the new task,
* but after the transition to running state. PostTaskHook is called
* after existing the current task but before leaving the task's
* running state.
*/
ret = GetTaskID(&TaskID);
ASSERT(EH_04, ret != E_OK);
ASSERT(EH_04, TaskID != Task2);
Sequence(15);
ret = GetTaskState(Task1, &TaskState);
ASSERT(OTHER, ret != E_OK);
ASSERT(OTHER, TaskState != READY);
Sequence(16);
ret = GetTaskState(Task2, &TaskState);
ASSERT(OTHER, ret != E_OK);
ASSERT(OTHER, TaskState != RUNNING);
break;
case 2:
/* increment post task hook call count */
count++;
Sequence(21);
/* \treq EH_04 nmf B1B2E1E2 se Check PreTaskHook/PostTaskHook:
* Force rescheduling
*
* \result PreTaskHook is called before executing the new task,
* but after the transition to running state. PostTaskHook is called
* after existing the current task but before leaving the task's
* running state.
*/
ret = GetTaskID(&TaskID);
ASSERT(EH_04, ret != E_OK);
ASSERT(EH_04, TaskID != Task1);
Sequence(22);
ret = GetTaskState(Task1, &TaskState);
ASSERT(OTHER, ret != E_OK);
ASSERT(OTHER, TaskState != RUNNING);
Sequence(23);
ret = GetTaskState(Task2, &TaskState);
ASSERT(OTHER, ret != E_OK);
ASSERT(OTHER, TaskState != SUSPENDED);
Sequence(24);
/* evaluate conformance tests */
ConfTestEvaluation();
/* finish the conformance test */
ConfTestFinish();
break;
default:
while(1);
break;
}
}
