/*----------------------------------------------------------------------------*/
void Test_OS_TaskRegister_Success(void)
{
int32 expected = OS_SUCCESS;
int32 actual = 99;
/* Setup Inputs */
uint32 tableIdx = 1;
uint32 task_id = 4;
OsApi_Adaptor_setOsTaskKey(77);
OsApi_Adaptor_setTaskTableEntry(tableIdx, FALSE, task_id, "", 0, 0, 1, NULL);
OsApi_SetReturnCode(OSAPI_TASKIDSELF_INDEX, task_id, 1);
OsApi_SetReturnCode(OSAPI_TASKVARADD_INDEX, VCS_OK, 1);
/* Execute Test */
actual = OS_TaskRegister();
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_SUCCESS");
UtAssert_True(OsApi_Adaptor_getOsTaskKey() == tableIdx, "OS_task_key == expected");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) > 0, "semaphore taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskCreate_NameTooLong(void)
{
int32 expected = OS_ERR_NAME_TOO_LONG;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = 1;
char *task_name = "test";
uint32 stack = 1;
uint32 stack_size = 1;
uint32 priority = 1;
uint32 flags = 1;
OsApi_SetReturnCode(OSAPI_STRLEN_INDEX, OS_MAX_API_NAME, 1);
/* Execute Test */
actual = OS_TaskCreate(&task_id, task_name, dummyFnc, &stack, stack_size, priority, flags);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERR_NAME_TOO_LONG");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == 0, "No OS_TASK_TABLE_SEM taken");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskCreate_NameTaken(void)
{
int32 expected = OS_ERR_NAME_TAKEN;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = 1;
char *task_name = "test";
uint32 stack = 1;
uint32 stack_size = 1;
uint32 priority = 1;
uint32 flags = 1;
OsApi_Adaptor_setTaskTableEntry(0, TRUE, 0, "", 0, 0, 0, NULL);
OsApi_Adaptor_setTaskTableEntry(1, FALSE, 0, "bad_task_name", 0, 0, 0, NULL);
OsApi_Adaptor_setTaskTableEntry(OS_MAX_TASKS - 1, FALSE, 0, task_name, 0, 0, 0, NULL);
/* Execute Test */
actual = OS_TaskCreate(&task_id, task_name, dummyFnc, &stack, stack_size, priority, flags);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERR_NAME_TAKEN");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == 1, "semaphore taken once");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskGetIdByName_Success(void)
{
int32 expected = OS_SUCCESS;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id_idx = 5;
uint32 task_id = 1;
const char *task_name = "testTaskName";
OsApi_Adaptor_setTaskTableEntry(0, FALSE, 0, "", 0, 0, 0, NULL);
OsApi_Adaptor_setTaskTableEntry(0, TRUE, 0, "", 0, 0, 0, NULL); /* for full MCDC coverage */
OsApi_Adaptor_setTaskTableEntry(task_id_idx, FALSE, 0, (char *)task_name, 0, 0, 0, NULL);
/* Execute Test */
actual = OS_TaskGetIdByName(&task_id, task_name);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_SUCCESS");
UtAssert_True(task_id == task_id_idx, "task_id updated");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) > 0, "semaphore taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskCreate_SpawnError(void)
{
int32 expected = OS_ERROR;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = 1;
char *task_name = "test";
uint32 stack = 1;
uint32 stack_size = 1;
uint32 priority = 1;
uint32 flags = OS_FP_ENABLED;
OsApi_Adaptor_setTaskTableEntry(0, TRUE, 0, "", 0, 0, 0, NULL);
OsApi_SetReturnCode(OSAPI_TASKSPAWN_INDEX, VCS_ERROR, 1);
/* Execute Test */
actual = OS_TaskCreate(&task_id, task_name, dummyFnc, &stack, stack_size, priority, flags);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERROR");
UtAssert_True(OsApi_Adaptor_getTaskTableEntry(0)->free == TRUE,
"task table entry still free");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) >= 1, "semaphore taken >1");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskDelete_Success(void)
{
int32 expected = OS_SUCCESS;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = 6;
OsApi_Adaptor_setTaskTableEntry(task_id, FALSE, 1, "testTask", 2, 3, 4, deleteFnc);
OsApi_SetReturnCode(OSAPI_TASKDELETE_INDEX, VCS_OK, 1);
/* Execute Test */
actual = OS_TaskDelete(task_id);
/* Verify Outputs */
osTaskRecord_ptr = OsApi_Adaptor_getTaskTableEntry(task_id);
UtAssert_True(actual == expected, "actual == OS_SUCCESS");
UtAssert_StrCmp("", osTaskRecord_ptr->name, "task name == expected");
UtAssert_True(osTaskRecord_ptr->free == TRUE, "task entry is free");
UtAssert_True(osTaskRecord_ptr->id == UNINITIALIZED, "task id == expected");
UtAssert_True(osTaskRecord_ptr->creator == UNINITIALIZED, "creator ID == input");
UtAssert_True(osTaskRecord_ptr->stack_size == UNINITIALIZED, "stack size == input");
UtAssert_True(osTaskRecord_ptr->priority == UNINITIALIZED, "priority == input");
UtAssert_True(osTaskRecord_ptr->delete_hook_pointer == NULL, "priority == input");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) >= 1, "semaphore taken >1");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskExit_Success(void)
{
int32 expected = TRUE;
/* Setup Inputs */
uint32 task_id = 2;
OsApi_Adaptor_setOsTaskKey(task_id);
OsApi_Adaptor_setTaskTableEntry(task_id, FALSE, 1, "testTask", 2, 3, 4, deleteFnc);
OsApi_SetReturnCode(OSAPI_EXIT_INDEX, 0, 1);
/* Execute Test */
OS_TaskExit();
/* Verify Outputs */
osTaskRecord_ptr = OsApi_Adaptor_getTaskTableEntry(task_id);
UtAssert_True(getTaskExitCalled() == expected, "taskExit called");
UtAssert_StrCmp("", osTaskRecord_ptr->name, "task name == expected");
UtAssert_True(osTaskRecord_ptr->free == TRUE, "task entry is free");
UtAssert_True(osTaskRecord_ptr->id == UNINITIALIZED, "task id == expected");
UtAssert_True(osTaskRecord_ptr->creator == UNINITIALIZED, "creator ID == expected");
UtAssert_True(osTaskRecord_ptr->stack_size == UNINITIALIZED, "stack size == expected");
UtAssert_True(osTaskRecord_ptr->priority == UNINITIALIZED, "priority == expected");
UtAssert_True(osTaskRecord_ptr->delete_hook_pointer == NULL, "priority == expected");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) > 0, "semaphore taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/* MSGTBL_Test01 - Constructor, ResetStatus, GetTblPtr */
void MSGTBL_Test01(void)
{
MSGTBL_Table* MsgTblPtr = NULL;
/* Constructor called as part of setup */
UtAssert_True(MsgTbl.Table.Entry[0].Buffer[0] == 0, "MsgTbl.Table.Entry[0] == 0");
MsgTblPtr = MSGTBL_GetTblPtr();
UtAssert_True(MsgTblPtr == &(MsgTbl.Table), "MsgTbl.Table.Entry[0] == 0");
MSGTBL_Constructor (&MsgTbl);
} /* End MSGTBL_Test01() */
void Test_OS_API_Init_MsgQCreate_Error(void)
{
int32 expected = OS_ERROR;
int32 actual = 99;
/* Setup Inputs */
OsApi_SetReturnCode(OSAPI_MSGQCREATE_INDEX, 0, 1);
/* Execute Test */
actual = OS_API_Init();
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERROR");
UtAssert_True(getNTaskDeleteForce() == 1, "taskDeleteForce called");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskDelay_Error(void)
{
int32 expected = OS_ERROR;
int32 actual = 99;
/* Setup Inputs */
OsApi_SetReturnCode(OSAPI_SYSCLKRATEGET_INDEX, 1000000, 1);
OsApi_SetReturnCode(OSAPI_TASKDELAY_INDEX, VCS_ERROR, 1);
/* Execute Test */
actual = OS_TaskDelay(1);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == expected");
UtAssert_True(getTaskDelayTicks() == 1000, "sys_ticks == expected");
}
void Example_Function2_Test_Case3(void)
{
int32 Result;
Example_GlobalData.Variable3 = 55;
/* Execute the function being tested */
Result = Example_Function2();
/* Verify results */
UtAssert_True (Example_GlobalData.Variable4 == 99, "Example_GlobalData.Variable4 == 99");
UtAssert_True (Result == 10, "Result == 10");
UtAssert_True (Ut_CFE_EVS_GetEventQueueDepth() == 0, "Ut_CFE_EVS_GetEventQueueDepth() == 0");
} /* end Example_Function2_Test_Case3 */
int32 Ut_CFE_EVS_SendEventHook(uint16 EventID, uint16 EventType, const char *EventText)
{
Ut_CFE_EVS_Event_t EventMessage;
if (strlen(EventText) >= CFE_EVS_MAX_MESSAGE_LENGTH) {
UtPrintf("WARNING - Event Message Too Long: %s\n", EventText);
}
EventMessage.EventID = EventID;
EventMessage.EventType = EventType;
strncpy(&EventMessage.EventText[0], EventText, CFE_EVS_MAX_MESSAGE_LENGTH);
UtList_Add(&EventQueue, &EventMessage, sizeof(EventMessage), 0);
if (EventType == CFE_EVS_DEBUG)
UtPrintf("DEBUG EVENT ID=%d %s\n", EventID, EventText);
else if (EventType == CFE_EVS_INFORMATION)
UtPrintf("INFO EVENT ID=%d %s\n", EventID, EventText);
else if (EventType == CFE_EVS_ERROR)
UtPrintf("ERROR EVENT ID=%d %s\n", EventID, EventText);
else if (EventType == CFE_EVS_CRITICAL)
UtPrintf("CRITICAL EVENT ID=%d %s\n", EventID, EventText);
else
{
UtPrintf("Invalid Event Type %d ID=%d %s\n", EventType, EventID, EventText);
UtAssert_True(FALSE, "Invalid Event Type");
}
return CFE_SUCCESS;
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskGetInfo_Success(void)
{
int32 expected = OS_SUCCESS;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = 1;
static OS_task_prop_t task_prop;
OsApi_Adaptor_setTaskTableEntry(task_id, FALSE, 1, "testTask", 2, 3, 4, deleteFnc);
/* Execute Test */
actual = OS_TaskGetInfo(task_id, &task_prop);
/* Verify Outputs */
osTaskRecord_ptr = OsApi_Adaptor_getTaskTableEntry(task_id);
UtAssert_True(actual == expected, "actual == OS_SUCCESS");
UtAssert_True(task_prop.creator == osTaskRecord_ptr->creator, "creator == expected");
UtAssert_True(task_prop.stack_size == osTaskRecord_ptr->stack_size, "stack_size == expected");
UtAssert_True(task_prop.priority == osTaskRecord_ptr->priority, "priority == expected");
UtAssert_True(task_prop.OStask_id == osTaskRecord_ptr->id, "OStask_id == expected");
UtAssert_StrCmp(task_prop.name, osTaskRecord_ptr->name, "name == expected");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) > 0, "semaphore taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_NetworkGetID_Nominal(void)
{
/* Setup Inputs */
Osnetwork_SetReturnCode(OSNETWORK_GETHOSTNAME_INDEX, 0, 1);
Osnetwork_SetReturnCode(OSNETWORK_HOSTGETBYNAME_INDEX, 99, 1);
/* Execute Test */
int32 retval = OS_NetworkGetID();
#ifdef OS_INCLUDE_NETWORK
/* Verify Outputs - WITH NETWORK */
UtAssert_True(retval == 99, "retval == 99");
#else
/* Verify Outputs - NO NETWORK */
UtAssert_True(retval == OS_ERR_NOT_IMPLEMENTED, "retval == OS_ERR_NOT_IMPLEMENTED");
#endif
}
void Example_Function2_Test_Case2(void)
{
int32 Result;
Example_GlobalData.Variable3 = 3;
Ut_CFE_SB_SetFunctionHook(UT_CFE_SB_SUBSCRIBE_INDEX, &Example_Cmds_Test_UT_CFE_SB_SubscribeHook2);
/* Execute the function being tested */
Result = Example_Function2();
/* Verify results */
UtAssert_True (Example_GlobalData.Variable4 == 4, "Example_GlobalData.Variable4 == 4");
UtAssert_True (Result == 10, "Result == 10");
UtAssert_True (Ut_CFE_EVS_GetEventQueueDepth() == 0, "Ut_CFE_EVS_GetEventQueueDepth() == 0");
} /* end Example_Function2_Test_Case2 */
/*----------------------------------------------------------------------------*/
void Test_OS_TaskDelete_IdInvalid(void)
{
int32 expected = OS_ERR_INVALID_ID;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = OS_MAX_TASKS;
/* Execute Test */
actual = OS_TaskDelete(task_id);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERR_INVALID_ID");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == 1, "semaphore taken once");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_NetworkGetHostName_Nominal(void)
{
/* Setup Inputs */
char hostname[255] = "UNSET";
uint32 name_len = 13;
/* Execute Test */
int32 retval = OS_NetworkGetHostName(hostname, name_len);
#ifdef OS_INCLUDE_NETWORK
/* Verify Outputs - WITH NETWORK */
UtAssert_True(retval == OS_SUCCESS, "retval == OS_SUCCESS");
UtAssert_StrCmp(hostname, "testname", "hostname == testname");
#else
/* Verify Outputs - NO NETWORK */
UtAssert_True(retval == OS_ERR_NOT_IMPLEMENTED, "retval == OS_ERR_NOT_IMPLEMENTED");
UtAssert_StrCmp(hostname, "UNSET", "hostname == UNSET");
#endif
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskInstallDeleteHandler_IdInvalid(void)
{
int32 expected = OS_ERR_INVALID_ID;
int32 actual = 99;
/* Setup Inputs */
OsApi_Adaptor_setOsTaskKey(OS_MAX_TASKS);
/* Execute Test */
actual = OS_TaskInstallDeleteHandler(dummyFnc);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERR_INVALID_ID");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == 0, "No semaphore taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskCreate_FpNotEnabled(void)
{
int32 expected = OS_SUCCESS;
int32 actual = 99;
/* Setup Inputs */
uint32 taskIdIdx = 7;
uint32 task_id = 5;
char *task_name = "test";
uint32 stack = 4;
uint32 stack_size = 3;
uint32 priority = 2;
uint32 flags = 0;
uint32 taskSpawnId = 101;
uint32 creatorId = 15;
uint32 creatorIndex = 5;
OsApi_Adaptor_setTaskTableEntry(taskIdIdx, TRUE, 0, "", 0, 0, 0, NULL);
OsApi_SetReturnCode(OSAPI_TASKSPAWN_INDEX, taskSpawnId, 1);
OsApi_SetReturnCode(OSAPI_TASKIDSELF_INDEX, creatorId, 1);
OsApi_Adaptor_setTaskTableEntry(creatorIndex, FALSE, creatorId, "", 0, 0, 0, NULL);
/* Execute Test */
actual = OS_TaskCreate(&task_id, task_name, dummyFnc, &stack, stack_size, priority, flags);
/* Verify Outputs */
osTaskRecord_ptr = OsApi_Adaptor_getTaskTableEntry(taskIdIdx);
UtAssert_True(actual == expected, "actual == OS_SUCCESS");
UtAssert_True(getTaskSpawnFlags() == 0, "taskSpawn called with expected flags");
UtAssert_StrCmp(task_name, osTaskRecord_ptr->name, "task name == expected");
UtAssert_True(osTaskRecord_ptr->free == FALSE, "task entry not free");
UtAssert_True(osTaskRecord_ptr->id == taskSpawnId, "task id == expected");
UtAssert_True(task_id == taskIdIdx, "input task id == expected");
UtAssert_True(osTaskRecord_ptr->creator == creatorIndex, "creator ID == input");
UtAssert_True(osTaskRecord_ptr->stack_size == stack_size, "stack size == input");
UtAssert_True(osTaskRecord_ptr->priority == priority, "priority == input");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) >= 1, "semaphore taken >1");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskGetIdByName_NullName(void)
{
int32 expected = OS_INVALID_POINTER;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = 1;
const char *task_name = NULL;
/* Execute Test */
actual = OS_TaskGetIdByName(&task_id, task_name);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_INVALID_POINTER");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == 0, "No OS_TASK_TABLE_SEM taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_NetworkGetHostName_NullArg1(void)
{
/* Setup Inputs */
uint32 name_len = 13;
/* Execute Test */
int32 retval = OS_NetworkGetHostName(NULL, name_len);
/* Verify Outputs - WITH OR WITHOUT NETWORK */
UtAssert_True(retval == OS_INVALID_POINTER, "retval == OS_INVALID_POINTER");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskGetInfo_IdInvalid(void)
{
int32 expected = OS_ERR_INVALID_ID;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = OS_MAX_TASKS;
static OS_task_prop_t task_prop;
/* Execute Test */
actual = OS_TaskGetInfo(task_id, &task_prop);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERR_INVALID_ID");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) > 0, "semaphore taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskRegister_IdInvalid(void)
{
int32 expected = OS_ERR_INVALID_ID;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = 4;
OsApi_SetReturnCode(OSAPI_TASKIDSELF_INDEX, task_id, 1);
/* Execute Test */
actual = OS_TaskRegister();
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERR_INVALID_ID");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) > 0, "semaphore taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskSetPriority_PriInvalid(void)
{
int32 expected = OS_ERR_INVALID_PRIORITY;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = 8;
uint32 priority = MAX_PRIORITY + 1;
/* Execute Test */
actual = OS_TaskSetPriority(task_id, priority);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERR_INVALID_PRIORITY");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) > 0, "semaphore taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskGetInfo_NullProp(void)
{
int32 expected = OS_INVALID_POINTER;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = 1;
OS_task_prop_t *task_prop = NULL;
/* Execute Test */
actual = OS_TaskGetInfo(task_id, task_prop);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_INVALID_POINTER");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) > 0, "semaphore taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskDelete_IdIsFree(void)
{
int32 expected = OS_ERR_INVALID_ID;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = OS_MAX_TASKS - 1;
OsApi_Adaptor_setTaskTableEntry(task_id, TRUE, 1, "testTask", 2, 3, 4, deleteFnc);
/* Execute Test */
actual = OS_TaskDelete(task_id);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERR_INVALID_ID");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == 1, "semaphore taken once");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
void Test_OS_NetworkGetID_FailhostGetByName(void)
{
/* Setup Inputs */
Osnetwork_SetReturnCode(OSNETWORK_GETHOSTNAME_INDEX, 0, 1);
Osnetwork_SetReturnCode(OSNETWORK_HOSTGETBYNAME_INDEX, -1, 1);
/* Execute Test */
int32 retval = OS_NetworkGetID();
/* Verify Outputs - WITH NETWORK */
UtAssert_True(retval == OS_ERROR, "retval == OS_ERROR");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskGetIdByName_NameErr(void)
{
int32 expected = OS_ERR_NAME_NOT_FOUND;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = 1;
const char *task_name = "testTaskName";
/* Execute Test */
actual = OS_TaskGetIdByName(&task_id, task_name);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERR_NAME_NOT_FOUND");
UtAssert_True(task_id == 1, "task_id unchanged");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) > 0, "semaphore taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskDelete_Error(void)
{
int32 expected = OS_ERROR;
int32 actual = 99;
/* Setup Inputs */
uint32 task_id = 13;
OsApi_SetReturnCode(OSAPI_TASKDELETE_INDEX, VCS_ERROR, 1);
/* Execute Test */
actual = OS_TaskDelete(task_id);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERROR");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) >= 1, "semaphore taken >1");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
void Ut_CFE_TIME_SetReturnCode(uint32 Index, int32 RtnVal, uint32 CallCnt)
{
if (Index < UT_CFE_TIME_MAX_INDEX)
{
Ut_CFE_TIME_ReturnCodeTable[Index].Value = RtnVal;
Ut_CFE_TIME_ReturnCodeTable[Index].Count = CallCnt;
}
else
{
printf("Unsupported TIME Index In SetReturnCode Call %lu\n", Index);
UtAssert_True(FALSE, "Unsupported TIME Index In SetReturnCode Call");
}
}
