diff --git a/fsw/src/sc_atsrq.c b/fsw/src/sc_atsrq.c index f5cb0de..0e6a120 100644 --- a/fsw/src/sc_atsrq.c +++ b/fsw/src/sc_atsrq.c @@ -52,75 +52,72 @@ void SC_StartAtsCmd(const CFE_SB_Buffer_t *BufPtr) uint16 AtsId; /* ATS ID */ uint16 AtsIndex; /* ATS array index */ - if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_StartAtsCmd_t))) + AtsId = ((SC_StartAtsCmd_t *)BufPtr)->AtsId; + + /* validate ATS ID */ + if ((AtsId > 0) && (AtsId <= SC_NUMBER_OF_ATS)) { - AtsId = ((SC_StartAtsCmd_t *)BufPtr)->AtsId; + /* convert ATS ID to array index */ + AtsIndex = SC_ATS_ID_TO_INDEX(AtsId); - /* validate ATS ID */ - if ((AtsId > 0) && (AtsId <= SC_NUMBER_OF_ATS)) + /* make sure that there is no ATS running on the ATP */ + if (SC_OperData.AtsCtrlBlckAddr->AtpState == SC_IDLE) { - /* convert ATS ID to array index */ - AtsIndex = SC_ATS_ID_TO_INDEX(AtsId); - - /* make sure that there is no ATS running on the ATP */ - if (SC_OperData.AtsCtrlBlckAddr->AtpState == SC_IDLE) + /* make sure the specified ATS is ready */ + if (SC_OperData.AtsInfoTblAddr[AtsIndex].NumberOfCommands > 0) { - /* make sure the specified ATS is ready */ - if (SC_OperData.AtsInfoTblAddr[AtsIndex].NumberOfCommands > 0) + /* start the ats */ + if (SC_BeginAts(AtsIndex, 0)) { - /* start the ats */ - if (SC_BeginAts(AtsIndex, 0)) - { - /* finish the ATP control block .. */ - SC_OperData.AtsCtrlBlckAddr->AtpState = SC_EXECUTING; - - /* increment the command request counter */ - SC_OperData.HkPacket.CmdCtr++; - - CFE_EVS_SendEvent(SC_STARTATS_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, - "ATS %c Execution Started", (AtsIndex ? 'B' : 'A')); - } - else - { /* could not start the ats, all commands were skipped */ - /* event message was sent from SC_BeginAts */ - /* increment the command request error counter */ - /* SC_OperData.AtsCtrlBlckAddr->AtpState is updated in SC_KillAts */ - SC_OperData.HkPacket.CmdErrCtr++; - - } /* end if */ - } - else - { /* the ats didn't have any commands in it */ + /* finish the ATP control block .. */ + SC_OperData.AtsCtrlBlckAddr->AtpState = SC_EXECUTING; - CFE_EVS_SendEvent(SC_STARTATS_CMD_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR, - "Start ATS Rejected: ATS %c Not Loaded", (AtsIndex ? 'B' : 'A')); + /* increment the command request counter */ + SC_OperData.HkPacket.CmdCtr++; + CFE_EVS_SendEvent(SC_STARTATS_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, + "ATS %c Execution Started", (AtsIndex ? 'B' : 'A')); + } + else + { /* could not start the ats, all commands were skipped */ + /* event message was sent from SC_BeginAts */ /* increment the command request error counter */ + /* SC_OperData.AtsCtrlBlckAddr->AtpState is updated in SC_KillAts */ SC_OperData.HkPacket.CmdErrCtr++; } /* end if */ } else - { /* the ATS is being used */ + { /* the ats didn't have any commands in it */ + + CFE_EVS_SendEvent(SC_STARTATS_CMD_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR, + "Start ATS Rejected: ATS %c Not Loaded", (AtsIndex ? 'B' : 'A')); - CFE_EVS_SendEvent(SC_STARTATS_CMD_NOT_IDLE_ERR_EID, CFE_EVS_EventType_ERROR, - "Start ATS Rejected: ATP is not Idle"); /* increment the command request error counter */ SC_OperData.HkPacket.CmdErrCtr++; } /* end if */ } else - { /* the specified ATS id is not valid */ - - CFE_EVS_SendEvent(SC_STARTATS_CMD_INVLD_ID_ERR_EID, CFE_EVS_EventType_ERROR, - "Start ATS %d Rejected: Invalid ATS ID", AtsId); + { /* the ATS is being used */ + CFE_EVS_SendEvent(SC_STARTATS_CMD_NOT_IDLE_ERR_EID, CFE_EVS_EventType_ERROR, + "Start ATS Rejected: ATP is not Idle"); /* increment the command request error counter */ SC_OperData.HkPacket.CmdErrCtr++; } /* end if */ } + else + { /* the specified ATS id is not valid */ + + CFE_EVS_SendEvent(SC_STARTATS_CMD_INVLD_ID_ERR_EID, CFE_EVS_EventType_ERROR, + "Start ATS %d Rejected: Invalid ATS ID", AtsId); + + /* increment the command request error counter */ + SC_OperData.HkPacket.CmdErrCtr++; + + } /* end if */ } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -133,43 +130,40 @@ void SC_StopAtsCmd(const CFE_SB_Buffer_t *BufPtr) char TempAtsChar = ' '; int32 Result = SC_ERROR; - if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_NoArgsCmd_t))) + /* + ** Set the temp ATS ID if it is valid + */ + if (SC_OperData.AtsCtrlBlckAddr->AtsNumber == SC_ATSA) { - /* - ** Set the temp ATS ID if it is valid - */ - if (SC_OperData.AtsCtrlBlckAddr->AtsNumber == SC_ATSA) + TempAtsChar = 'A'; + Result = CFE_SUCCESS; + } + else + { + if (SC_OperData.AtsCtrlBlckAddr->AtsNumber == SC_ATSB) { - TempAtsChar = 'A'; + TempAtsChar = 'B'; Result = CFE_SUCCESS; } - else - { - if (SC_OperData.AtsCtrlBlckAddr->AtsNumber == SC_ATSB) - { - TempAtsChar = 'B'; - Result = CFE_SUCCESS; - } - } + } - if (Result == CFE_SUCCESS) - { - CFE_EVS_SendEvent(SC_STOPATS_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, "ATS %c stopped", TempAtsChar); - } - else - { - CFE_EVS_SendEvent(SC_STOPATS_NO_ATS_INF_EID, CFE_EVS_EventType_INFORMATION, - "There is no ATS running to stop"); - } + if (Result == CFE_SUCCESS) + { + CFE_EVS_SendEvent(SC_STOPATS_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, "ATS %c stopped", TempAtsChar); + } + else + { + CFE_EVS_SendEvent(SC_STOPATS_NO_ATS_INF_EID, CFE_EVS_EventType_INFORMATION, + "There is no ATS running to stop"); + } - /* Stop the ATS from executing */ - SC_KillAts(); + /* Stop the ATS from executing */ + SC_KillAts(); - /* clear the global switch pend flag */ - SC_OperData.AtsCtrlBlckAddr->SwitchPendFlag = false; + /* clear the global switch pend flag */ + SC_OperData.AtsCtrlBlckAddr->SwitchPendFlag = false; - SC_OperData.HkPacket.CmdCtr++; - } + SC_OperData.HkPacket.CmdCtr++; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -301,8 +295,6 @@ void SC_GroundSwitchCmd(const CFE_SB_Buffer_t *BufPtr) { uint16 NewAtsIndex; /* the index of the ats to switch to*/ - if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_NoArgsCmd_t))) - { /* make sure that an ATS is running on the ATP */ if (SC_OperData.AtsCtrlBlckAddr->AtpState == SC_EXECUTING) { @@ -323,29 +315,28 @@ void SC_GroundSwitchCmd(const CFE_SB_Buffer_t *BufPtr) else { /* the other ATS does not have any commands in it */ - CFE_EVS_SendEvent(SC_SWITCH_ATS_CMD_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR, - "Switch ATS Failure: Destination ATS Not Loaded"); - - /* update command error counter */ - SC_OperData.HkPacket.CmdErrCtr++; - - SC_OperData.AtsCtrlBlckAddr->SwitchPendFlag = false; - - } /* end if */ - } - else - { /* the ATP is not currently executing any commands */ - - CFE_EVS_SendEvent(SC_SWITCH_ATS_CMD_IDLE_ERR_EID, CFE_EVS_EventType_ERROR, - "Switch ATS Rejected: ATP is idle"); + CFE_EVS_SendEvent(SC_SWITCH_ATS_CMD_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR, + "Switch ATS Failure: Destination ATS Not Loaded"); - /* update the command error counter */ + /* update command error counter */ SC_OperData.HkPacket.CmdErrCtr++; SC_OperData.AtsCtrlBlckAddr->SwitchPendFlag = false; } /* end if */ } + else + { /* the ATP is not currently executing any commands */ + + CFE_EVS_SendEvent(SC_SWITCH_ATS_CMD_IDLE_ERR_EID, CFE_EVS_EventType_ERROR, + "Switch ATS Rejected: ATP is idle"); + + /* update the command error counter */ + SC_OperData.HkPacket.CmdErrCtr++; + + SC_OperData.AtsCtrlBlckAddr->SwitchPendFlag = false; + + } /* end if */ } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -504,115 +495,113 @@ void SC_JumpAtsCmd(const CFE_SB_Buffer_t *BufPtr) CFE_TIME_SysTime_t NewTime; uint16 NumSkipped; - if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_JumpAtsCmd_t))) + if (SC_OperData.AtsCtrlBlckAddr->AtpState == SC_EXECUTING) { - if (SC_OperData.AtsCtrlBlckAddr->AtpState == SC_EXECUTING) - { - JumpTime = ((SC_JumpAtsCmd_t *)BufPtr)->NewTime; - AtsIndex = SC_ATS_NUM_TO_INDEX(SC_OperData.AtsCtrlBlckAddr->AtsNumber); + JumpTime = ((SC_JumpAtsCmd_t *)BufPtr)->NewTime; + AtsIndex = SC_ATS_NUM_TO_INDEX(SC_OperData.AtsCtrlBlckAddr->AtsNumber); - /* - ** Loop through the commands until a time tag is found - ** that has a time greater than or equal to the current time OR - ** all of the commands have been skipped - */ - TimeIndex = 0; - NumSkipped = 0; + /* + ** Loop through the commands until a time tag is found + ** that has a time greater than or equal to the current time OR + ** all of the commands have been skipped + */ + TimeIndex = 0; + NumSkipped = 0; - while (TimeIndex < SC_OperData.AtsInfoTblAddr[AtsIndex].NumberOfCommands) + while (TimeIndex < SC_OperData.AtsInfoTblAddr[AtsIndex].NumberOfCommands) + { + /* first get the cmd index at this list entry */ + CmdIndex = SC_ATS_CMD_NUM_TO_INDEX(SC_AppData.AtsTimeIndexBuffer[AtsIndex][TimeIndex]); + /* then get the entry index from the cmd index table */ + EntryIndex = SC_AppData.AtsCmdIndexBuffer[AtsIndex][CmdIndex]; + /* then get a pointer to the ATS entry data */ + Entry = (SC_AtsEntryHeader_t *)&SC_OperData.AtsTblAddr[AtsIndex][EntryIndex]; + /* then get cmd execution time from the ATS entry */ + ListCmdTime = SC_GetAtsEntryTime(Entry); + + /* compare ATS jump time to this list entry time */ + if (SC_CompareAbsTime(JumpTime, ListCmdTime)) { - /* first get the cmd index at this list entry */ - CmdIndex = SC_ATS_CMD_NUM_TO_INDEX(SC_AppData.AtsTimeIndexBuffer[AtsIndex][TimeIndex]); - /* then get the entry index from the cmd index table */ - EntryIndex = SC_AppData.AtsCmdIndexBuffer[AtsIndex][CmdIndex]; - /* then get a pointer to the ATS entry data */ - Entry = (SC_AtsEntryHeader_t *)&SC_OperData.AtsTblAddr[AtsIndex][EntryIndex]; - /* then get cmd execution time from the ATS entry */ - ListCmdTime = SC_GetAtsEntryTime(Entry); - - /* compare ATS jump time to this list entry time */ - if (SC_CompareAbsTime(JumpTime, ListCmdTime)) - { - /* jump time is greater than this list entry time */ - - /* - ** If the ATS command is loaded and ready to run, then - ** mark the command as being skipped - ** if the command has any other status, SC_SKIPPED, SC_EXECUTED, - ** etc, then leave the status alone. - */ - if (SC_OperData.AtsCmdStatusTblAddr[AtsIndex][CmdIndex] == SC_LOADED) - { - SC_OperData.AtsCmdStatusTblAddr[AtsIndex][CmdIndex] = SC_SKIPPED; - NumSkipped++; - } - - TimeIndex++; - } - else + /* jump time is greater than this list entry time */ + + /* + ** If the ATS command is loaded and ready to run, then + ** mark the command as being skipped + ** if the command has any other status, SC_SKIPPED, SC_EXECUTED, + ** etc, then leave the status alone. + */ + if (SC_OperData.AtsCmdStatusTblAddr[AtsIndex][CmdIndex] == SC_LOADED) { - /* jump time is less than or equal to this list entry */ - CFE_EVS_SendEvent(SC_JUMPATS_CMD_LIST_INF_EID, CFE_EVS_EventType_INFORMATION, - "Jump Cmd: Jump time less than or equal to list entry %d", CmdIndex); - break; + SC_OperData.AtsCmdStatusTblAddr[AtsIndex][CmdIndex] = SC_SKIPPED; + NumSkipped++; } - } - - /* - ** Check to see if the whole ATS was skipped - */ - if (TimeIndex == SC_OperData.AtsInfoTblAddr[AtsIndex].NumberOfCommands) - { - CFE_EVS_SendEvent(SC_JUMPATS_CMD_STOPPED_ERR_EID, CFE_EVS_EventType_ERROR, - "Jump Cmd: All ATS commands were skipped, ATS stopped"); - SC_OperData.HkPacket.CmdErrCtr++; - - /* stop the ats */ - SC_KillAts(); + TimeIndex++; } else - { /* there is at least one command to execute */ + { + /* jump time is less than or equal to this list entry */ + CFE_EVS_SendEvent(SC_JUMPATS_CMD_LIST_INF_EID, CFE_EVS_EventType_INFORMATION, + "Jump Cmd: Jump time less than or equal to list entry %d", CmdIndex); + break; + } + } - /* - ** Update the ATP Control Block entries. - */ - SC_OperData.AtsCtrlBlckAddr->CmdNumber = SC_ATS_CMD_INDEX_TO_NUM(CmdIndex); - SC_OperData.AtsCtrlBlckAddr->TimeIndexPtr = TimeIndex; + /* + ** Check to see if the whole ATS was skipped + */ + if (TimeIndex == SC_OperData.AtsInfoTblAddr[AtsIndex].NumberOfCommands) + { + CFE_EVS_SendEvent(SC_JUMPATS_CMD_STOPPED_ERR_EID, CFE_EVS_EventType_ERROR, + "Jump Cmd: All ATS commands were skipped, ATS stopped"); - /* - ** Set the next command time for the ATP - */ - SC_AppData.NextCmdTime[SC_ATP] = ListCmdTime; + SC_OperData.HkPacket.CmdErrCtr++; - SC_OperData.HkPacket.CmdCtr++; + /* stop the ats */ + SC_KillAts(); + } + else + { /* there is at least one command to execute */ - /* print out the date in a readable format */ - NewTime.Seconds = ListCmdTime; - NewTime.Subseconds = 0; + /* + ** Update the ATP Control Block entries. + */ + SC_OperData.AtsCtrlBlckAddr->CmdNumber = SC_ATS_CMD_INDEX_TO_NUM(CmdIndex); + SC_OperData.AtsCtrlBlckAddr->TimeIndexPtr = TimeIndex; - CFE_TIME_Print((char *)&TimeBuffer, NewTime); + /* + ** Set the next command time for the ATP + */ + SC_AppData.NextCmdTime[SC_ATP] = ListCmdTime; - CFE_EVS_SendEvent(SC_JUMP_ATS_INF_EID, CFE_EVS_EventType_INFORMATION, - "Next ATS command time in the ATP was set to %s", TimeBuffer); - if (NumSkipped > 0) - { - /* We skipped come commands, but not all of them */ - CFE_EVS_SendEvent(SC_JUMP_ATS_SKIPPED_DBG_EID, CFE_EVS_EventType_DEBUG, - "Jump Cmd: Skipped %d ATS commands", NumSkipped); - } + SC_OperData.HkPacket.CmdCtr++; - } /* end if */ - } - else - { /* There is not a running ATS */ + /* print out the date in a readable format */ + NewTime.Seconds = ListCmdTime; + NewTime.Subseconds = 0; - CFE_EVS_SendEvent(SC_JUMPATS_CMD_NOT_ACT_ERR_EID, CFE_EVS_EventType_ERROR, - "ATS Jump Failed: No active ATS"); - SC_OperData.HkPacket.CmdErrCtr++; + CFE_TIME_Print((char *)&TimeBuffer, NewTime); + + CFE_EVS_SendEvent(SC_JUMP_ATS_INF_EID, CFE_EVS_EventType_INFORMATION, + "Next ATS command time in the ATP was set to %s", TimeBuffer); + if (NumSkipped > 0) + { + /* We skipped come commands, but not all of them */ + CFE_EVS_SendEvent(SC_JUMP_ATS_SKIPPED_DBG_EID, CFE_EVS_EventType_DEBUG, + "Jump Cmd: Skipped %d ATS commands", NumSkipped); + } } /* end if */ } + + else + { /* There is not a running ATS */ + + CFE_EVS_SendEvent(SC_JUMPATS_CMD_NOT_ACT_ERR_EID, CFE_EVS_EventType_ERROR, + "ATS Jump Failed: No active ATS"); + SC_OperData.HkPacket.CmdErrCtr++; + + } /* end if */ } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -624,26 +613,23 @@ void SC_ContinueAtsOnFailureCmd(const CFE_SB_Buffer_t *BufPtr) { uint16 State; - if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_SetContinueAtsOnFailureCmd_t))) - { - State = ((SC_SetContinueAtsOnFailureCmd_t *)BufPtr)->ContinueState; + State = ((SC_SetContinueAtsOnFailureCmd_t *)BufPtr)->ContinueState; - if (State != SC_CONTINUE_TRUE && State != SC_CONTINUE_FALSE) - { - SC_OperData.HkPacket.CmdErrCtr++; + if (State != SC_CONTINUE_TRUE && State != SC_CONTINUE_FALSE) + { + SC_OperData.HkPacket.CmdErrCtr++; - CFE_EVS_SendEvent(SC_CONT_CMD_ERR_EID, CFE_EVS_EventType_ERROR, - "Continue ATS On Failure command failed, invalid state: %d", State); - } - else - { - SC_OperData.HkPacket.ContinueAtsOnFailureFlag = State; + CFE_EVS_SendEvent(SC_CONT_CMD_ERR_EID, CFE_EVS_EventType_ERROR, + "Continue ATS On Failure command failed, invalid state: %d", State); + } + else + { + SC_OperData.HkPacket.ContinueAtsOnFailureFlag = State; - SC_OperData.HkPacket.CmdCtr++; + SC_OperData.HkPacket.CmdCtr++; - CFE_EVS_SendEvent(SC_CONT_CMD_DEB_EID, CFE_EVS_EventType_DEBUG, - "Continue-ATS-On-Failure command, State: %d", State); - } + CFE_EVS_SendEvent(SC_CONT_CMD_DEB_EID, CFE_EVS_EventType_DEBUG, + "Continue-ATS-On-Failure command, State: %d", State); } } @@ -657,62 +643,59 @@ void SC_AppendAtsCmd(const CFE_SB_Buffer_t *BufPtr) SC_AppendAtsCmd_t *AppendCmd = (SC_AppendAtsCmd_t *)BufPtr; uint16 AtsIndex; /* index (not ID) of target ATS */ - if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_AppendAtsCmd_t))) + if ((AppendCmd->AtsId == 0) || (AppendCmd->AtsId > SC_NUMBER_OF_ATS)) { - if ((AppendCmd->AtsId == 0) || (AppendCmd->AtsId > SC_NUMBER_OF_ATS)) - { - /* invalid target ATS selection */ - SC_OperData.HkPacket.CmdErrCtr++; + /* invalid target ATS selection */ + SC_OperData.HkPacket.CmdErrCtr++; - CFE_EVS_SendEvent(SC_APPEND_CMD_ARG_ERR_EID, CFE_EVS_EventType_ERROR, - "Append ATS error: invalid ATS ID = %d", AppendCmd->AtsId); + CFE_EVS_SendEvent(SC_APPEND_CMD_ARG_ERR_EID, CFE_EVS_EventType_ERROR, + "Append ATS error: invalid ATS ID = %d", AppendCmd->AtsId); - return; - } + return; + } - /* create base zero array index from base one ID value */ - AtsIndex = SC_ATS_ID_TO_INDEX(AppendCmd->AtsId); + /* create base zero array index from base one ID value */ + AtsIndex = SC_ATS_ID_TO_INDEX(AppendCmd->AtsId); - if (SC_OperData.AtsInfoTblAddr[AtsIndex].NumberOfCommands == 0) - { - /* target ATS table is empty */ - SC_OperData.HkPacket.CmdErrCtr++; + if (SC_OperData.AtsInfoTblAddr[AtsIndex].NumberOfCommands == 0) + { + /* target ATS table is empty */ + SC_OperData.HkPacket.CmdErrCtr++; - CFE_EVS_SendEvent(SC_APPEND_CMD_TGT_ERR_EID, CFE_EVS_EventType_ERROR, - "Append ATS %c error: ATS table is empty", 'A' + AtsIndex); - } - else if (SC_OperData.HkPacket.AppendEntryCount == 0) - { - /* append table is empty */ - SC_OperData.HkPacket.CmdErrCtr++; + CFE_EVS_SendEvent(SC_APPEND_CMD_TGT_ERR_EID, CFE_EVS_EventType_ERROR, + "Append ATS %c error: ATS table is empty", 'A' + AtsIndex); + } + else if (SC_OperData.HkPacket.AppendEntryCount == 0) + { + /* append table is empty */ + SC_OperData.HkPacket.CmdErrCtr++; - CFE_EVS_SendEvent(SC_APPEND_CMD_SRC_ERR_EID, CFE_EVS_EventType_ERROR, - "Append ATS %c error: Append table is empty", 'A' + AtsIndex); - } - else if ((SC_OperData.AtsInfoTblAddr[AtsIndex].AtsSize + SC_AppData.AppendWordCount) > SC_ATS_BUFF_SIZE32) - { - /* not enough room in ATS buffer for Append table data */ - SC_OperData.HkPacket.CmdErrCtr++; + CFE_EVS_SendEvent(SC_APPEND_CMD_SRC_ERR_EID, CFE_EVS_EventType_ERROR, + "Append ATS %c error: Append table is empty", 'A' + AtsIndex); + } + else if ((SC_OperData.AtsInfoTblAddr[AtsIndex].AtsSize + SC_AppData.AppendWordCount) > SC_ATS_BUFF_SIZE32) + { + /* not enough room in ATS buffer for Append table data */ + SC_OperData.HkPacket.CmdErrCtr++; - CFE_EVS_SendEvent(SC_APPEND_CMD_FIT_ERR_EID, CFE_EVS_EventType_ERROR, - "Append ATS %c error: ATS size = %d, Append size = %d, ATS buffer = %d", 'A' + AtsIndex, - (int)SC_OperData.AtsInfoTblAddr[AtsIndex].AtsSize, SC_AppData.AppendWordCount, - SC_ATS_BUFF_SIZE32); - } - else - { - /* store ATS selection from most recent ATS Append command */ - SC_OperData.HkPacket.AppendCmdArg = AppendCmd->AtsId; + CFE_EVS_SendEvent(SC_APPEND_CMD_FIT_ERR_EID, CFE_EVS_EventType_ERROR, + "Append ATS %c error: ATS size = %d, Append size = %d, ATS buffer = %d", 'A' + AtsIndex, + (int)SC_OperData.AtsInfoTblAddr[AtsIndex].AtsSize, SC_AppData.AppendWordCount, + SC_ATS_BUFF_SIZE32); + } + else + { + /* store ATS selection from most recent ATS Append command */ + SC_OperData.HkPacket.AppendCmdArg = AppendCmd->AtsId; - /* copy append data and re-calc timing data */ - SC_ProcessAppend(AtsIndex); + /* copy append data and re-calc timing data */ + SC_ProcessAppend(AtsIndex); - /* increment command success counter */ - SC_OperData.HkPacket.CmdCtr++; + /* increment command success counter */ + SC_OperData.HkPacket.CmdCtr++; - CFE_EVS_SendEvent(SC_APPEND_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, - "Append ATS %c command: %d ATS entries appended", 'A' + AtsIndex, - SC_OperData.HkPacket.AppendEntryCount); - } + CFE_EVS_SendEvent(SC_APPEND_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, + "Append ATS %c command: %d ATS entries appended", 'A' + AtsIndex, + SC_OperData.HkPacket.AppendEntryCount); } } diff --git a/fsw/src/sc_cmds.c b/fsw/src/sc_cmds.c index 3b2f86d..d678cce 100644 --- a/fsw/src/sc_cmds.c +++ b/fsw/src/sc_cmds.c @@ -475,19 +475,16 @@ void SC_SendHkPacket(void) void SC_ResetCountersCmd(const CFE_SB_Buffer_t *BufPtr) { - if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_NoArgsCmd_t))) - { - CFE_EVS_SendEvent(SC_RESET_DEB_EID, CFE_EVS_EventType_DEBUG, "Reset counters command"); - - SC_OperData.HkPacket.CmdCtr = 0; - SC_OperData.HkPacket.CmdErrCtr = 0; - SC_OperData.HkPacket.AtsCmdCtr = 0; - SC_OperData.HkPacket.AtsCmdErrCtr = 0; - SC_OperData.HkPacket.RtsCmdCtr = 0; - SC_OperData.HkPacket.RtsCmdErrCtr = 0; - SC_OperData.HkPacket.RtsActiveCtr = 0; - SC_OperData.HkPacket.RtsActiveErrCtr = 0; - } + CFE_EVS_SendEvent(SC_RESET_DEB_EID, CFE_EVS_EventType_DEBUG, "Reset counters command"); + + SC_OperData.HkPacket.CmdCtr = 0; + SC_OperData.HkPacket.CmdErrCtr = 0; + SC_OperData.HkPacket.AtsCmdCtr = 0; + SC_OperData.HkPacket.AtsCmdErrCtr = 0; + SC_OperData.HkPacket.RtsCmdCtr = 0; + SC_OperData.HkPacket.RtsCmdErrCtr = 0; + SC_OperData.HkPacket.RtsActiveCtr = 0; + SC_OperData.HkPacket.RtsActiveErrCtr = 0; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -497,12 +494,9 @@ void SC_ResetCountersCmd(const CFE_SB_Buffer_t *BufPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void SC_NoOpCmd(const CFE_SB_Buffer_t *BufPtr) { - if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_NoArgsCmd_t))) - { - SC_OperData.HkPacket.CmdCtr++; - CFE_EVS_SendEvent(SC_NOOP_INF_EID, CFE_EVS_EventType_INFORMATION, "No-op command. Version %d.%d.%d.%d", - SC_MAJOR_VERSION, SC_MINOR_VERSION, SC_REVISION, SC_MISSION_REV); - } + SC_OperData.HkPacket.CmdCtr++; + CFE_EVS_SendEvent(SC_NOOP_INF_EID, CFE_EVS_EventType_INFORMATION, "No-op command. Version %d.%d.%d.%d", + SC_MAJOR_VERSION, SC_MINOR_VERSION, SC_REVISION, SC_MISSION_REV); } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -628,73 +622,129 @@ void SC_ProcessCommand(const CFE_SB_Buffer_t *BufPtr) switch (CommandCode) { case SC_NOOP_CC: - SC_NoOpCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_NoArgsCmd_t))) + { + SC_NoOpCmd(BufPtr); + } break; + case SC_RESET_COUNTERS_CC: - SC_ResetCountersCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_NoArgsCmd_t))) + { + SC_ResetCountersCmd(BufPtr); + } break; case SC_START_ATS_CC: - SC_StartAtsCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_StartAtsCmd_t))) + { + SC_StartAtsCmd(BufPtr); + } break; case SC_STOP_ATS_CC: - SC_StopAtsCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_NoArgsCmd_t))) + { + SC_StopAtsCmd(BufPtr); + } break; case SC_START_RTS_CC: - SC_StartRtsCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_RtsCmd_t))) + { + SC_StartRtsCmd(BufPtr); + } + else + { + SC_OperData.HkPacket.RtsActiveErrCtr++; + } break; case SC_STOP_RTS_CC: - SC_StopRtsCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_RtsCmd_t))) + { + SC_StopRtsCmd(BufPtr); + } break; case SC_DISABLE_RTS_CC: - SC_DisableRtsCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_RtsCmd_t))) + { + SC_DisableRtsCmd(BufPtr); + } break; case SC_ENABLE_RTS_CC: - SC_EnableRtsCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_RtsCmd_t))) + { + SC_EnableRtsCmd(BufPtr); + } break; case SC_SWITCH_ATS_CC: - SC_GroundSwitchCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_NoArgsCmd_t))) + { + SC_GroundSwitchCmd(BufPtr); + } break; case SC_JUMP_ATS_CC: - SC_JumpAtsCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_JumpAtsCmd_t))) + { + SC_JumpAtsCmd(BufPtr); + } break; case SC_CONTINUE_ATS_ON_FAILURE_CC: - SC_ContinueAtsOnFailureCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_SetContinueAtsOnFailureCmd_t))) + { + SC_ContinueAtsOnFailureCmd(BufPtr); + } break; case SC_APPEND_ATS_CC: - SC_AppendAtsCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_AppendAtsCmd_t))) + { + SC_AppendAtsCmd(BufPtr); + } break; case SC_MANAGE_TABLE_CC: - SC_TableManageCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_NoArgsCmd_t))) + { + SC_TableManageCmd(BufPtr); + } break; #if (SC_ENABLE_GROUP_COMMANDS == true) case SC_START_RTS_GRP_CC: - SC_StartRtsGrpCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_RtsGrpCmd_t))) + { + SC_StartRtsGrpCmd(BufPtr); + } break; case SC_STOP_RTS_GRP_CC: - SC_StopRtsGrpCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_RtsGrpCmd_t))) + { + SC_StopRtsGrpCmd(BufPtr); + } break; case SC_DISABLE_RTS_GRP_CC: - SC_DisableRtsGrpCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_RtsGrpCmd_t))) + { + SC_DisableRtsGrpCmd(BufPtr); + } break; case SC_ENABLE_RTS_GRP_CC: - SC_EnableRtsGrpCmd(BufPtr); + if (SC_VerifyCmdLength(&BufPtr->Msg, sizeof(SC_RtsGrpCmd_t))) + { + SC_EnableRtsGrpCmd(BufPtr); + } break; #endif diff --git a/fsw/src/sc_rtsrq.c b/fsw/src/sc_rtsrq.c index 83a8a43..d45b998 100644 --- a/fsw/src/sc_rtsrq.c +++ b/fsw/src/sc_rtsrq.c @@ -55,102 +55,88 @@ void SC_StartRtsCmd(const CFE_SB_Buffer_t *CmdPacket) SC_RtsEntryHeader_t *RtsEntryPtr; /* pointer to an rts entry */ CFE_MSG_Message_t * RtsEntryCmd; /* pointer to an rts command */ CFE_MSG_Size_t CmdLength = 0; /* the length of the 1st cmd */ + /* - ** Verify command packet length... + ** Check start RTS parameters */ - if (SC_VerifyCmdLength(&CmdPacket->Msg, sizeof(SC_RtsCmd_t))) + RtsId = ((SC_RtsCmd_t *)CmdPacket)->RtsId; + + if ((RtsId > 0) && (RtsId <= SC_NUMBER_OF_RTS)) { - /* - ** Check start RTS parameters - */ - RtsId = ((SC_RtsCmd_t *)CmdPacket)->RtsId; + /* convert RTS ID to RTS array index */ + RtsIndex = SC_RTS_ID_TO_INDEX(RtsId); - if ((RtsId > 0) && (RtsId <= SC_NUMBER_OF_RTS)) + /* make sure that RTS is not disabled */ + if (SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag == false) { - /* convert RTS ID to RTS array index */ - RtsIndex = SC_RTS_ID_TO_INDEX(RtsId); - - /* make sure that RTS is not disabled */ - if (SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag == false) + /* the requested RTS is not being used and is not empty */ + if (SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus == SC_LOADED) { - /* the requested RTS is not being used and is not empty */ - if (SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus == SC_LOADED) + /* + ** Check the command length + */ + RtsEntryPtr = (SC_RtsEntryHeader_t *)SC_OperData.RtsTblAddr[RtsIndex]; + RtsEntryCmd = (CFE_MSG_Message_t *)((uint8_t *)RtsEntryPtr + SC_RTS_HEADER_SIZE); + + CFE_MSG_GetSize(RtsEntryCmd, &CmdLength); + + /* Make sure the command is big enough, but not too big */ + if (CmdLength >= SC_PACKET_MIN_SIZE && CmdLength <= SC_PACKET_MAX_SIZE) { /* - ** Check the command length - */ - RtsEntryPtr = (SC_RtsEntryHeader_t *)SC_OperData.RtsTblAddr[RtsIndex]; - RtsEntryCmd = (CFE_MSG_Message_t *)((uint8_t *)RtsEntryPtr + SC_RTS_HEADER_SIZE); + ** Initialize the RTS info table entry + */ + SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus = SC_EXECUTING; + SC_OperData.RtsInfoTblAddr[RtsIndex].CmdCtr = 0; + SC_OperData.RtsInfoTblAddr[RtsIndex].CmdErrCtr = 0; + SC_OperData.RtsInfoTblAddr[RtsIndex].NextCommandPtr = 0; + SC_OperData.RtsInfoTblAddr[RtsIndex].UseCtr++; - CFE_MSG_GetSize(RtsEntryCmd, &CmdLength); + /* + ** Get the absolute time for the RTSs next_cmd_time + ** using the current time and the relative time tag. + */ + SC_OperData.RtsInfoTblAddr[RtsIndex].NextCommandTime = + SC_ComputeAbsTime(((SC_RtsEntryHeader_t *)SC_OperData.RtsTblAddr[RtsIndex])->TimeTag); - /* Make sure the command is big enough, but not too big */ - if (CmdLength >= SC_PACKET_MIN_SIZE && CmdLength <= SC_PACKET_MAX_SIZE) + /* + ** Last, Increment some global counters associated with the + ** starting of the RTS + */ + SC_OperData.RtsCtrlBlckAddr->NumRtsActive++; + SC_OperData.HkPacket.RtsActiveCtr++; + SC_OperData.HkPacket.CmdCtr++; + + if (((SC_RtsCmd_t *)CmdPacket)->RtsId <= SC_LAST_RTS_WITH_EVENTS) { - /* - ** Initialize the RTS info table entry - */ - SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus = SC_EXECUTING; - SC_OperData.RtsInfoTblAddr[RtsIndex].CmdCtr = 0; - SC_OperData.RtsInfoTblAddr[RtsIndex].CmdErrCtr = 0; - SC_OperData.RtsInfoTblAddr[RtsIndex].NextCommandPtr = 0; - SC_OperData.RtsInfoTblAddr[RtsIndex].UseCtr++; - - /* - ** Get the absolute time for the RTSs next_cmd_time - ** using the current time and the relative time tag. - */ - SC_OperData.RtsInfoTblAddr[RtsIndex].NextCommandTime = - SC_ComputeAbsTime(((SC_RtsEntryHeader_t *)SC_OperData.RtsTblAddr[RtsIndex])->TimeTag); - - /* - ** Last, Increment some global counters associated with the - ** starting of the RTS - */ - SC_OperData.RtsCtrlBlckAddr->NumRtsActive++; - SC_OperData.HkPacket.RtsActiveCtr++; - SC_OperData.HkPacket.CmdCtr++; - - if (((SC_RtsCmd_t *)CmdPacket)->RtsId <= SC_LAST_RTS_WITH_EVENTS) - { - CFE_EVS_SendEvent(SC_RTS_START_INF_EID, CFE_EVS_EventType_INFORMATION, - "RTS Number %03d Started", RtsId); - } - else - { - CFE_EVS_SendEvent(SC_STARTRTS_CMD_DBG_EID, CFE_EVS_EventType_DEBUG, "Start RTS #%d command", - RtsId); - } + CFE_EVS_SendEvent(SC_RTS_START_INF_EID, CFE_EVS_EventType_INFORMATION, + "RTS Number %03d Started", RtsId); } else - { /* the length field of the 1st cmd was bad */ - CFE_EVS_SendEvent( - SC_STARTRTS_CMD_INVLD_LEN_ERR_EID, CFE_EVS_EventType_ERROR, - "Start RTS %03d Rejected: Invld Len Field for 1st Cmd in Sequence. Invld Cmd Length = %d", - RtsId, (int)CmdLength); - - SC_OperData.HkPacket.CmdErrCtr++; - SC_OperData.HkPacket.RtsActiveErrCtr++; - - } /* end if - check command number */ + { + CFE_EVS_SendEvent(SC_STARTRTS_CMD_DBG_EID, CFE_EVS_EventType_DEBUG, "Start RTS #%d command", + RtsId); + } } else - { /* Cannot use the RTS now */ - - CFE_EVS_SendEvent(SC_STARTRTS_CMD_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR, - "Start RTS %03d Rejected: RTS Not Loaded or In Use, Status: %d", - ((SC_RtsCmd_t *)CmdPacket)->RtsId, - SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus); + { /* the length field of the 1st cmd was bad */ + CFE_EVS_SendEvent( + SC_STARTRTS_CMD_INVLD_LEN_ERR_EID, CFE_EVS_EventType_ERROR, + "Start RTS %03d Rejected: Invld Len Field for 1st Cmd in Sequence. Invld Cmd Length = %d", + RtsId, (int)CmdLength); SC_OperData.HkPacket.CmdErrCtr++; SC_OperData.HkPacket.RtsActiveErrCtr++; - } /* end if */ + } /* end if - check command number */ } else - { /* the RTS is disabled */ - CFE_EVS_SendEvent(SC_STARTRTS_CMD_DISABLED_ERR_EID, CFE_EVS_EventType_ERROR, - "Start RTS %03d Rejected: RTS Disabled", RtsId); + { /* Cannot use the RTS now */ + + CFE_EVS_SendEvent(SC_STARTRTS_CMD_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR, + "Start RTS %03d Rejected: RTS Not Loaded or In Use, Status: %d", + ((SC_RtsCmd_t *)CmdPacket)->RtsId, + SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus); SC_OperData.HkPacket.CmdErrCtr++; SC_OperData.HkPacket.RtsActiveErrCtr++; @@ -158,16 +144,20 @@ void SC_StartRtsCmd(const CFE_SB_Buffer_t *CmdPacket) } /* end if */ } else - { /* the rts id is invalid */ - CFE_EVS_SendEvent(SC_STARTRTS_CMD_INVALID_ERR_EID, CFE_EVS_EventType_ERROR, - "Start RTS %03d Rejected: Invalid RTS ID", RtsId); + { /* the RTS is disabled */ + CFE_EVS_SendEvent(SC_STARTRTS_CMD_DISABLED_ERR_EID, CFE_EVS_EventType_ERROR, + "Start RTS %03d Rejected: RTS Disabled", RtsId); SC_OperData.HkPacket.CmdErrCtr++; SC_OperData.HkPacket.RtsActiveErrCtr++; - } + } /* end if */ } else - { /* the command length is invalid */ + { /* the rts id is invalid */ + CFE_EVS_SendEvent(SC_STARTRTS_CMD_INVALID_ERR_EID, CFE_EVS_EventType_ERROR, + "Start RTS %03d Rejected: Invalid RTS ID", RtsId); + + SC_OperData.HkPacket.CmdErrCtr++; SC_OperData.HkPacket.RtsActiveErrCtr++; } } @@ -187,77 +177,74 @@ void SC_StartRtsGrpCmd(const CFE_SB_Buffer_t *CmdPacket) uint16 RtsIndex; int32 StartCount = 0; - if (SC_VerifyCmdLength(&CmdPacket->Msg, sizeof(SC_RtsGrpCmd_t))) + FirstId = ((SC_RtsGrpCmd_t *)CmdPacket)->FirstRtsId; + LastId = ((SC_RtsGrpCmd_t *)CmdPacket)->LastRtsId; + + /* make sure the specified group is valid */ + if ((FirstId > 0) && (LastId > 0) && (FirstId <= SC_NUMBER_OF_RTS) && (LastId <= SC_NUMBER_OF_RTS) && + (FirstId <= LastId)) { - FirstId = ((SC_RtsGrpCmd_t *)CmdPacket)->FirstRtsId; - LastId = ((SC_RtsGrpCmd_t *)CmdPacket)->LastRtsId; + /* convert RTS ID to RTS array index */ + FirstIndex = SC_RTS_ID_TO_INDEX(FirstId); + LastIndex = SC_RTS_ID_TO_INDEX(LastId); - /* make sure the specified group is valid */ - if ((FirstId > 0) && (LastId > 0) && (FirstId <= SC_NUMBER_OF_RTS) && (LastId <= SC_NUMBER_OF_RTS) && - (FirstId <= LastId)) + for (RtsIndex = FirstIndex; RtsIndex <= LastIndex; RtsIndex++) { - /* convert RTS ID to RTS array index */ - FirstIndex = SC_RTS_ID_TO_INDEX(FirstId); - LastIndex = SC_RTS_ID_TO_INDEX(LastId); - - for (RtsIndex = FirstIndex; RtsIndex <= LastIndex; RtsIndex++) + /* make sure that RTS is not disabled, empty or executing */ + if (SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag == false) { - /* make sure that RTS is not disabled, empty or executing */ - if (SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag == false) + if (SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus == SC_LOADED) { - if (SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus == SC_LOADED) - { - /* initialize the RTS info table entry */ - SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus = SC_EXECUTING; - SC_OperData.RtsInfoTblAddr[RtsIndex].CmdCtr = 0; - SC_OperData.RtsInfoTblAddr[RtsIndex].CmdErrCtr = 0; - SC_OperData.RtsInfoTblAddr[RtsIndex].NextCommandPtr = 0; - SC_OperData.RtsInfoTblAddr[RtsIndex].UseCtr++; - - /* get absolute time for 1st cmd in the RTS */ - SC_OperData.RtsInfoTblAddr[RtsIndex].NextCommandTime = - SC_ComputeAbsTime(((SC_RtsEntryHeader_t *)SC_OperData.RtsTblAddr[RtsIndex])->TimeTag); - - /* maintain counters associated with starting RTS */ - SC_OperData.RtsCtrlBlckAddr->NumRtsActive++; - SC_OperData.HkPacket.RtsActiveCtr++; - - /* count the RTS that were actually started */ - StartCount++; - } - else - { /* Cannot use the RTS now */ - CFE_EVS_SendEvent( - SC_STARTRTSGRP_CMD_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR, - "Start RTS group error: rejected RTS ID %03d, RTS Not Loaded or In Use, Status: %d", - SC_RTS_INDEX_TO_ID(RtsIndex), SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus); - - SC_OperData.HkPacket.RtsActiveErrCtr++; - - } /* end if */ + /* initialize the RTS info table entry */ + SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus = SC_EXECUTING; + SC_OperData.RtsInfoTblAddr[RtsIndex].CmdCtr = 0; + SC_OperData.RtsInfoTblAddr[RtsIndex].CmdErrCtr = 0; + SC_OperData.RtsInfoTblAddr[RtsIndex].NextCommandPtr = 0; + SC_OperData.RtsInfoTblAddr[RtsIndex].UseCtr++; + + /* get absolute time for 1st cmd in the RTS */ + SC_OperData.RtsInfoTblAddr[RtsIndex].NextCommandTime = + SC_ComputeAbsTime(((SC_RtsEntryHeader_t *)SC_OperData.RtsTblAddr[RtsIndex])->TimeTag); + + /* maintain counters associated with starting RTS */ + SC_OperData.RtsCtrlBlckAddr->NumRtsActive++; + SC_OperData.HkPacket.RtsActiveCtr++; + + /* count the RTS that were actually started */ + StartCount++; } else - { /* the RTS is disabled */ - CFE_EVS_SendEvent(SC_STARTRTSGRP_CMD_DISABLED_ERR_EID, CFE_EVS_EventType_ERROR, - "Start RTS group error: rejected RTS ID %03d, RTS Disabled", - SC_RTS_INDEX_TO_ID(RtsIndex)); + { /* Cannot use the RTS now */ + CFE_EVS_SendEvent( + SC_STARTRTSGRP_CMD_NOT_LDED_ERR_EID, CFE_EVS_EventType_ERROR, + "Start RTS group error: rejected RTS ID %03d, RTS Not Loaded or In Use, Status: %d", + SC_RTS_INDEX_TO_ID(RtsIndex), SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus); SC_OperData.HkPacket.RtsActiveErrCtr++; } /* end if */ } + else + { /* the RTS is disabled */ + CFE_EVS_SendEvent(SC_STARTRTSGRP_CMD_DISABLED_ERR_EID, CFE_EVS_EventType_ERROR, + "Start RTS group error: rejected RTS ID %03d, RTS Disabled", + SC_RTS_INDEX_TO_ID(RtsIndex)); - /* success */ - CFE_EVS_SendEvent(SC_STARTRTSGRP_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, - "Start RTS group: FirstID=%d, LastID=%d, Modified=%d", FirstId, LastId, (int)StartCount); - SC_OperData.HkPacket.CmdCtr++; - } - else - { /* error */ - CFE_EVS_SendEvent(SC_STARTRTSGRP_CMD_ERR_EID, CFE_EVS_EventType_ERROR, - "Start RTS group error: FirstID=%d, LastID=%d", FirstId, LastId); - SC_OperData.HkPacket.CmdErrCtr++; + SC_OperData.HkPacket.RtsActiveErrCtr++; + + } /* end if */ } + + /* success */ + CFE_EVS_SendEvent(SC_STARTRTSGRP_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, + "Start RTS group: FirstID=%d, LastID=%d, Modified=%d", FirstId, LastId, (int)StartCount); + SC_OperData.HkPacket.CmdCtr++; + } + else + { /* error */ + CFE_EVS_SendEvent(SC_STARTRTSGRP_CMD_ERR_EID, CFE_EVS_EventType_ERROR, + "Start RTS group error: FirstID=%d, LastID=%d", FirstId, LastId); + SC_OperData.HkPacket.CmdErrCtr++; } } #endif @@ -272,34 +259,31 @@ void SC_StopRtsCmd(const CFE_SB_Buffer_t *CmdPacket) uint16 RtsId; /* RTS ID */ uint16 RtsIndex; /* RTS array index */ - if (SC_VerifyCmdLength(&CmdPacket->Msg, sizeof(SC_RtsCmd_t))) - { - RtsId = ((SC_RtsCmd_t *)CmdPacket)->RtsId; + RtsId = ((SC_RtsCmd_t *)CmdPacket)->RtsId; - /* check the command parameter */ - if (RtsId <= SC_NUMBER_OF_RTS) - { - /* convert RTS ID to RTS array index */ - RtsIndex = SC_RTS_ID_TO_INDEX(RtsId); + /* check the command parameter */ + if (RtsId <= SC_NUMBER_OF_RTS) + { + /* convert RTS ID to RTS array index */ + RtsIndex = SC_RTS_ID_TO_INDEX(RtsId); - /* stop the rts by calling a generic routine */ - SC_KillRts(RtsIndex); + /* stop the rts by calling a generic routine */ + SC_KillRts(RtsIndex); - SC_OperData.HkPacket.CmdCtr++; + SC_OperData.HkPacket.CmdCtr++; - CFE_EVS_SendEvent(SC_STOPRTS_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, "RTS %03d Aborted", RtsId); - } - else - { /* the specified RTS is invalid */ + CFE_EVS_SendEvent(SC_STOPRTS_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, "RTS %03d Aborted", RtsId); + } + else + { /* the specified RTS is invalid */ - /* the rts id is invalid */ - CFE_EVS_SendEvent(SC_STOPRTS_CMD_ERR_EID, CFE_EVS_EventType_ERROR, "Stop RTS %03d rejected: Invalid RTS ID", - RtsId); + /* the rts id is invalid */ + CFE_EVS_SendEvent(SC_STOPRTS_CMD_ERR_EID, CFE_EVS_EventType_ERROR, "Stop RTS %03d rejected: Invalid RTS ID", + RtsId); - SC_OperData.HkPacket.CmdErrCtr++; + SC_OperData.HkPacket.CmdErrCtr++; - } /* end if */ - } + } /* end if */ } #if (SC_ENABLE_GROUP_COMMANDS == true) @@ -317,40 +301,37 @@ void SC_StopRtsGrpCmd(const CFE_SB_Buffer_t *CmdPacket) uint16 RtsIndex; int32 StopCount = 0; - if (SC_VerifyCmdLength(&CmdPacket->Msg, sizeof(SC_RtsGrpCmd_t))) + FirstId = ((SC_RtsGrpCmd_t *)CmdPacket)->FirstRtsId; + LastId = ((SC_RtsGrpCmd_t *)CmdPacket)->LastRtsId; + + /* make sure the specified group is valid */ + if ((FirstId > 0) && (LastId > 0) && (FirstId <= SC_NUMBER_OF_RTS) && (LastId <= SC_NUMBER_OF_RTS) && + (FirstId <= LastId)) { - FirstId = ((SC_RtsGrpCmd_t *)CmdPacket)->FirstRtsId; - LastId = ((SC_RtsGrpCmd_t *)CmdPacket)->LastRtsId; + /* convert RTS ID to RTS array index */ + FirstIndex = SC_RTS_ID_TO_INDEX(FirstId); + LastIndex = SC_RTS_ID_TO_INDEX(LastId); - /* make sure the specified group is valid */ - if ((FirstId > 0) && (LastId > 0) && (FirstId <= SC_NUMBER_OF_RTS) && (LastId <= SC_NUMBER_OF_RTS) && - (FirstId <= LastId)) + for (RtsIndex = FirstIndex; RtsIndex <= LastIndex; RtsIndex++) { - /* convert RTS ID to RTS array index */ - FirstIndex = SC_RTS_ID_TO_INDEX(FirstId); - LastIndex = SC_RTS_ID_TO_INDEX(LastId); - - for (RtsIndex = FirstIndex; RtsIndex <= LastIndex; RtsIndex++) + /* count the entries that were actually stopped */ + if (SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus == SC_EXECUTING) { - /* count the entries that were actually stopped */ - if (SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus == SC_EXECUTING) - { - SC_KillRts(RtsIndex); - StopCount++; - } + SC_KillRts(RtsIndex); + StopCount++; } - - /* success */ - CFE_EVS_SendEvent(SC_STOPRTSGRP_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, - "Stop RTS group: FirstID=%d, LastID=%d, Modified=%d", FirstId, LastId, (int)StopCount); - SC_OperData.HkPacket.CmdCtr++; - } - else - { /* error */ - CFE_EVS_SendEvent(SC_STOPRTSGRP_CMD_ERR_EID, CFE_EVS_EventType_ERROR, - "Stop RTS group error: FirstID=%d, LastID=%d", FirstId, LastId); - SC_OperData.HkPacket.CmdErrCtr++; } + + /* success */ + CFE_EVS_SendEvent(SC_STOPRTSGRP_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, + "Stop RTS group: FirstID=%d, LastID=%d, Modified=%d", FirstId, LastId, (int)StopCount); + SC_OperData.HkPacket.CmdCtr++; + } + else + { /* error */ + CFE_EVS_SendEvent(SC_STOPRTSGRP_CMD_ERR_EID, CFE_EVS_EventType_ERROR, + "Stop RTS group error: FirstID=%d, LastID=%d", FirstId, LastId); + SC_OperData.HkPacket.CmdErrCtr++; } } #endif @@ -365,33 +346,30 @@ void SC_DisableRtsCmd(const CFE_SB_Buffer_t *CmdPacket) uint16 RtsId; /* RTS ID */ uint16 RtsIndex; /* RTS array index */ - if (SC_VerifyCmdLength(&CmdPacket->Msg, sizeof(SC_RtsCmd_t))) - { - RtsId = ((SC_RtsCmd_t *)CmdPacket)->RtsId; - - /* make sure tha specified rts is valid */ - if (RtsId <= SC_NUMBER_OF_RTS) - { - /* convert RTS ID to RTS array index */ - RtsIndex = SC_RTS_ID_TO_INDEX(RtsId); + RtsId = ((SC_RtsCmd_t *)CmdPacket)->RtsId; - /* disable the RTS */ - SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag = true; + /* make sure tha specified rts is valid */ + if (RtsId <= SC_NUMBER_OF_RTS) + { + /* convert RTS ID to RTS array index */ + RtsIndex = SC_RTS_ID_TO_INDEX(RtsId); - /* update the command status */ - SC_OperData.HkPacket.CmdCtr++; + /* disable the RTS */ + SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag = true; - CFE_EVS_SendEvent(SC_DISABLE_RTS_DEB_EID, CFE_EVS_EventType_DEBUG, "Disabled RTS %03d", RtsId); - } - else - { /* it is not a valid RTS id */ - CFE_EVS_SendEvent(SC_DISRTS_CMD_ERR_EID, CFE_EVS_EventType_ERROR, - "Disable RTS %03d Rejected: Invalid RTS ID", RtsId); + /* update the command status */ + SC_OperData.HkPacket.CmdCtr++; - /* update the command error status */ - SC_OperData.HkPacket.CmdErrCtr++; - } /* end if */ + CFE_EVS_SendEvent(SC_DISABLE_RTS_DEB_EID, CFE_EVS_EventType_DEBUG, "Disabled RTS %03d", RtsId); } + else + { /* it is not a valid RTS id */ + CFE_EVS_SendEvent(SC_DISRTS_CMD_ERR_EID, CFE_EVS_EventType_ERROR, + "Disable RTS %03d Rejected: Invalid RTS ID", RtsId); + + /* update the command error status */ + SC_OperData.HkPacket.CmdErrCtr++; + } /* end if */ } #if (SC_ENABLE_GROUP_COMMANDS == true) @@ -409,41 +387,38 @@ void SC_DisableRtsGrpCmd(const CFE_SB_Buffer_t *CmdPacket) uint16 RtsIndex; int32 DisableCount = 0; - if (SC_VerifyCmdLength(&CmdPacket->Msg, sizeof(SC_RtsGrpCmd_t))) + FirstId = ((SC_RtsGrpCmd_t *)CmdPacket)->FirstRtsId; + LastId = ((SC_RtsGrpCmd_t *)CmdPacket)->LastRtsId; + + /* make sure the specified group is valid */ + if ((FirstId > 0) && (LastId > 0) && (FirstId <= SC_NUMBER_OF_RTS) && (LastId <= SC_NUMBER_OF_RTS) && + (FirstId <= LastId)) { - FirstId = ((SC_RtsGrpCmd_t *)CmdPacket)->FirstRtsId; - LastId = ((SC_RtsGrpCmd_t *)CmdPacket)->LastRtsId; + /* convert RTS ID to RTS array index */ + FirstIndex = SC_RTS_ID_TO_INDEX(FirstId); + LastIndex = SC_RTS_ID_TO_INDEX(LastId); - /* make sure the specified group is valid */ - if ((FirstId > 0) && (LastId > 0) && (FirstId <= SC_NUMBER_OF_RTS) && (LastId <= SC_NUMBER_OF_RTS) && - (FirstId <= LastId)) + for (RtsIndex = FirstIndex; RtsIndex <= LastIndex; RtsIndex++) { - /* convert RTS ID to RTS array index */ - FirstIndex = SC_RTS_ID_TO_INDEX(FirstId); - LastIndex = SC_RTS_ID_TO_INDEX(LastId); - - for (RtsIndex = FirstIndex; RtsIndex <= LastIndex; RtsIndex++) + /* count the entries that were actually disabled */ + if (SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag == false) { - /* count the entries that were actually disabled */ - if (SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag == false) - { - DisableCount++; - SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag = true; - } + DisableCount++; + SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag = true; } - - /* success */ - CFE_EVS_SendEvent(SC_DISRTSGRP_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, - "Disable RTS group: FirstID=%d, LastID=%d, Modified=%d", FirstId, LastId, - (int)DisableCount); - SC_OperData.HkPacket.CmdCtr++; - } - else - { /* error */ - CFE_EVS_SendEvent(SC_DISRTSGRP_CMD_ERR_EID, CFE_EVS_EventType_ERROR, - "Disable RTS group error: FirstID=%d, LastID=%d", FirstId, LastId); - SC_OperData.HkPacket.CmdErrCtr++; } + + /* success */ + CFE_EVS_SendEvent(SC_DISRTSGRP_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, + "Disable RTS group: FirstID=%d, LastID=%d, Modified=%d", FirstId, LastId, + (int)DisableCount); + SC_OperData.HkPacket.CmdCtr++; + } + else + { /* error */ + CFE_EVS_SendEvent(SC_DISRTSGRP_CMD_ERR_EID, CFE_EVS_EventType_ERROR, + "Disable RTS group error: FirstID=%d, LastID=%d", FirstId, LastId); + SC_OperData.HkPacket.CmdErrCtr++; } } #endif @@ -458,34 +433,31 @@ void SC_EnableRtsCmd(const CFE_SB_Buffer_t *CmdPacket) uint16 RtsId; /* RTS ID */ uint16 RtsIndex; /* RTS array index */ - if (SC_VerifyCmdLength(&CmdPacket->Msg, sizeof(SC_RtsCmd_t))) - { - RtsId = ((SC_RtsCmd_t *)CmdPacket)->RtsId; + RtsId = ((SC_RtsCmd_t *)CmdPacket)->RtsId; - /* make sure the specified rts is valid */ - if ((RtsId > 0) && (RtsId <= SC_NUMBER_OF_RTS)) - { - /* convert RTS ID to RTS array index */ - RtsIndex = SC_RTS_ID_TO_INDEX(RtsId); + /* make sure the specified rts is valid */ + if ((RtsId > 0) && (RtsId <= SC_NUMBER_OF_RTS)) + { + /* convert RTS ID to RTS array index */ + RtsIndex = SC_RTS_ID_TO_INDEX(RtsId); - /* re-enable the RTS */ - SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag = false; + /* re-enable the RTS */ + SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag = false; - /* update the command status */ - SC_OperData.HkPacket.CmdCtr++; + /* update the command status */ + SC_OperData.HkPacket.CmdCtr++; - CFE_EVS_SendEvent(SC_ENABLE_RTS_DEB_EID, CFE_EVS_EventType_DEBUG, "Enabled RTS %03d", RtsId); - } - else - { /* it is not a valid RTS id */ - CFE_EVS_SendEvent(SC_ENARTS_CMD_ERR_EID, CFE_EVS_EventType_ERROR, - "Enable RTS %03d Rejected: Invalid RTS ID", RtsId); + CFE_EVS_SendEvent(SC_ENABLE_RTS_DEB_EID, CFE_EVS_EventType_DEBUG, "Enabled RTS %03d", RtsId); + } + else + { /* it is not a valid RTS id */ + CFE_EVS_SendEvent(SC_ENARTS_CMD_ERR_EID, CFE_EVS_EventType_ERROR, + "Enable RTS %03d Rejected: Invalid RTS ID", RtsId); - /* update the command error status */ - SC_OperData.HkPacket.CmdErrCtr++; + /* update the command error status */ + SC_OperData.HkPacket.CmdErrCtr++; - } /* end if */ - } + } /* end if */ } #if (SC_ENABLE_GROUP_COMMANDS == true) @@ -503,41 +475,38 @@ void SC_EnableRtsGrpCmd(const CFE_SB_Buffer_t *CmdPacket) uint16 RtsIndex; int32 EnableCount = 0; - if (SC_VerifyCmdLength(&CmdPacket->Msg, sizeof(SC_RtsGrpCmd_t))) + FirstId = ((SC_RtsGrpCmd_t *)CmdPacket)->FirstRtsId; + LastId = ((SC_RtsGrpCmd_t *)CmdPacket)->LastRtsId; + + /* make sure the specified group is valid */ + if ((FirstId > 0) && (LastId > 0) && (FirstId <= SC_NUMBER_OF_RTS) && (LastId <= SC_NUMBER_OF_RTS) && + (FirstId <= LastId)) { - FirstId = ((SC_RtsGrpCmd_t *)CmdPacket)->FirstRtsId; - LastId = ((SC_RtsGrpCmd_t *)CmdPacket)->LastRtsId; + /* convert RTS ID to RTS array index */ + FirstIndex = SC_RTS_ID_TO_INDEX(FirstId); + LastIndex = SC_RTS_ID_TO_INDEX(LastId); - /* make sure the specified group is valid */ - if ((FirstId > 0) && (LastId > 0) && (FirstId <= SC_NUMBER_OF_RTS) && (LastId <= SC_NUMBER_OF_RTS) && - (FirstId <= LastId)) + for (RtsIndex = FirstIndex; RtsIndex <= LastIndex; RtsIndex++) { - /* convert RTS ID to RTS array index */ - FirstIndex = SC_RTS_ID_TO_INDEX(FirstId); - LastIndex = SC_RTS_ID_TO_INDEX(LastId); - - for (RtsIndex = FirstIndex; RtsIndex <= LastIndex; RtsIndex++) + /* count the entries that were actually enabled */ + if (SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag == true) { - /* count the entries that were actually enabled */ - if (SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag == true) - { - EnableCount++; - SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag = false; - } + EnableCount++; + SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag = false; } - - /* success */ - CFE_EVS_SendEvent(SC_ENARTSGRP_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, - "Enable RTS group: FirstID=%d, LastID=%d, Modified=%d", FirstId, LastId, - (int)EnableCount); - SC_OperData.HkPacket.CmdCtr++; - } - else - { /* error */ - CFE_EVS_SendEvent(SC_ENARTSGRP_CMD_ERR_EID, CFE_EVS_EventType_ERROR, - "Enable RTS group error: FirstID=%d, LastID=%d", FirstId, LastId); - SC_OperData.HkPacket.CmdErrCtr++; } + + /* success */ + CFE_EVS_SendEvent(SC_ENARTSGRP_CMD_INF_EID, CFE_EVS_EventType_INFORMATION, + "Enable RTS group: FirstID=%d, LastID=%d, Modified=%d", FirstId, LastId, + (int)EnableCount); + SC_OperData.HkPacket.CmdCtr++; + } + else + { /* error */ + CFE_EVS_SendEvent(SC_ENARTSGRP_CMD_ERR_EID, CFE_EVS_EventType_ERROR, + "Enable RTS group error: FirstID=%d, LastID=%d", FirstId, LastId); + SC_OperData.HkPacket.CmdErrCtr++; } } #endif diff --git a/unit-test/sc_atsrq_tests.c b/unit-test/sc_atsrq_tests.c index 83017ed..89db453 100644 --- a/unit-test/sc_atsrq_tests.c +++ b/unit-test/sc_atsrq_tests.c @@ -71,8 +71,6 @@ void SC_StartAtsCmd_Test_NominalA(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.StartAtsCmd.AtsId = 1; SC_OperData.AtsInfoTblAddr[0].NumberOfCommands = 1; SC_OperData.AtsCtrlBlckAddr->AtpState = SC_IDLE; @@ -95,8 +93,6 @@ void SC_StartAtsCmd_Test_NominalB(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.StartAtsCmd.AtsId = 2; SC_OperData.AtsInfoTblAddr[1].NumberOfCommands = 1; SC_OperData.AtsCtrlBlckAddr->AtpState = SC_IDLE; @@ -121,7 +117,6 @@ void SC_StartAtsCmd_Test_CouldNotStart(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(SC_CompareAbsTime), 1, true); UT_CmdBuf.StartAtsCmd.AtsId = 1; @@ -149,8 +144,6 @@ void SC_StartAtsCmd_Test_NoCommandsA(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.StartAtsCmd.AtsId = 1; SC_OperData.AtsInfoTblAddr[0].NumberOfCommands = 0; SC_OperData.AtsCtrlBlckAddr->AtpState = SC_IDLE; @@ -173,8 +166,6 @@ void SC_StartAtsCmd_Test_NoCommandsB(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.StartAtsCmd.AtsId = 2; SC_OperData.AtsInfoTblAddr[1].NumberOfCommands = 0; SC_OperData.AtsCtrlBlckAddr->AtpState = SC_IDLE; @@ -197,8 +188,6 @@ void SC_StartAtsCmd_Test_InUse(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.StartAtsCmd.AtsId = 1; SC_OperData.AtsCtrlBlckAddr->AtpState = SC_EXECUTING; @@ -220,8 +209,6 @@ void SC_StartAtsCmd_Test_InvalidAtsId(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.StartAtsCmd.AtsId = 99; SC_OperData.AtsCtrlBlckAddr->AtpState = SC_EXECUTING; @@ -243,8 +230,6 @@ void SC_StartAtsCmd_Test_InvalidAtsIdZero(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.StartAtsCmd.AtsId = 0; SC_OperData.AtsCtrlBlckAddr->AtpState = SC_EXECUTING; @@ -258,23 +243,6 @@ void SC_StartAtsCmd_Test_InvalidAtsIdZero(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void SC_StartAtsCmd_Test_InvalidCmdLength(void) -{ - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = SC_START_ATS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - UtAssert_VOIDCALL(SC_StartAtsCmd(&UT_CmdBuf.Buf)); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void SC_StopAtsCmd_Test_NominalA(void) { CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); @@ -283,8 +251,6 @@ void SC_StopAtsCmd_Test_NominalA(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - SC_OperData.AtsCtrlBlckAddr->AtsNumber = SC_ATSA; /* Execute the function being tested */ @@ -305,8 +271,6 @@ void SC_StopAtsCmd_Test_NominalB(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - SC_OperData.AtsCtrlBlckAddr->AtsNumber = SC_ATSB; /* Execute the function being tested */ @@ -327,8 +291,6 @@ void SC_StopAtsCmd_Test_NoRunningAts(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - SC_OperData.AtsCtrlBlckAddr->AtsNumber = 99; /* Execute the function being tested */ @@ -341,25 +303,6 @@ void SC_StopAtsCmd_Test_NoRunningAts(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void SC_StopAtsCmd_Test_InvalidCmdLength(void) -{ - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = SC_START_ATS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); - - SC_OperData.AtsCtrlBlckAddr->AtsNumber = 99; - - /* Execute the function being tested */ - UtAssert_VOIDCALL(SC_StopAtsCmd(&UT_CmdBuf.Buf)); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void SC_BeginAts_Test_Nominal(void) { uint16 AtsIndex = 0; @@ -448,8 +391,6 @@ void SC_GroundSwitchCmd_Test_Nominal(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - SC_OperData.AtsCtrlBlckAddr->AtsNumber = 1; SC_OperData.AtsCtrlBlckAddr->AtpState = SC_EXECUTING; SC_OperData.AtsInfoTblAddr[1].NumberOfCommands = 1; @@ -474,8 +415,6 @@ void SC_GroundSwitchCmd_Test_DestinationAtsNotLoaded(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - SC_OperData.AtsCtrlBlckAddr->AtsNumber = 1; SC_OperData.AtsCtrlBlckAddr->AtpState = SC_EXECUTING; SC_OperData.AtsInfoTblAddr[1].NumberOfCommands = 0; @@ -498,8 +437,6 @@ void SC_GroundSwitchCmd_Test_AtpIdle(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - SC_OperData.AtsCtrlBlckAddr->AtsNumber = 1; SC_OperData.AtsCtrlBlckAddr->AtpState = 99; @@ -515,21 +452,6 @@ void SC_GroundSwitchCmd_Test_AtpIdle(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void SC_GroundSwitchCmd_Test_InvalidCmdLength(void) -{ - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_1HZ_WAKEUP_MID); - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - SC_GroundSwitchCmd(&UT_CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void SC_ServiceSwitchPend_Test_NominalA(void) { UT_SetDeferredRetcode(UT_KEY(SC_CompareAbsTime), 1, true); @@ -782,7 +704,6 @@ void SC_JumpAtsCmd_Test_SkipOneCmd(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_JumpAtsCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(SC_CompareAbsTime), 1, true); /* Set to satisfy first if-statement, while not affecting later calls to CFE_TIME_Compare */ @@ -826,7 +747,6 @@ void SC_JumpAtsCmd_Test_AllCommandsSkipped(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_JumpAtsCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(SC_CompareAbsTime), 1, true); /* Set to satisfy first if-statement, while not affecting later calls to CFE_TIME_Compare */ @@ -856,8 +776,6 @@ void SC_JumpAtsCmd_Test_NoRunningAts(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_JumpAtsCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - SC_OperData.AtsCtrlBlckAddr->AtpState = SC_IDLE; /* Execute the function being tested */ @@ -879,7 +797,6 @@ void SC_JumpAtsCmd_Test_AtsNotLoaded(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_JumpAtsCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(SC_CompareAbsTime), 1, true); /* Set to satisfy first if-statement, while not affecting later calls to CFE_TIME_Compare */ @@ -910,25 +827,6 @@ void SC_JumpAtsCmd_Test_AtsNotLoaded(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); } -void SC_JumpAtsCmd_Test_InvalidCmdLength(void) -{ - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = SC_JUMP_ATS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_JumpAtsCmd_t), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); - - SC_OperData.AtsCtrlBlckAddr->AtpState = SC_IDLE; - - /* Execute the function being tested */ - UtAssert_VOIDCALL(SC_JumpAtsCmd(&UT_CmdBuf.Buf)); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void ContinueAtsOnFailureCmd_Test_Nominal(void) { CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); @@ -937,8 +835,6 @@ void ContinueAtsOnFailureCmd_Test_Nominal(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_SetContinueAtsOnFailureCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.SetContinueAtsOnFailureCmd.ContinueState = true; /* Execute the function being tested */ @@ -961,8 +857,6 @@ void ContinueAtsOnFailureCmd_Test_FalseState(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_SetContinueAtsOnFailureCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.SetContinueAtsOnFailureCmd.ContinueState = false; /* Execute the function being tested */ @@ -985,8 +879,6 @@ void ContinueAtsOnFailureCmd_Test_InvalidState(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_SetContinueAtsOnFailureCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.SetContinueAtsOnFailureCmd.ContinueState = 99; /* Execute the function being tested */ @@ -999,23 +891,6 @@ void ContinueAtsOnFailureCmd_Test_InvalidState(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void ContinueAtsOnFailureCmd_Test_InvalidCmdLength(void) -{ - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = SC_CONTINUE_ATS_ON_FAILURE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_SetContinueAtsOnFailureCmd_t), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - UtAssert_VOIDCALL(SC_ContinueAtsOnFailureCmd(&UT_CmdBuf.Buf)); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void SC_AppendAtsCmd_Test_Nominal(void) { SC_AtsEntryHeader_t *Entry; @@ -1026,8 +901,6 @@ void SC_AppendAtsCmd_Test_Nominal(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_AppendAtsCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - Entry = (SC_AtsEntryHeader_t *)&SC_OperData.AtsTblAddr[AtsIndex][0]; Entry->CmdNumber = 1; @@ -1054,8 +927,6 @@ void SC_AppendAtsCmd_Test_InvalidAtsId(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_AppendAtsCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.AppendAtsCmd.AtsId = 99; SC_OperData.HkPacket.AppendEntryCount = 1; @@ -1077,8 +948,6 @@ void SC_AppendAtsCmd_Test_InvalidAtsIdZero(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_AppendAtsCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.AppendAtsCmd.AtsId = 0; SC_OperData.HkPacket.AppendEntryCount = 1; @@ -1101,8 +970,6 @@ void SC_AppendAtsCmd_Test_AtsTableEmpty(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_AppendAtsCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.AppendAtsCmd.AtsId = 1; SC_OperData.HkPacket.AppendEntryCount = 1; SC_OperData.AtsInfoTblAddr[AtsIndex].NumberOfCommands = 0; @@ -1126,8 +993,6 @@ void SC_AppendAtsCmd_Test_AppendTableEmpty(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_AppendAtsCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.AppendAtsCmd.AtsId = 1; SC_OperData.HkPacket.AppendEntryCount = 0; SC_OperData.AtsInfoTblAddr[AtsIndex].NumberOfCommands = 1; @@ -1151,8 +1016,6 @@ void SC_AppendAtsCmd_Test_NoRoomForAppendInAts(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_AppendAtsCmd_t), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - UT_CmdBuf.AppendAtsCmd.AtsId = 1; SC_OperData.HkPacket.AppendEntryCount = 1; SC_OperData.AtsInfoTblAddr[AtsIndex].NumberOfCommands = 1; @@ -1169,23 +1032,6 @@ void SC_AppendAtsCmd_Test_NoRoomForAppendInAts(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void SC_AppendAtsCmd_Test_InvalidCmdLength(void) -{ - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = SC_APPEND_ATS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(SC_AppendAtsCmd_t), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - SC_AppendAtsCmd(&UT_CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void UtTest_Setup(void) { UtTest_Add(SC_StartAtsCmd_Test_NominalA, SC_Test_Setup, SC_Test_TearDown, "SC_StartAtsCmd_Test_NominalA"); @@ -1197,13 +1043,9 @@ void UtTest_Setup(void) UtTest_Add(SC_StartAtsCmd_Test_InvalidAtsId, SC_Test_Setup, SC_Test_TearDown, "SC_StartAtsCmd_Test_InvalidAtsId"); UtTest_Add(SC_StartAtsCmd_Test_InvalidAtsIdZero, SC_Test_Setup, SC_Test_TearDown, "SC_StartAtsCmd_Test_InvalidAtsIdZero"); - UtTest_Add(SC_StartAtsCmd_Test_InvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, - "SC_StartAtsCmd_Test_InvalidCmdLength"); UtTest_Add(SC_StopAtsCmd_Test_NominalA, SC_Test_Setup, SC_Test_TearDown, "SC_StopAtsCmd_Test_NominalA"); UtTest_Add(SC_StopAtsCmd_Test_NominalB, SC_Test_Setup, SC_Test_TearDown, "SC_StopAtsCmd_Test_NominalB"); UtTest_Add(SC_StopAtsCmd_Test_NoRunningAts, SC_Test_Setup, SC_Test_TearDown, "SC_StopAtsCmd_Test_NoRunningAts"); - UtTest_Add(SC_StopAtsCmd_Test_InvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, - "SC_StopAtsCmd_Test_InvalidCmdLength"); UtTest_Add(SC_BeginAts_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_BeginAts_Test_Nominal"); UtTest_Add(SC_BeginAts_Test_AllCommandsSkipped, SC_Test_Setup, SC_Test_TearDown, "SC_BeginAts_Test_AllCommandsSkipped"); @@ -1213,8 +1055,6 @@ void UtTest_Setup(void) UtTest_Add(SC_GroundSwitchCmd_Test_DestinationAtsNotLoaded, SC_Test_Setup, SC_Test_TearDown, "SC_GroundSwitchCmd_Test_DestinationAtsNotLoaded"); UtTest_Add(SC_GroundSwitchCmd_Test_AtpIdle, SC_Test_Setup, SC_Test_TearDown, "SC_GroundSwitchCmd_Test_AtpIdle"); - UtTest_Add(SC_GroundSwitchCmd_Test_InvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, - "SC_GroundSwitchCmd_Test_InvalidCmdLength"); UtTest_Add(SC_ServiceSwitchPend_Test_NominalA, SC_Test_Setup, SC_Test_TearDown, "SC_ServiceSwitchPend_Test_NominalA"); UtTest_Add(SC_ServiceSwitchPend_Test_NominalB, SC_Test_Setup, SC_Test_TearDown, @@ -1237,16 +1077,12 @@ void UtTest_Setup(void) "SC_JumpAtsCmd_Test_AllCommandsSkipped"); UtTest_Add(SC_JumpAtsCmd_Test_NoRunningAts, SC_Test_Setup, SC_Test_TearDown, "SC_JumpAtsCmd_Test_NoRunningAts"); UtTest_Add(SC_JumpAtsCmd_Test_AtsNotLoaded, SC_Test_Setup, SC_Test_TearDown, "SC_JumpAtsCmd_Test_AtsNotLoaded"); - UtTest_Add(SC_JumpAtsCmd_Test_InvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, - "SC_JumpAtsCmd_Test_InvalidCmdLength"); UtTest_Add(ContinueAtsOnFailureCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "ContinueAtsOnFailureCmd_Test_Nominal"); UtTest_Add(ContinueAtsOnFailureCmd_Test_FalseState, SC_Test_Setup, SC_Test_TearDown, "ContinueAtsOnFailureCmd_Test_FalseState"); UtTest_Add(ContinueAtsOnFailureCmd_Test_InvalidState, SC_Test_Setup, SC_Test_TearDown, "ContinueAtsOnFailureCmd_Test_InvalidState"); - UtTest_Add(ContinueAtsOnFailureCmd_Test_InvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, - "ContinueAtsOnFailureCmd_Test_InvalidCmdLength"); UtTest_Add(SC_AppendAtsCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_AppendAtsCmd_Test_Nominal"); UtTest_Add(SC_AppendAtsCmd_Test_InvalidAtsId, SC_Test_Setup, SC_Test_TearDown, "SC_AppendAtsCmd_Test_InvalidAtsId"); UtTest_Add(SC_AppendAtsCmd_Test_InvalidAtsIdZero, SC_Test_Setup, SC_Test_TearDown, @@ -1257,6 +1093,4 @@ void UtTest_Setup(void) "SC_AppendAtsCmd_Test_AppendTableEmpty"); UtTest_Add(SC_AppendAtsCmd_Test_NoRoomForAppendInAts, SC_Test_Setup, SC_Test_TearDown, "SC_AppendAtsCmd_Test_NoRoomForAppendInAts"); - UtTest_Add(SC_AppendAtsCmd_Test_InvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, - "SC_AppendAtsCmd_Test_InvalidCmdLength"); } diff --git a/unit-test/sc_cmds_tests.c b/unit-test/sc_cmds_tests.c index d9a84ef..464af34 100644 --- a/unit-test/sc_cmds_tests.c +++ b/unit-test/sc_cmds_tests.c @@ -1349,6 +1349,7 @@ void SC_ProcessCommand_Test_StartAts(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); UT_CmdBuf.StartAtsCmd.AtsId = 1; @@ -1373,6 +1374,7 @@ void SC_ProcessCommand_Test_StopAts(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -1395,6 +1397,7 @@ void SC_ProcessCommand_Test_StartRts(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -1417,6 +1420,7 @@ void SC_ProcessCommand_Test_StopRts(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -1439,6 +1443,7 @@ void SC_ProcessCommand_Test_DisableRts(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -1461,6 +1466,7 @@ void SC_ProcessCommand_Test_EnableRts(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -1483,6 +1489,7 @@ void SC_ProcessCommand_Test_SwitchAts(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -1505,6 +1512,7 @@ void SC_ProcessCommand_Test_JumpAts(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -1527,6 +1535,7 @@ void SC_ProcessCommand_Test_ContinueAtsOnFailure(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -1549,6 +1558,7 @@ void SC_ProcessCommand_Test_AppendAts(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -1572,6 +1582,7 @@ void SC_ProcessCommand_Test_TableManageAtsTableNominal(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); Entry = (SC_AtsEntryHeader_t *)&SC_OperData.AtsTblAddr[0][0]; Entry->CmdNumber = 0; @@ -1602,6 +1613,7 @@ void SC_ProcessCommand_Test_TableManageAtsTableGetAddressError(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); UT_CmdBuf.NotifyCmd.Payload.Parameter = SC_TBL_ID_ATS_0; @@ -1632,6 +1644,7 @@ void SC_ProcessCommand_Test_TableManageAtsTableID(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); Entry = (SC_AtsEntryHeader_t *)&SC_OperData.AtsTblAddr[0][0]; Entry->CmdNumber = 0; @@ -1676,6 +1689,7 @@ void SC_ProcessCommand_Test_TableManageAtsTableGetAddressNeverLoaded(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); Entry = (SC_AtsEntryHeader_t *)&SC_OperData.AtsTblAddr[0][0]; Entry->CmdNumber = 0; @@ -1706,6 +1720,7 @@ void SC_ProcessCommand_Test_TableManageAtsTableGetAddressSuccess(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); Entry = (SC_AtsEntryHeader_t *)&SC_OperData.AtsTblAddr[0][0]; Entry->CmdNumber = 0; @@ -1736,6 +1751,7 @@ void SC_ProcessCommand_Test_TableManageAppendTableNominal(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); Entry = (SC_AtsEntryHeader_t *)&SC_OperData.AppendTblAddr; Entry->CmdNumber = 0; @@ -1766,6 +1782,7 @@ void SC_ProcessCommand_Test_TableManageAppendTableGetAddressError(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); UT_CmdBuf.NotifyCmd.Payload.Parameter = SC_TBL_ID_APPEND; @@ -1796,6 +1813,7 @@ void SC_ProcessCommand_Test_TableManageAppendTableGetAddressNeverLoaded(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); Entry = (SC_AtsEntryHeader_t *)&SC_OperData.AppendTblAddr; Entry->CmdNumber = 0; @@ -1826,6 +1844,7 @@ void SC_ProcessCommand_Test_TableManageAppendTableGetAddressSuccess(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); Entry = (SC_AtsEntryHeader_t *)&SC_OperData.AppendTblAddr; Entry->CmdNumber = 0; @@ -1855,6 +1874,7 @@ void SC_ProcessCommand_Test_TableManageRtsTableNominal(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); UT_CmdBuf.NotifyCmd.Payload.Parameter = SC_TBL_ID_RTS_0; @@ -1882,6 +1902,7 @@ void SC_ProcessCommand_Test_TableManageRtsTableGetAddressError(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); UT_CmdBuf.NotifyCmd.Payload.Parameter = SC_TBL_ID_RTS_0; @@ -1911,6 +1932,7 @@ void SC_ProcessCommand_Test_TableManageRtsTableID(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); /* test TableID >= SC_TBL_ID_RTS_0 */ UT_CmdBuf.NotifyCmd.Payload.Parameter = 0; @@ -1951,6 +1973,7 @@ void SC_ProcessCommand_Test_TableManageRtsTableGetAddressNeverLoaded(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); UT_CmdBuf.NotifyCmd.Payload.Parameter = SC_TBL_ID_RTS_0; @@ -1977,6 +2000,7 @@ void SC_ProcessCommand_Test_TableManageRtsTableGetAddressSuccess(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); UT_CmdBuf.NotifyCmd.Payload.Parameter = SC_TBL_ID_RTS_0; @@ -2003,6 +2027,7 @@ void SC_ProcessCommand_Test_TableManageRtsInfo(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); UT_CmdBuf.NotifyCmd.Payload.Parameter = SC_TBL_ID_RTS_INFO; @@ -2027,6 +2052,7 @@ void SC_ProcessCommand_Test_TableManageRtpCtrl(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); UT_CmdBuf.NotifyCmd.Payload.Parameter = SC_TBL_ID_RTP_CTRL; @@ -2051,6 +2077,7 @@ void SC_ProcessCommand_Test_TableManageAtsInfo(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); UT_CmdBuf.NotifyCmd.Payload.Parameter = SC_TBL_ID_ATS_INFO; @@ -2075,6 +2102,7 @@ void SC_ProcessCommand_Test_TableManageAtpCtrl(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); UT_CmdBuf.NotifyCmd.Payload.Parameter = SC_TBL_ID_ATP_CTRL; @@ -2099,6 +2127,7 @@ void SC_ProcessCommand_Test_TableManageAtsCmdStatus(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); UT_CmdBuf.NotifyCmd.Payload.Parameter = SC_TBL_ID_ATS_CMD_0; @@ -2123,6 +2152,7 @@ void SC_ProcessCommand_Test_TableManageInvalidTableID(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); UT_CmdBuf.NotifyCmd.Payload.Parameter = 999; @@ -2149,6 +2179,7 @@ void SC_ProcessCommand_Test_StartRtsGrp(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -2171,6 +2202,7 @@ void SC_ProcessCommand_Test_StopRtsGrp(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -2193,6 +2225,7 @@ void SC_ProcessCommand_Test_DisableRtsGrp(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -2215,6 +2248,7 @@ void SC_ProcessCommand_Test_EnableRtsGrp(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDefaultReturnValue(UT_KEY(SC_VerifyCmdLength), true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_ProcessCommand(&UT_CmdBuf.Buf)); @@ -2222,6 +2256,291 @@ void SC_ProcessCommand_Test_EnableRtsGrp(void) /* This function is already verified to work correctly in another file, so no verifications here. */ } +void SC_ProcessCommand_Test_StartAtsInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_START_ATS_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_StopAtsInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_STOP_ATS_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_StartRtsInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_START_RTS_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_StopRtsInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_STOP_RTS_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_DisableRtsInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_DISABLE_RTS_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_EnableRtsInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_ENABLE_RTS_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_GroundSwitchInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_SWITCH_ATS_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_JumpAtsInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_JUMP_ATS_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_ContinueAtsOnFailureInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_CONTINUE_ATS_ON_FAILURE_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_AppendAtsInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_APPEND_ATS_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_TableManageInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_MANAGE_TABLE_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_StartRtsGrpInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_START_RTS_GRP_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_StopRtsGrpInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_STOP_RTS_GRP_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_DisableRtsGrpInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_DISABLE_RTS_GRP_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + +void SC_ProcessCommand_Test_EnableRtsGrpInvalidCmdLength(void) +{ + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(SC_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = SC_ENABLE_RTS_GRP_CC; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + SC_ProcessCommand(&UT_CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(SC_OperData.HkPacket.CmdCtr == 0, "SC_OperData.HkPacket.CmdCtr == 0"); + UtAssert_True(SC_OperData.HkPacket.CmdErrCtr == 0, "SC_OperData.HkPacket.CmdErrCtr == 0"); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + void SC_ProcessCommand_Test_InvalidCmdError(void) { /** @@ -2383,6 +2702,36 @@ void UtTest_Setup(void) "SC_ProcessCommand_Test_DisableRtsGrp"); UtTest_Add(SC_ProcessCommand_Test_EnableRtsGrp, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessCommand_Test_EnableRtsGrp"); + UtTest_Add(SC_ProcessCommand_Test_StartAtsInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_StartAtsInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_StopAtsInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_StopAtsInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_StartRtsInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_StartRtsInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_StopRtsInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_StopRtsInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_DisableRtsInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_DisableRtsInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_EnableRtsInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_EnableRtsInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_GroundSwitchInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_GroundSwitchInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_JumpAtsInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_JumpAtsInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_ContinueAtsOnFailureInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_ContinueAtsOnFailureInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_AppendAtsInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_AppendAtsInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_TableManageInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_TableManageInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_StartRtsGrpInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_StartRtsGrpInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_StopRtsGrpInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_StopRtsGrpInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_DisableRtsGrpInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_DisableRtsGrpInvalidCmdLength"); + UtTest_Add(SC_ProcessCommand_Test_EnableRtsGrpInvalidCmdLength, SC_Test_Setup, SC_Test_TearDown, + "SC_ProcessCommand_Test_EnableRtsGrpInvalidCmdLength"); UtTest_Add(SC_ProcessCommand_Test_InvalidCmdError, SC_Test_Setup, SC_Test_TearDown, "SC_ProcessCommand_Test_InvalidCmdError"); } diff --git a/unit-test/sc_rtsrq_tests.c b/unit-test/sc_rtsrq_tests.c index 7074343..3353a09 100644 --- a/unit-test/sc_rtsrq_tests.c +++ b/unit-test/sc_rtsrq_tests.c @@ -63,7 +63,6 @@ void SC_StartRtsCmd_Test_Nominal(void) MsgSize = sizeof(SC_RtsCmd_t); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsCmd(&UT_CmdBuf.Buf)); @@ -108,7 +107,6 @@ void SC_StartRtsCmd_Test_StartRtsNoEvents(void) MsgSize = sizeof(SC_RtsCmd_t); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsCmd(&UT_CmdBuf.Buf)); @@ -159,7 +157,6 @@ void SC_StartRtsCmd_Test_InvalidCommandLength1(void) MsgSize = 0; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsCmd(&UT_CmdBuf.Buf)); @@ -188,7 +185,6 @@ void SC_StartRtsCmd_Test_InvalidCommandLength2(void) MsgSize = SC_PACKET_MAX_SIZE + 1; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsCmd(&UT_CmdBuf.Buf)); @@ -211,10 +207,6 @@ void SC_StartRtsCmd_Test_RtsNotLoadedOrInUse(void) SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag = false; SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus = SC_IDLE; - /* Set message size in order to satisfy if-statement after comment "Make sure the command is big enough, but not too - * big" */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsCmd(&UT_CmdBuf.Buf)); @@ -236,10 +228,6 @@ void SC_StartRtsCmd_Test_RtsDisabled(void) SC_OperData.RtsInfoTblAddr[RtsIndex].DisabledFlag = true; SC_OperData.RtsInfoTblAddr[RtsIndex].RtsStatus = SC_LOADED; - /* Set message size in order to satisfy if-statement after comment "Make sure the command is big enough, but not too - * big" */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsCmd(&UT_CmdBuf.Buf)); @@ -252,10 +240,6 @@ void SC_StartRtsCmd_Test_InvalidRtsId(void) { UT_CmdBuf.RtsCmd.RtsId = SC_NUMBER_OF_RTS * 2; - /* Set message size in order to satisfy if-statement after comment "Make sure the command is big enough, but not too - * big" */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsCmd(&UT_CmdBuf.Buf)); @@ -268,10 +252,6 @@ void SC_StartRtsCmd_Test_InvalidRtsIdZero(void) { UT_CmdBuf.RtsCmd.RtsId = 0; - /* Set message size in order to satisfy if-statement after comment "Make sure the command is big enough, but not too - * big" */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsCmd(&UT_CmdBuf.Buf)); @@ -280,17 +260,6 @@ void SC_StartRtsCmd_Test_InvalidRtsIdZero(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void SC_StartRtsCmd_Test_NoVerifyLength(void) -{ - /* Execute the function being tested */ - UtAssert_VOIDCALL(SC_StartRtsCmd(&UT_CmdBuf.Buf)); - - /* Verify results */ - UtAssert_True(SC_OperData.HkPacket.RtsActiveErrCtr == 1, "SC_OperData.HkPacket.RtsActiveErrCtr == 1"); - - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void SC_StartRtsGrpCmd_Test_Nominal(void) { uint8 RtsIndex = 0; @@ -301,9 +270,6 @@ void SC_StartRtsGrpCmd_Test_Nominal(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -330,9 +296,6 @@ void SC_StartRtsGrpCmd_Test_StartRtsGroupError(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = SC_NUMBER_OF_RTS * 2; UT_CmdBuf.RtsGrpCmd.LastRtsId = SC_NUMBER_OF_RTS * 2; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -343,23 +306,11 @@ void SC_StartRtsGrpCmd_Test_StartRtsGroupError(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void SC_StartRtsGrpCmd_Test_NoVerifyLength(void) -{ - /* Execute the function being tested */ - UtAssert_VOIDCALL(SC_StartRtsGrpCmd(&UT_CmdBuf.Buf)); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void SC_StartRtsGrpCmd_Test_FirstRtsIndex(void) { UT_CmdBuf.RtsGrpCmd.FirstRtsId = SC_NUMBER_OF_RTS + 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -375,9 +326,6 @@ void SC_StartRtsGrpCmd_Test_FirstRtsIndexZero(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 0; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -393,9 +341,6 @@ void SC_StartRtsGrpCmd_Test_LastRtsIndex(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = SC_NUMBER_OF_RTS + 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -411,9 +356,6 @@ void SC_StartRtsGrpCmd_Test_LastRtsIndexZero(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 0; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -429,9 +371,6 @@ void SC_StartRtsGrpCmd_Test_FirstLastRtsIndex(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 2; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -455,9 +394,6 @@ void SC_StartRtsGrpCmd_Test_DisabledFlag(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -491,9 +427,6 @@ void SC_StartRtsGrpCmd_Test_RtsStatus(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StartRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -521,9 +454,6 @@ void SC_StopRtsCmd_Test_Nominal(void) { UT_CmdBuf.RtsCmd.RtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StopRtsCmd(&UT_CmdBuf.Buf)); @@ -538,9 +468,6 @@ void SC_StopRtsCmd_Test_InvalidRts(void) { UT_CmdBuf.RtsCmd.RtsId = SC_NUMBER_OF_RTS * 2; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StopRtsCmd(&UT_CmdBuf.Buf)); @@ -551,23 +478,11 @@ void SC_StopRtsCmd_Test_InvalidRts(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void SC_StopRtsCmd_Test_NoVerifyLength(void) -{ - /* Execute the function being tested */ - UtAssert_VOIDCALL(SC_StopRtsCmd(&UT_CmdBuf.Buf)); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void SC_StopRtsGrpCmd_Test_Nominal(void) { UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StopRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -583,9 +498,6 @@ void SC_StopRtsGrpCmd_Test_Error(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = SC_NUMBER_OF_RTS * 2; UT_CmdBuf.RtsGrpCmd.LastRtsId = SC_NUMBER_OF_RTS * 2; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StopRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -596,15 +508,6 @@ void SC_StopRtsGrpCmd_Test_Error(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void SC_StopRtsGrpCmd_Test_NoVerifyLength(void) -{ - /* Execute the function being tested */ - UtAssert_VOIDCALL(SC_StopRtsGrpCmd(&UT_CmdBuf.Buf)); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void SC_StopRtsGrpCmd_Test_NotExecuting(void) { uint8 RtsIndex = 0; @@ -614,9 +517,6 @@ void SC_StopRtsGrpCmd_Test_NotExecuting(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StopRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -632,9 +532,6 @@ void SC_StopRtsGrpCmd_Test_FirstRtsIndex(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = SC_NUMBER_OF_RTS + 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StopRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -650,9 +547,6 @@ void SC_StopRtsGrpCmd_Test_FirstRtsIndexZero(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 0; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StopRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -668,9 +562,6 @@ void SC_StopRtsGrpCmd_Test_LastRtsIndex(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = SC_NUMBER_OF_RTS + 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StopRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -686,9 +577,6 @@ void SC_StopRtsGrpCmd_Test_LastRtsIndexZero(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 0; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StopRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -704,9 +592,6 @@ void SC_StopRtsGrpCmd_Test_FirstLastRtsIndex(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 2; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_StopRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -723,9 +608,6 @@ void SC_DisableRtsCmd_Test_Nominal(void) UT_CmdBuf.RtsCmd.RtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_DisableRtsCmd(&UT_CmdBuf.Buf)); @@ -742,9 +624,6 @@ void SC_DisableRtsCmd_Test_InvalidRtsID(void) { UT_CmdBuf.RtsCmd.RtsId = SC_NUMBER_OF_RTS * 2; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_DisableRtsCmd(&UT_CmdBuf.Buf)); @@ -755,15 +634,6 @@ void SC_DisableRtsCmd_Test_InvalidRtsID(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void SC_DisableRtsCmd_Test_NoVerifyLength(void) -{ - /* Execute the function being tested */ - UtAssert_VOIDCALL(SC_DisableRtsCmd(&UT_CmdBuf.Buf)); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void SC_DisableRtsGrpCmd_Test_Nominal(void) { uint8 RtsIndex = 0; /* RtsId - 1 */ @@ -771,9 +641,6 @@ void SC_DisableRtsGrpCmd_Test_Nominal(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_DisableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -791,9 +658,6 @@ void SC_DisableRtsGrpCmd_Test_Error(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = SC_NUMBER_OF_RTS * 2; UT_CmdBuf.RtsGrpCmd.LastRtsId = SC_NUMBER_OF_RTS * 2; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_DisableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -804,23 +668,11 @@ void SC_DisableRtsGrpCmd_Test_Error(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void SC_DisableRtsGrpCmd_Test_NoVerifyLength(void) -{ - /* Execute the function being tested */ - UtAssert_VOIDCALL(SC_DisableRtsGrpCmd(&UT_CmdBuf.Buf)); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void SC_DisableRtsGrpCmd_Test_FirstRtsIndex(void) { UT_CmdBuf.RtsGrpCmd.FirstRtsId = SC_NUMBER_OF_RTS + 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_DisableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -836,9 +688,6 @@ void SC_DisableRtsGrpCmd_Test_FirstRtsIndexZero(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 0; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_DisableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -854,9 +703,6 @@ void SC_DisableRtsGrpCmd_Test_LastRtsIndex(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = SC_NUMBER_OF_RTS + 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_DisableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -872,9 +718,6 @@ void SC_DisableRtsGrpCmd_Test_LastRtsIndexZero(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 0; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_DisableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -890,9 +733,6 @@ void SC_DisableRtsGrpCmd_Test_FirstLastRtsIndex(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 2; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_DisableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -912,9 +752,6 @@ void SC_DisableRtsGrpCmd_Test_DisabledFlag(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_DisableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -933,9 +770,6 @@ void SC_EnableRtsCmd_Test_Nominal(void) UT_CmdBuf.RtsCmd.RtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_EnableRtsCmd(&UT_CmdBuf.Buf)); @@ -952,9 +786,6 @@ void SC_EnableRtsCmd_Test_InvalidRtsID(void) { UT_CmdBuf.RtsCmd.RtsId = SC_NUMBER_OF_RTS * 2; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_EnableRtsCmd(&UT_CmdBuf.Buf)); @@ -969,9 +800,6 @@ void SC_EnableRtsCmd_Test_InvalidRtsIDZero(void) { UT_CmdBuf.RtsCmd.RtsId = 0; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_EnableRtsCmd(&UT_CmdBuf.Buf)); @@ -982,15 +810,6 @@ void SC_EnableRtsCmd_Test_InvalidRtsIDZero(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void SC_EnableRtsCmd_Test_NoVerifyLength(void) -{ - /* Execute the function being tested */ - UtAssert_VOIDCALL(SC_EnableRtsCmd(&UT_CmdBuf.Buf)); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void SC_EnableRtsGrpCmd_Test_Nominal(void) { uint8 RtsIndex = 0; /* RtsId - 1 */ @@ -998,9 +817,6 @@ void SC_EnableRtsGrpCmd_Test_Nominal(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_EnableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -1018,9 +834,6 @@ void SC_EnableRtsGrpCmd_Test_Error(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = SC_NUMBER_OF_RTS * 2; UT_CmdBuf.RtsGrpCmd.LastRtsId = SC_NUMBER_OF_RTS * 2; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_EnableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -1031,23 +844,11 @@ void SC_EnableRtsGrpCmd_Test_Error(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void SC_EnableRtsGrpCmd_Test_NoVerifyLength(void) -{ - /* Execute the function being tested */ - UtAssert_VOIDCALL(SC_EnableRtsGrpCmd(&UT_CmdBuf.Buf)); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - void SC_EnableRtsGrpCmd_Test_FirstRtsIndex(void) { UT_CmdBuf.RtsGrpCmd.FirstRtsId = SC_NUMBER_OF_RTS + 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_EnableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -1063,9 +864,6 @@ void SC_EnableRtsGrpCmd_Test_FirstRtsIndexZero(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 0; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_EnableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -1081,9 +879,6 @@ void SC_EnableRtsGrpCmd_Test_LastRtsIndex(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = SC_NUMBER_OF_RTS + 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_EnableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -1099,9 +894,6 @@ void SC_EnableRtsGrpCmd_Test_LastRtsIndexZero(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 0; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_EnableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -1117,9 +909,6 @@ void SC_EnableRtsGrpCmd_Test_FirstLastRtsIndex(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 2; UT_CmdBuf.RtsGrpCmd.LastRtsId = 1; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_EnableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -1139,9 +928,6 @@ void SC_EnableRtsGrpCmd_Test_DisabledFlag(void) UT_CmdBuf.RtsGrpCmd.FirstRtsId = 1; UT_CmdBuf.RtsGrpCmd.LastRtsId = 2; - /* Set message size so SC_VerifyCmdLength will return true, to satisfy first if-statement */ - UT_SetDeferredRetcode(UT_KEY(SC_VerifyCmdLength), 1, true); - /* Execute the function being tested */ UtAssert_VOIDCALL(SC_EnableRtsGrpCmd(&UT_CmdBuf.Buf)); @@ -1257,13 +1043,9 @@ void UtTest_Setup(void) UtTest_Add(SC_StartRtsCmd_Test_InvalidRtsIdZero, SC_Test_Setup, SC_Test_TearDown, "SC_StartRtsCmd_Test_InvalidRtsIdZero"); - UtTest_Add(SC_StartRtsCmd_Test_NoVerifyLength, SC_Test_Setup, SC_Test_TearDown, - "SC_StartRtsCmd_Test_NoVerifyLength"); UtTest_Add(SC_StartRtsGrpCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_StartRtsGrpCmd_Test_Nominal"); UtTest_Add(SC_StartRtsGrpCmd_Test_StartRtsGroupError, SC_Test_Setup, SC_Test_TearDown, "SC_StartRtsGrpCmd_Test_StartRtsGroupError"); - UtTest_Add(SC_StartRtsGrpCmd_Test_NoVerifyLength, SC_Test_Setup, SC_Test_TearDown, - "SC_StartRtsGrpCmd_Test_NoVerifyLength"); UtTest_Add(SC_StartRtsGrpCmd_Test_FirstRtsIndex, SC_Test_Setup, SC_Test_TearDown, "SC_StartRtsGrpCmd_Test_FirstRtsIndex"); UtTest_Add(SC_StartRtsGrpCmd_Test_FirstRtsIndexZero, SC_Test_Setup, SC_Test_TearDown, @@ -1279,11 +1061,8 @@ void UtTest_Setup(void) UtTest_Add(SC_StartRtsGrpCmd_Test_RtsStatus, SC_Test_Setup, SC_Test_TearDown, "SC_StartRtsGrpCmd_Test_RtsStatus"); UtTest_Add(SC_StopRtsCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_StopRtsCmd_Test_Nominal"); UtTest_Add(SC_StopRtsCmd_Test_InvalidRts, SC_Test_Setup, SC_Test_TearDown, "SC_StopRtsCmd_Test_InvalidRts"); - UtTest_Add(SC_StopRtsCmd_Test_NoVerifyLength, SC_Test_Setup, SC_Test_TearDown, "SC_StopRtsCmd_Test_NoVerifyLength"); UtTest_Add(SC_StopRtsGrpCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_StopRtsGrpCmd_Test_Nominal"); UtTest_Add(SC_StopRtsGrpCmd_Test_Error, SC_Test_Setup, SC_Test_TearDown, "SC_StopRtsGrpCmd_Test_Error"); - UtTest_Add(SC_StopRtsGrpCmd_Test_NoVerifyLength, SC_Test_Setup, SC_Test_TearDown, - "SC_StopRtsGrpCmd_Test_NoVerifyLength"); UtTest_Add(SC_StopRtsGrpCmd_Test_NotExecuting, SC_Test_Setup, SC_Test_TearDown, "SC_StopRtsGrpCmd_Test_NotExecuting"); UtTest_Add(SC_StopRtsGrpCmd_Test_FirstRtsIndex, SC_Test_Setup, SC_Test_TearDown, @@ -1299,12 +1078,8 @@ void UtTest_Setup(void) UtTest_Add(SC_DisableRtsCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_DisableRtsCmd_Test_Nominal"); UtTest_Add(SC_DisableRtsCmd_Test_InvalidRtsID, SC_Test_Setup, SC_Test_TearDown, "SC_DisableRtsCmd_Test_InvalidRtsID"); - UtTest_Add(SC_DisableRtsCmd_Test_NoVerifyLength, SC_Test_Setup, SC_Test_TearDown, - "SC_DisableRtsCmd_Test_NoVerifyLength"); UtTest_Add(SC_DisableRtsGrpCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_DisableRtsGrpCmd_Test_Nominal"); UtTest_Add(SC_DisableRtsGrpCmd_Test_Error, SC_Test_Setup, SC_Test_TearDown, "SC_DisableRtsGrpCmd_Test_Error"); - UtTest_Add(SC_DisableRtsGrpCmd_Test_NoVerifyLength, SC_Test_Setup, SC_Test_TearDown, - "SC_DisableRtsGrpCmd_Test_NoVerifyLength"); UtTest_Add(SC_DisableRtsGrpCmd_Test_FirstRtsIndex, SC_Test_Setup, SC_Test_TearDown, "SC_DisableRtsGrpCmd_Test_FirstRtsIndex"); UtTest_Add(SC_DisableRtsGrpCmd_Test_FirstRtsIndexZero, SC_Test_Setup, SC_Test_TearDown, @@ -1321,12 +1096,8 @@ void UtTest_Setup(void) UtTest_Add(SC_EnableRtsCmd_Test_InvalidRtsID, SC_Test_Setup, SC_Test_TearDown, "SC_EnableRtsCmd_Test_InvalidRtsID"); UtTest_Add(SC_EnableRtsCmd_Test_InvalidRtsIDZero, SC_Test_Setup, SC_Test_TearDown, "SC_EnableRtsCmd_Test_InvalidRtsIDZero"); - UtTest_Add(SC_EnableRtsCmd_Test_NoVerifyLength, SC_Test_Setup, SC_Test_TearDown, - "SC_EnableRtsCmd_Test_NoVerifyLength"); UtTest_Add(SC_EnableRtsGrpCmd_Test_Nominal, SC_Test_Setup, SC_Test_TearDown, "SC_EnableRtsGrpCmd_Test_Nominal"); UtTest_Add(SC_EnableRtsGrpCmd_Test_Error, SC_Test_Setup, SC_Test_TearDown, "SC_EnableRtsGrpCmd_Test_Error"); - UtTest_Add(SC_EnableRtsGrpCmd_Test_NoVerifyLength, SC_Test_Setup, SC_Test_TearDown, - "SC_EnableRtsGrpCmd_Test_NoVerifyLength"); UtTest_Add(SC_EnableRtsGrpCmd_Test_FirstRtsIndex, SC_Test_Setup, SC_Test_TearDown, "SC_EnableRtsGrpCmd_Test_FirstRtsIndex"); UtTest_Add(SC_EnableRtsGrpCmd_Test_FirstRtsIndexZero, SC_Test_Setup, SC_Test_TearDown,