From 1e520a9cd776222cfa3d8e5fe7f8b6551e3051d8 Mon Sep 17 00:00:00 2001 From: havencarlson Date: Thu, 1 Jun 2023 15:16:41 -0400 Subject: [PATCH] Fix #75, Moved command validation out of command functions --- fsw/src/cs_app.c | 202 +++- fsw/src/cs_app_cmds.c | 41 +- fsw/src/cs_cmds.c | 92 +- fsw/src/cs_eeprom_cmds.c | 44 - fsw/src/cs_memory_cmds.c | 39 - fsw/src/cs_table_cmds.c | 43 - unit-test/cs_app_cmds_tests.c | 118 --- unit-test/cs_app_tests.c | 1529 ++++++++++++++++++++++++++++++ unit-test/cs_cmds_tests.c | 247 ----- unit-test/cs_eeprom_cmds_tests.c | 140 --- unit-test/cs_memory_cmds_tests.c | 140 --- unit-test/cs_table_cmds_tests.c | 124 --- 12 files changed, 1692 insertions(+), 1067 deletions(-) diff --git a/fsw/src/cs_app.c b/fsw/src/cs_app.c index 6191140..7c25266 100644 --- a/fsw/src/cs_app.c +++ b/fsw/src/cs_app.c @@ -275,169 +275,289 @@ void CS_ProcessCmd(const CFE_SB_Buffer_t *BufPtr) { /* All CS Commands */ case CS_NOOP_CC: - CS_NoopCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_NoopCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_RESET_CC: - CS_ResetCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_ResetCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_ONE_SHOT_CC: - CS_OneShotCmd((CS_OneShotCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_OneShotCmd_t))) + { + CS_OneShotCmd((CS_OneShotCmd_t *)BufPtr); + } break; case CS_CANCEL_ONE_SHOT_CC: - CS_CancelOneShotCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_CancelOneShotCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_ENABLE_ALL_CS_CC: - CS_EnableAllCSCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_EnableAllCSCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_DISABLE_ALL_CS_CC: - CS_DisableAllCSCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_DisableAllCSCmd((CS_NoArgsCmd_t *)BufPtr); + } break; /* cFE core Commands */ case CS_ENABLE_CFE_CORE_CC: - CS_EnableCfeCoreCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_EnableCfeCoreCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_DISABLE_CFE_CORE_CC: - CS_DisableCfeCoreCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_DisableCfeCoreCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_REPORT_BASELINE_CFE_CORE_CC: - CS_ReportBaselineCfeCoreCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_ReportBaselineCfeCoreCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_RECOMPUTE_BASELINE_CFE_CORE_CC: - CS_RecomputeBaselineCfeCoreCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_RecomputeBaselineCfeCoreCmd((CS_NoArgsCmd_t *)BufPtr); + } break; /* OS Commands*/ case CS_ENABLE_OS_CC: - CS_EnableOSCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_EnableOSCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_DISABLE_OS_CC: - CS_DisableOSCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_DisableOSCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_REPORT_BASELINE_OS_CC: - CS_ReportBaselineOSCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_ReportBaselineOSCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_RECOMPUTE_BASELINE_OS_CC: - CS_RecomputeBaselineOSCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_RecomputeBaselineOSCmd((CS_NoArgsCmd_t *)BufPtr); + } break; /* EEPROM Commands */ case CS_ENABLE_EEPROM_CC: - CS_EnableEepromCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_EnableEepromCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_DISABLE_EEPROM_CC: - CS_DisableEepromCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_DisableEepromCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_REPORT_BASELINE_EEPROM_CC: - CS_ReportBaselineEntryIDEepromCmd((CS_EntryCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) + { + CS_ReportBaselineEntryIDEepromCmd((CS_EntryCmd_t *)BufPtr); + } break; case CS_RECOMPUTE_BASELINE_EEPROM_CC: - CS_RecomputeBaselineEepromCmd((CS_EntryCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) + { + CS_RecomputeBaselineEepromCmd((CS_EntryCmd_t *)BufPtr); + } break; case CS_ENABLE_ENTRY_EEPROM_CC: - CS_EnableEntryIDEepromCmd((CS_EntryCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) + { + CS_EnableEntryIDEepromCmd((CS_EntryCmd_t *)BufPtr); + } break; case CS_DISABLE_ENTRY_EEPROM_CC: - CS_DisableEntryIDEepromCmd((CS_EntryCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) + { + CS_DisableEntryIDEepromCmd((CS_EntryCmd_t *)BufPtr); + } break; case CS_GET_ENTRY_ID_EEPROM_CC: - CS_GetEntryIDEepromCmd((CS_GetEntryIDCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_GetEntryIDCmd_t))) + { + CS_GetEntryIDEepromCmd((CS_GetEntryIDCmd_t *)BufPtr); + } break; /* Memory Commands */ case CS_ENABLE_MEMORY_CC: - CS_EnableMemoryCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_EnableMemoryCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_DISABLE_MEMORY_CC: - CS_DisableMemoryCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_DisableMemoryCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_REPORT_BASELINE_MEMORY_CC: - CS_ReportBaselineEntryIDMemoryCmd((CS_EntryCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) + { + CS_ReportBaselineEntryIDMemoryCmd((CS_EntryCmd_t *)BufPtr); + } break; case CS_RECOMPUTE_BASELINE_MEMORY_CC: - CS_RecomputeBaselineMemoryCmd((CS_EntryCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) + { + CS_RecomputeBaselineMemoryCmd((CS_EntryCmd_t *)BufPtr); + } break; case CS_ENABLE_ENTRY_MEMORY_CC: - CS_EnableEntryIDMemoryCmd((CS_EntryCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) + { + CS_EnableEntryIDMemoryCmd((CS_EntryCmd_t *)BufPtr); + } break; case CS_DISABLE_ENTRY_MEMORY_CC: - CS_DisableEntryIDMemoryCmd((CS_EntryCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) + { + CS_DisableEntryIDMemoryCmd((CS_EntryCmd_t *)BufPtr); + } break; case CS_GET_ENTRY_ID_MEMORY_CC: - CS_GetEntryIDMemoryCmd((CS_GetEntryIDCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_GetEntryIDCmd_t))) + { + CS_GetEntryIDMemoryCmd((CS_GetEntryIDCmd_t *)BufPtr); + } break; /* Tables Commands */ case CS_ENABLE_TABLES_CC: - CS_EnableTablesCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_EnableTablesCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_DISABLE_TABLES_CC: - CS_DisableTablesCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_DisableTablesCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_REPORT_BASELINE_TABLE_CC: - CS_ReportBaselineTablesCmd((CS_TableNameCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_TableNameCmd_t))) + { + CS_ReportBaselineTablesCmd((CS_TableNameCmd_t *)BufPtr); + } break; case CS_RECOMPUTE_BASELINE_TABLE_CC: - CS_RecomputeBaselineTablesCmd((CS_TableNameCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_TableNameCmd_t))) + { + CS_RecomputeBaselineTablesCmd((CS_TableNameCmd_t *)BufPtr); + } break; case CS_ENABLE_NAME_TABLE_CC: - CS_EnableNameTablesCmd((CS_TableNameCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_TableNameCmd_t))) + { + CS_EnableNameTablesCmd((CS_TableNameCmd_t *)BufPtr); + } break; case CS_DISABLE_NAME_TABLE_CC: - CS_DisableNameTablesCmd((CS_TableNameCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_TableNameCmd_t))) + { + CS_DisableNameTablesCmd((CS_TableNameCmd_t *)BufPtr); + } break; /* App Commands */ case CS_ENABLE_APPS_CC: - CS_EnableAppCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_EnableAppCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_DISABLE_APPS_CC: - CS_DisableAppCmd((CS_NoArgsCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) + { + CS_DisableAppCmd((CS_NoArgsCmd_t *)BufPtr); + } break; case CS_REPORT_BASELINE_APP_CC: - CS_ReportBaselineAppCmd((CS_AppNameCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_AppNameCmd_t))) + { + CS_ReportBaselineAppCmd((CS_AppNameCmd_t *)BufPtr); + } break; case CS_RECOMPUTE_BASELINE_APP_CC: - CS_RecomputeBaselineAppCmd((CS_AppNameCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_AppNameCmd_t))) + { + CS_RecomputeBaselineAppCmd((CS_AppNameCmd_t *)BufPtr); + } break; case CS_ENABLE_NAME_APP_CC: - CS_EnableNameAppCmd((CS_AppNameCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_AppNameCmd_t))) + { + CS_EnableNameAppCmd((CS_AppNameCmd_t *)BufPtr); + } break; case CS_DISABLE_NAME_APP_CC: - CS_DisableNameAppCmd((CS_AppNameCmd_t *)BufPtr); + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_AppNameCmd_t))) + { + CS_DisableNameAppCmd((CS_AppNameCmd_t *)BufPtr); + } break; default: @@ -624,4 +744,4 @@ void CS_UpdateCDS(void) } } } -#endif /* #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true ) */ \ No newline at end of file +#endif /* #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true ) */ diff --git a/fsw/src/cs_app_cmds.c b/fsw/src/cs_app_cmds.c index 491fc0f..70ea4ec 100644 --- a/fsw/src/cs_app_cmds.c +++ b/fsw/src/cs_app_cmds.c @@ -46,12 +46,6 @@ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_DisableAppCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { CS_AppData.HkPacket.AppCSState = CS_STATE_DISABLED; @@ -64,7 +58,6 @@ void CS_DisableAppCmd(const CS_NoArgsCmd_t *CmdPtr) CFE_EVS_SendEvent(CS_DISABLE_APP_INF_EID, CFE_EVS_EventType_INFORMATION, "Checksumming of App is Disabled"); CS_AppData.HkPacket.CmdCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -74,12 +67,6 @@ void CS_DisableAppCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_EnableAppCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { CS_AppData.HkPacket.AppCSState = CS_STATE_ENABLED; @@ -91,7 +78,6 @@ void CS_EnableAppCmd(const CS_NoArgsCmd_t *CmdPtr) CFE_EVS_SendEvent(CS_ENABLE_APP_INF_EID, CFE_EVS_EventType_INFORMATION, "Checksumming of App is Enabled"); CS_AppData.HkPacket.CmdCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -102,15 +88,10 @@ void CS_EnableAppCmd(const CS_NoArgsCmd_t *CmdPtr) void CS_ReportBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_AppNameCmd_t); - CS_Res_App_Table_Entry_t *ResultsEntry; uint32 Baseline; char Name[OS_MAX_API_NAME]; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { strncpy(Name, CmdPtr->Name, sizeof(Name) - 1); Name[sizeof(Name) - 1] = '\0'; @@ -135,7 +116,6 @@ void CS_ReportBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) "App report baseline failed, app %s not found", Name); CS_AppData.HkPacket.CmdErrCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -146,17 +126,11 @@ void CS_ReportBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) void CS_RecomputeBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_AppNameCmd_t); - CFE_ES_TaskId_t ChildTaskID; CFE_Status_t Status; CS_Res_App_Table_Entry_t *ResultsEntry; char Name[OS_MAX_API_NAME]; - /* Verify command packet length */ - - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_AppData.HkPacket.RecomputeInProgress == false && CS_AppData.HkPacket.OneShotInProgress == false) { strncpy(Name, CmdPtr->Name, sizeof(Name) - 1); @@ -204,7 +178,6 @@ void CS_RecomputeBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) "App recompute baseline for app %s failed: child task in use", Name); CS_AppData.HkPacket.CmdErrCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -215,15 +188,10 @@ void CS_RecomputeBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) void CS_DisableNameAppCmd(const CS_AppNameCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_AppNameCmd_t); - CS_Res_App_Table_Entry_t *ResultsEntry; CS_Def_App_Table_Entry_t *DefinitionEntry; char Name[OS_MAX_API_NAME]; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { strncpy(Name, CmdPtr->Name, sizeof(Name) - 1); @@ -260,7 +228,6 @@ void CS_DisableNameAppCmd(const CS_AppNameCmd_t *CmdPtr) CS_AppData.HkPacket.CmdErrCounter++; } } /* end InProgress if */ - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -271,15 +238,10 @@ void CS_DisableNameAppCmd(const CS_AppNameCmd_t *CmdPtr) void CS_EnableNameAppCmd(const CS_AppNameCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_AppNameCmd_t); - CS_Res_App_Table_Entry_t *ResultsEntry; CS_Def_App_Table_Entry_t *DefinitionEntry; char Name[OS_MAX_API_NAME]; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { strncpy(Name, CmdPtr->Name, sizeof(Name) - 1); @@ -313,5 +275,4 @@ void CS_EnableNameAppCmd(const CS_AppNameCmd_t *CmdPtr) CS_AppData.HkPacket.CmdErrCounter++; } } /* end InProgress if */ - } -} \ No newline at end of file +} diff --git a/fsw/src/cs_cmds.c b/fsw/src/cs_cmds.c index d0c0905..6a14e23 100644 --- a/fsw/src/cs_cmds.c +++ b/fsw/src/cs_cmds.c @@ -48,17 +48,10 @@ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_NoopCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { CS_AppData.HkPacket.CmdCounter++; CFE_EVS_SendEvent(CS_NOOP_INF_EID, CFE_EVS_EventType_INFORMATION, "No-op command. Version %d.%d.%d.%d", CS_MAJOR_VERSION, CS_MINOR_VERSION, CS_REVISION, CS_MISSION_REV); - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -68,12 +61,6 @@ void CS_NoopCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_ResetCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { CS_AppData.HkPacket.CmdCounter = 0; CS_AppData.HkPacket.CmdErrCounter = 0; @@ -86,7 +73,6 @@ void CS_ResetCmd(const CS_NoArgsCmd_t *CmdPtr) CS_AppData.HkPacket.PassCounter = 0; CFE_EVS_SendEvent(CS_RESET_DBG_EID, CFE_EVS_EventType_DEBUG, "Reset Counters command recieved"); - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -204,12 +190,6 @@ void CS_BackgroundCheckCycle(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_DisableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { CS_AppData.HkPacket.ChecksumState = CS_STATE_DISABLED; /* zero out the temp values in all the tables @@ -225,7 +205,6 @@ void CS_DisableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) CS_AppData.HkPacket.CmdCounter++; CFE_EVS_SendEvent(CS_DISABLE_ALL_INF_EID, CFE_EVS_EventType_INFORMATION, "Background Checksumming Disabled"); - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -235,18 +214,11 @@ void CS_DisableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_EnableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { CS_AppData.HkPacket.ChecksumState = CS_STATE_ENABLED; CS_AppData.HkPacket.CmdCounter++; CFE_EVS_SendEvent(CS_ENABLE_ALL_INF_EID, CFE_EVS_EventType_INFORMATION, "Background Checksumming Enabled"); - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -256,12 +228,6 @@ void CS_EnableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_DisableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { CS_AppData.HkPacket.CfeCoreCSState = CS_STATE_DISABLED; CS_ZeroCfeCoreTempValues(); @@ -273,7 +239,6 @@ void CS_DisableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) "Checksumming of cFE Core is Disabled"); CS_AppData.HkPacket.CmdCounter++; - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -283,12 +248,6 @@ void CS_DisableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_EnableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { CS_AppData.HkPacket.CfeCoreCSState = CS_STATE_ENABLED; #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) @@ -299,7 +258,6 @@ void CS_EnableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) "Checksumming of cFE Core is Enabled"); CS_AppData.HkPacket.CmdCounter++; - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -309,12 +267,6 @@ void CS_EnableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_DisableOSCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { CS_AppData.HkPacket.OSCSState = CS_STATE_DISABLED; CS_ZeroOSTempValues(); @@ -326,7 +278,6 @@ void CS_DisableOSCmd(const CS_NoArgsCmd_t *CmdPtr) "Checksumming of OS code segment is Disabled"); CS_AppData.HkPacket.CmdCounter++; - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -336,12 +287,6 @@ void CS_DisableOSCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_EnableOSCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { CS_AppData.HkPacket.OSCSState = CS_STATE_ENABLED; #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) @@ -352,7 +297,6 @@ void CS_EnableOSCmd(const CS_NoArgsCmd_t *CmdPtr) "Checksumming of OS code segment is Enabled"); CS_AppData.HkPacket.CmdCounter++; - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -362,12 +306,6 @@ void CS_EnableOSCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_ReportBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_AppData.CfeCoreCodeSeg.ComputedYet == true) { CFE_EVS_SendEvent(CS_BASELINE_CFECORE_INF_EID, CFE_EVS_EventType_INFORMATION, @@ -380,7 +318,6 @@ void CS_ReportBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) "Baseline of cFE Core has not been computed yet"); } CS_AppData.HkPacket.CmdCounter++; - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -390,12 +327,6 @@ void CS_ReportBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_ReportBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_AppData.OSCodeSeg.ComputedYet == true) { CFE_EVS_SendEvent(CS_BASELINE_OS_INF_EID, CFE_EVS_EventType_INFORMATION, @@ -408,7 +339,6 @@ void CS_ReportBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) "Baseline of OS code segment has not been computed yet"); } CS_AppData.HkPacket.CmdCounter++; - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -419,13 +349,9 @@ void CS_ReportBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) void CS_RecomputeBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); CFE_ES_TaskId_t ChildTaskID; CFE_Status_t Status; - /* Verify command packet length... */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_AppData.HkPacket.RecomputeInProgress == false && CS_AppData.HkPacket.OneShotInProgress == false) { /* There is no child task running right now, we can use it*/ @@ -462,7 +388,6 @@ void CS_RecomputeBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) "Recompute cFE core failed: child task in use"); CS_AppData.HkPacket.CmdErrCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -473,13 +398,9 @@ void CS_RecomputeBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) void CS_RecomputeBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); CFE_ES_TaskId_t ChildTaskID; CFE_Status_t Status; - /* Verify command packet length... */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_AppData.HkPacket.RecomputeInProgress == false && CS_AppData.HkPacket.OneShotInProgress == false) { /* There is no child task running right now, we can use it*/ @@ -514,7 +435,6 @@ void CS_RecomputeBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) "Recompute OS code segment failed: child task in use"); CS_AppData.HkPacket.CmdErrCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -525,13 +445,9 @@ void CS_RecomputeBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) void CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_OneShotCmd_t); CFE_ES_TaskId_t ChildTaskID; CFE_Status_t Status; - /* Verify command packet length... */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { /* validate size and address */ Status = CFE_PSP_MemValidateRange(CmdPtr->Address, CmdPtr->Size, CFE_PSP_MEM_ANY); @@ -595,7 +511,6 @@ void CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr) CS_AppData.HkPacket.CmdErrCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -606,12 +521,8 @@ void CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr) void CS_CancelOneShotCmd(const CS_NoArgsCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); CFE_Status_t Status; - /* Verify command packet length... */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { /* Make sure there is a OneShot command in use */ if (CS_AppData.HkPacket.RecomputeInProgress == false && CS_AppData.HkPacket.OneShotInProgress == true) { @@ -640,5 +551,4 @@ void CS_CancelOneShotCmd(const CS_NoArgsCmd_t *CmdPtr) "Cancel OneShot checksum failed. No OneShot active"); CS_AppData.HkPacket.CmdErrCounter++; } - } -} \ No newline at end of file +} diff --git a/fsw/src/cs_eeprom_cmds.c b/fsw/src/cs_eeprom_cmds.c index f1ac6cf..601c92f 100644 --- a/fsw/src/cs_eeprom_cmds.c +++ b/fsw/src/cs_eeprom_cmds.c @@ -48,12 +48,6 @@ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_DisableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { CS_AppData.HkPacket.EepromCSState = CS_STATE_DISABLED; @@ -68,7 +62,6 @@ void CS_DisableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) CS_AppData.HkPacket.CmdCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -78,12 +71,6 @@ void CS_DisableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_EnableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { CS_AppData.HkPacket.EepromCSState = CS_STATE_ENABLED; @@ -97,7 +84,6 @@ void CS_EnableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) CS_AppData.HkPacket.CmdCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -108,16 +94,11 @@ void CS_EnableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) void CS_ReportBaselineEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_EntryCmd_t); - uint32 Baseline = 0; uint16 EntryID = 0; uint16 State = CS_STATE_EMPTY; CS_Res_EepromMemory_Table_Entry_t ResultsEntry; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { EntryID = CmdPtr->EntryID; if ((EntryID < CS_MAX_NUM_EEPROM_TABLE_ENTRIES) && @@ -155,7 +136,6 @@ void CS_ReportBaselineEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) State, (CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1)); CS_AppData.HkPacket.CmdErrCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -166,16 +146,11 @@ void CS_ReportBaselineEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) void CS_RecomputeBaselineEepromCmd(const CS_EntryCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_EntryCmd_t); - CFE_ES_TaskId_t ChildTaskID = CFE_ES_TASKID_UNDEFINED; CFE_Status_t Status = CS_ERROR; uint16 EntryID = 0; uint16 State = CS_STATE_EMPTY; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { EntryID = CmdPtr->EntryID; if (CS_AppData.HkPacket.RecomputeInProgress == false && CS_AppData.HkPacket.OneShotInProgress == false) @@ -238,7 +213,6 @@ void CS_RecomputeBaselineEepromCmd(const CS_EntryCmd_t *CmdPtr) "Recompute baseline of EEPROM Entry ID %d failed: child task in use", EntryID); CS_AppData.HkPacket.CmdErrCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -249,15 +223,10 @@ void CS_RecomputeBaselineEepromCmd(const CS_EntryCmd_t *CmdPtr) void CS_EnableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_EntryCmd_t); - CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; uint16 EntryID = 0; uint16 State = CS_STATE_EMPTY; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { EntryID = CmdPtr->EntryID; @@ -304,7 +273,6 @@ void CS_EnableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) CS_AppData.HkPacket.CmdErrCounter++; } } /* end InProgress if */ - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -315,15 +283,10 @@ void CS_EnableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) void CS_DisableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_EntryCmd_t); - CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; uint16 EntryID = 0; uint16 State = CS_STATE_EMPTY; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { EntryID = CmdPtr->EntryID; @@ -373,7 +336,6 @@ void CS_DisableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) CS_AppData.HkPacket.CmdErrCounter++; } } /* end InProgress if */ - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -384,16 +346,11 @@ void CS_DisableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) void CS_GetEntryIDEepromCmd(const CS_GetEntryIDCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_GetEntryIDCmd_t); - CS_Res_EepromMemory_Table_Entry_t *StartOfResultsTable = NULL; uint16 Loop = 0; bool EntryFound = false; CS_Res_EepromMemory_Table_Entry_t ResultsEntry; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { StartOfResultsTable = CS_AppData.ResEepromTblPtr; for (Loop = 0; Loop < CS_MAX_NUM_EEPROM_TABLE_ENTRIES; Loop++) @@ -416,5 +373,4 @@ void CS_GetEntryIDEepromCmd(const CS_GetEntryIDCmd_t *CmdPtr) "Address 0x%08X was not found in EEPROM table", (unsigned int)(CmdPtr->Address)); } CS_AppData.HkPacket.CmdCounter++; - } } diff --git a/fsw/src/cs_memory_cmds.c b/fsw/src/cs_memory_cmds.c index 342e884..edfa846 100644 --- a/fsw/src/cs_memory_cmds.c +++ b/fsw/src/cs_memory_cmds.c @@ -48,12 +48,6 @@ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_DisableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { CS_AppData.HkPacket.MemoryCSState = CS_STATE_DISABLED; @@ -68,7 +62,6 @@ void CS_DisableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) CS_AppData.HkPacket.CmdCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -78,12 +71,6 @@ void CS_DisableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_EnableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { CS_AppData.HkPacket.MemoryCSState = CS_STATE_ENABLED; @@ -97,7 +84,6 @@ void CS_EnableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) CS_AppData.HkPacket.CmdCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -108,15 +94,11 @@ void CS_EnableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) void CS_ReportBaselineEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_EntryCmd_t); CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; uint32 Baseline = 0; uint16 EntryID = 0; uint16 State = CS_STATE_EMPTY; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { EntryID = CmdPtr->EntryID; if ((EntryID < CS_MAX_NUM_MEMORY_TABLE_ENTRIES) && @@ -154,7 +136,6 @@ void CS_ReportBaselineEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) State, (CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1)); CS_AppData.HkPacket.CmdErrCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -165,15 +146,11 @@ void CS_ReportBaselineEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) void CS_RecomputeBaselineMemoryCmd(const CS_EntryCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_EntryCmd_t); CFE_ES_TaskId_t ChildTaskID = CFE_ES_TASKID_UNDEFINED; CFE_Status_t Status = CS_ERROR; uint16 EntryID = 0; uint16 State = CS_STATE_EMPTY; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { EntryID = CmdPtr->EntryID; if (CS_AppData.HkPacket.RecomputeInProgress == false && CS_AppData.HkPacket.OneShotInProgress == false) @@ -236,7 +213,6 @@ void CS_RecomputeBaselineMemoryCmd(const CS_EntryCmd_t *CmdPtr) "Recompute baseline of Memory Entry ID %d failed: child task in use", EntryID); CS_AppData.HkPacket.CmdErrCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -247,14 +223,10 @@ void CS_RecomputeBaselineMemoryCmd(const CS_EntryCmd_t *CmdPtr) void CS_EnableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_EntryCmd_t); CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; uint16 EntryID = 0; uint16 State = CS_STATE_EMPTY; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { EntryID = CmdPtr->EntryID; @@ -301,7 +273,6 @@ void CS_EnableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) CS_AppData.HkPacket.CmdErrCounter++; } } /* end InProgress if */ - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -312,14 +283,10 @@ void CS_EnableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) void CS_DisableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_EntryCmd_t); CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; uint16 EntryID = 0; uint16 State = CS_STATE_EMPTY; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { EntryID = CmdPtr->EntryID; @@ -369,7 +336,6 @@ void CS_DisableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) CS_AppData.HkPacket.CmdErrCounter++; } } /* end InProgress if */ - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -380,15 +346,11 @@ void CS_DisableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) void CS_GetEntryIDMemoryCmd(const CS_GetEntryIDCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_GetEntryIDCmd_t); CS_Res_EepromMemory_Table_Entry_t *StartOfResultsTable = NULL; CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; uint16 Loop = 0; bool EntryFound = false; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { StartOfResultsTable = CS_AppData.ResMemoryTblPtr; for (Loop = 0; Loop < CS_MAX_NUM_MEMORY_TABLE_ENTRIES; Loop++) @@ -411,5 +373,4 @@ void CS_GetEntryIDMemoryCmd(const CS_GetEntryIDCmd_t *CmdPtr) "Address 0x%08X was not found in Memory table", (unsigned int)(CmdPtr->Address)); } CS_AppData.HkPacket.CmdCounter++; - } } diff --git a/fsw/src/cs_table_cmds.c b/fsw/src/cs_table_cmds.c index 04c3669..a6388cb 100644 --- a/fsw/src/cs_table_cmds.c +++ b/fsw/src/cs_table_cmds.c @@ -46,12 +46,6 @@ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_DisableTablesCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { CS_AppData.HkPacket.TablesCSState = CS_STATE_DISABLED; @@ -65,7 +59,6 @@ void CS_DisableTablesCmd(const CS_NoArgsCmd_t *CmdPtr) "Checksumming of Tables is Disabled"); CS_AppData.HkPacket.CmdCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -75,12 +68,6 @@ void CS_DisableTablesCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_EnableTablesCmd(const CS_NoArgsCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { CS_AppData.HkPacket.TablesCSState = CS_STATE_ENABLED; @@ -93,7 +80,6 @@ void CS_EnableTablesCmd(const CS_NoArgsCmd_t *CmdPtr) "Checksumming of Tables is Enabled"); CS_AppData.HkPacket.CmdCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -103,16 +89,10 @@ void CS_EnableTablesCmd(const CS_NoArgsCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_ReportBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_TableNameCmd_t); - CS_Res_Tables_Table_Entry_t *ResultsEntry; uint32 Baseline; char Name[CFE_TBL_MAX_FULL_NAME_LEN]; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { strncpy(Name, CmdPtr->Name, sizeof(Name) - 1); Name[sizeof(Name) - 1] = '\0'; @@ -137,7 +117,6 @@ void CS_ReportBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr) "Tables report baseline failed, table %s not found", Name); CS_AppData.HkPacket.CmdErrCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -147,18 +126,11 @@ void CS_ReportBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_RecomputeBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_TableNameCmd_t); - CFE_ES_TaskId_t ChildTaskID; CFE_Status_t Status; CS_Res_Tables_Table_Entry_t *ResultsEntry; char Name[CFE_TBL_MAX_FULL_NAME_LEN]; - /* Verify command packet length */ - - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_AppData.HkPacket.RecomputeInProgress == false && CS_AppData.HkPacket.OneShotInProgress == false) { strncpy(Name, CmdPtr->Name, sizeof(Name) - 1); @@ -206,7 +178,6 @@ void CS_RecomputeBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr) "Tables recompute baseline for table %s failed: child task in use", Name); CS_AppData.HkPacket.CmdErrCounter++; } - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -216,16 +187,10 @@ void CS_RecomputeBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_DisableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_TableNameCmd_t); - CS_Res_Tables_Table_Entry_t *ResultsEntry; CS_Def_Tables_Table_Entry_t *DefinitionEntry; char Name[CFE_TBL_MAX_FULL_NAME_LEN]; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { strncpy(Name, CmdPtr->Name, sizeof(Name) - 1); @@ -261,7 +226,6 @@ void CS_DisableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr) CS_AppData.HkPacket.CmdErrCounter++; } } /* end InProgress if */ - } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -271,16 +235,10 @@ void CS_DisableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_EnableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr) { - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_TableNameCmd_t); - CS_Res_Tables_Table_Entry_t *ResultsEntry; CS_Def_Tables_Table_Entry_t *DefinitionEntry; char Name[CFE_TBL_MAX_FULL_NAME_LEN]; - /* Verify command packet length */ - if (CS_VerifyCmdLength(&CmdPtr->CmdHeader.Msg, ExpectedLength)) - { if (CS_CheckRecomputeOneshot() == false) { strncpy(Name, CmdPtr->Name, sizeof(Name) - 1); @@ -314,5 +272,4 @@ void CS_EnableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr) CS_AppData.HkPacket.CmdErrCounter++; } } /* end InProgress if */ - } } diff --git a/unit-test/cs_app_cmds_tests.c b/unit-test/cs_app_cmds_tests.c index 317a2d0..3c5afbb 100644 --- a/unit-test/cs_app_cmds_tests.c +++ b/unit-test/cs_app_cmds_tests.c @@ -106,24 +106,6 @@ void CS_DisableAppCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableAppCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_DisableAppCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_DisableAppCmd_Test_OneShot(void) { CS_NoArgsCmd_t CmdPacket; @@ -178,24 +160,6 @@ void CS_EnableAppCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableAppCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_EnableAppCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_EnableAppCmd_Test_OneShot(void) { CS_NoArgsCmd_t CmdPacket; @@ -334,24 +298,6 @@ void CS_ReportBaselineAppCmd_Test_BaselineInvalidName(void) call_count_CFE_EVS_SendEvent); } -void CS_ReportBaselineAppCmd_Test_VerifyError(void) -{ - CS_AppNameCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ReportBaselineAppCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_ReportBaselineAppCmd_Test_OneShot(void) { CS_AppNameCmd_t CmdPacket; @@ -563,24 +509,6 @@ void CS_RecomputeBaselineAppCmd_Test_RecomputeInProgress(void) call_count_CFE_EVS_SendEvent); } -void CS_RecomputeBaselineAppCmd_Test_VerifyError(void) -{ - CS_AppNameCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_RecomputeBaselineAppCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_DisableNameAppCmd_Test_Nominal(void) { CS_AppNameCmd_t CmdPacket; @@ -723,24 +651,6 @@ void CS_DisableNameAppCmd_Test_UnknownNameError(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableNameAppCmd_Test_VerifyError(void) -{ - CS_AppNameCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_DisableNameAppCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_DisableNameAppCmd_Test_OneShot(void) { CS_AppNameCmd_t CmdPacket; @@ -904,24 +814,6 @@ void CS_EnableNameAppCmd_Test_UnknownNameError(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableNameAppCmd_Test_VerifyError(void) -{ - CS_AppNameCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_EnableNameAppCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_EnableNameAppCmd_Test_OneShot(void) { CS_AppNameCmd_t CmdPacket; @@ -945,11 +837,9 @@ void CS_EnableNameAppCmd_Test_OneShot(void) void UtTest_Setup(void) { UtTest_Add(CS_DisableAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_DisableAppCmd_Test"); - UtTest_Add(CS_DisableAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, "CS_DisableAppCmd_Test_VerifyError"); UtTest_Add(CS_DisableAppCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_DisableAppCmd_Test_OneShot"); UtTest_Add(CS_EnableAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_EnableAppCmd_Test"); - UtTest_Add(CS_EnableAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, "CS_EnableAppCmd_Test_VerifyError"); UtTest_Add(CS_EnableAppCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_EnableAppCmd_Test_OneShot"); UtTest_Add(CS_ReportBaselineAppCmd_Test_Baseline, CS_Test_Setup, CS_Test_TearDown, @@ -958,8 +848,6 @@ void UtTest_Setup(void) "CS_ReportBaselineAppCmd_Test_NoBaseline"); UtTest_Add(CS_ReportBaselineAppCmd_Test_BaselineInvalidName, CS_Test_Setup, CS_Test_TearDown, "CS_ReportBaselineAppCmd_Test_BaselineInvalidName"); - UtTest_Add(CS_ReportBaselineAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ReportBaselineAppCmd_Test_VerifyError"); UtTest_Add(CS_ReportBaselineAppCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_ReportBaselineAppCmd_Test_OneShot"); @@ -971,16 +859,12 @@ void UtTest_Setup(void) "CS_RecomputeBaselineAppCmd_Test_UnknownNameError"); UtTest_Add(CS_RecomputeBaselineAppCmd_Test_RecomputeInProgress, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineAppCmd_Test_RecomputeInProgress"); - UtTest_Add(CS_RecomputeBaselineAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_RecomputeBaselineAppCmd_Test_VerifyError"); UtTest_Add(CS_DisableNameAppCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_DisableNameAppCmd_Test_Nominal"); UtTest_Add(CS_DisableNameAppCmd_Test_UpdateAppsDefinitionTableError, CS_Test_Setup, CS_Test_TearDown, "CS_DisableNameAppCmd_Test_UpdateAppsDefinitionTableError"); UtTest_Add(CS_DisableNameAppCmd_Test_UnknownNameError, CS_Test_Setup, CS_Test_TearDown, "CS_DisableNameAppCmd_Test_UnknownNameError"); - UtTest_Add(CS_DisableNameAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableNameAppCmd_Test_VerifyError"); UtTest_Add(CS_DisableNameAppCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_DisableNameAppCmd_Test_OneShot"); UtTest_Add(CS_EnableNameAppCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_EnableNameAppCmd_Test_Nominal"); @@ -988,7 +872,5 @@ void UtTest_Setup(void) "CS_EnableNameAppCmd_Test_UpdateAppsDefinitionTableError"); UtTest_Add(CS_EnableNameAppCmd_Test_UnknownNameError, CS_Test_Setup, CS_Test_TearDown, "CS_EnableNameAppCmd_Test_UnknownNameError"); - UtTest_Add(CS_EnableNameAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableNameAppCmd_Test_VerifyError"); UtTest_Add(CS_EnableNameAppCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_EnableNameAppCmd_Test_OneShot"); } diff --git a/unit-test/cs_app_tests.c b/unit-test/cs_app_tests.c index 427e521..57f757b 100644 --- a/unit-test/cs_app_tests.c +++ b/unit-test/cs_app_tests.c @@ -22,6 +22,11 @@ */ #include "cs_app.h" +#include "cs_app_cmds.h" +#include "cs_cmds.h" +#include "cs_eeprom_cmds.h" +#include "cs_memory_cmds.h" +#include "cs_table_cmds.h" #include "cs_msg.h" #include "cs_msgdefs.h" #include "cs_events.h" @@ -2283,6 +2288,1366 @@ void CS_HousekeepingCmd_Test_InvalidMsgLength(void) call_count_CFE_EVS_SendEvent); } +void CS_ProcessCmd_NoopCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_NOOP_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_NoopCmd, 1); +} + +void CS_ProcessCmd_ResetCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RESET_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ResetCmd, 1); +} + +void CS_ProcessCmd_DisableAllCSCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ALL_CS_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableAllCSCmd, 1); +} + +void CS_ProcessCmd_EnableAllCSCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ALL_CS_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableAllCSCmd, 1); +} + +void CS_ProcessCmd_DisableCfeCoreCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_CFE_CORE_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableCfeCoreCmd, 1); +} + +void CS_ProcessCMD_EnableCfeCoreCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_CFE_CORE_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableCfeCoreCmd, 1); +} + +void CS_ProcessCmd_DisableOSCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_OS_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableOSCmd, 1); +} + +void CS_ProcessCmd_EnableOSCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_OS_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableOSCmd, 1); +} + +void CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_CFE_CORE_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineCfeCoreCmd, 1); +} + +void CS_ProcessCmd_ReportBaselineOSCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_OS_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineOSCmd, 1); +} + +void CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_CFE_CORE_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineCfeCoreCmd, 1); +} + +void CS_ProcessCmd_RecomputeBaselineOSCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_OS_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineOSCmd, 1); +} + +void CS_ProcessCmd_OneShotCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ONE_SHOT_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_OneShotCmd, 1); +} + +void CS_ProcessCmd_CancelOneShotCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_CANCEL_ONE_SHOT_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_CancelOneShotCmd, 1); +} + +void CS_ProcessCmd_DisableTablesCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_TABLES_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableTablesCmd, 1); +} + +void CS_ProcessCmd_EnableTablesCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_TABLES_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableTablesCmd, 1); +} + +void CS_ProcessCmd_ReportBaselineTablesCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineTablesCmd, 1); +} + +void CS_ProcessCmd_RecomputeBaselineTablesCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineTablesCmd, 1); +} + +void CS_ProcessCmd_DisableNameTablesCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_NAME_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableNameTablesCmd, 1); +} + +void CS_ProcessCmd_EnableNameTablesCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_NAME_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableNameTablesCmd, 1); +} + +void CS_ProcessCmd_DisableAppCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_APPS_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableAppCmd, 1); +} + +void CS_ProcessCmd_EnableAppCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_APPS_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableAppCmd, 1); +} + +void CS_ProcessCmd_ReportBaselineAppCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_APP_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineAppCmd, 1); +} + +void CS_ProcessCmd_RecomputeBaselineAppCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_APP_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineAppCmd, 1); +} + +void CS_ProcessCmd_DisableNameAppCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_NAME_APP_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableNameAppCmd, 1); +} + +void CS_ProcessCmd_EnableNameAppCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_NAME_APP_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableNameAppCmd, 1); +} + +void CS_ProcessCmd_DisableMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_MEMORY_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableMemoryCmd, 1); +} + +void CS_ProcessCmd_EnableMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_MEMORY_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableMemoryCmd, 1); +} + +void CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_MEMORY_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineEntryIDMemoryCmd, 1); +} + +void CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_MEMORY_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineMemoryCmd, 1); +} + +void CS_ProcessCmd_EnableEntryIDMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ENTRY_MEMORY_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableEntryIDMemoryCmd, 1); +} + +void CS_ProcessCmd_DisableEntryIDMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ENTRY_MEMORY_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableEntryIDMemoryCmd, 1); +} + +void CS_ProcessCmd_GetEntryIDMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_GET_ENTRY_ID_MEMORY_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_GetEntryIDMemoryCmd, 1); +} + +void CS_ProcessCmd_DisableEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_EEPROM_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableEepromCmd, 1); +} + +void CS_ProcessCmd_EnableEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_EEPROM_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableEepromCmd, 1); +} + +void CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_EEPROM_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineEntryIDEepromCmd, 1); +} + +void CS_ProcessCmd_RecomputeBaselineEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_EEPROM_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineEepromCmd, 1); +} + +void CS_ProcessCmd_EnableEntryIDEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ENTRY_EEPROM_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableEntryIDEepromCmd, 1); +} + +void CS_ProcessCmd_DisableEntryIDEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ENTRY_EEPROM_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableEntryIDEepromCmd, 1); +} + +void CS_ProcessCmd_GetEntryIDEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_GET_ENTRY_ID_EEPROM_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(CS_VerifyCmdLength), 1, true); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_GetEntryIDEepromCmd, 1); +} + +void CS_ProcessCmd_NoopCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_NOOP_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_NoopCmd, 0); +} + +void CS_ProcessCmd_ResetCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RESET_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ResetCmd, 0); +} + +void CS_ProcessCmd_DisableAllCSCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ALL_CS_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableAllCSCmd, 0); +} + +void CS_ProcessCmd_EnableAllCSCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ALL_CS_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableAllCSCmd, 0); +} + +void CS_ProcessCmd_DisableCfeCoreCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_CFE_CORE_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableCfeCoreCmd, 0); +} + +void CS_ProcessCMD_EnableCfeCoreCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_CFE_CORE_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableCfeCoreCmd, 0); +} + +void CS_ProcessCmd_DisableOSCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_OS_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableOSCmd, 0); +} + +void CS_ProcessCmd_EnableOSCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_OS_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableOSCmd, 0); +} + +void CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_CFE_CORE_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineCfeCoreCmd, 0); +} + +void CS_ProcessCmd_ReportBaselineOSCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_OS_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineOSCmd, 0); +} + +void CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_CFE_CORE_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineCfeCoreCmd, 0); +} + +void CS_ProcessCmd_RecomputeBaselineOSCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_OS_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineOSCmd, 0); +} + +void CS_ProcessCmd_OneShotCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ONE_SHOT_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_OneShotCmd, 0); +} + +void CS_ProcessCmd_CancelOneShotCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_CANCEL_ONE_SHOT_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_CancelOneShotCmd, 0); +} + +void CS_ProcessCmd_DisableTablesCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_TABLES_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableTablesCmd, 0); +} + +void CS_ProcessCmd_EnableTablesCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_TABLES_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableTablesCmd, 0); +} + +void CS_ProcessCmd_ReportBaselineTablesCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineTablesCmd, 0); +} + +void CS_ProcessCmd_RecomputeBaselineTablesCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineTablesCmd, 0); +} + +void CS_ProcessCmd_DisableNameTablesCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_NAME_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableNameTablesCmd, 0); +} + +void CS_ProcessCmd_EnableNameTablesCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_NAME_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableNameTablesCmd, 0); +} + +void CS_ProcessCmd_DisableAppCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_APPS_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableAppCmd, 0); +} + +void CS_ProcessCmd_EnableAppCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_APPS_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableAppCmd, 0); +} + +void CS_ProcessCmd_ReportBaselineAppCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_APP_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineAppCmd, 0); +} + +void CS_ProcessCmd_RecomputeBaselineAppCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_APP_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineAppCmd, 0); +} + +void CS_ProcessCmd_DisableNameAppCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_NAME_APP_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableNameAppCmd, 0); +} + +void CS_ProcessCmd_EnableNameAppCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_NAME_APP_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableNameAppCmd, 0); +} + +void CS_ProcessCmd_DisableMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_MEMORY_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableMemoryCmd, 0); +} + +void CS_ProcessCmd_EnableMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_MEMORY_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableMemoryCmd, 0); +} + +void CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_MEMORY_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineEntryIDMemoryCmd, 0); +} + +void CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_MEMORY_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineMemoryCmd, 0); +} + +void CS_ProcessCmd_EnableEntryIDMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ENTRY_MEMORY_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableEntryIDMemoryCmd, 0); +} + +void CS_ProcessCmd_DisableEntryIDMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ENTRY_MEMORY_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableEntryIDMemoryCmd, 0); +} + +void CS_ProcessCmd_GetEntryIDMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_GET_ENTRY_ID_MEMORY_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_GetEntryIDMemoryCmd, 0); +} + +void CS_ProcessCmd_DisableEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_EEPROM_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableEepromCmd, 0); +} + +void CS_ProcessCmd_EnableEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_EEPROM_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableEepromCmd, 0); +} + +void CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_EEPROM_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineEntryIDEepromCmd, 0); +} + +void CS_ProcessCmd_RecomputeBaselineEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_EEPROM_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineEepromCmd, 0); +} + +void CS_ProcessCmd_EnableEntryIDEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ENTRY_EEPROM_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableEntryIDEepromCmd, 0); +} + +void CS_ProcessCmd_DisableEntryIDEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ENTRY_EEPROM_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableEntryIDEepromCmd, 0); +} + +void CS_ProcessCmd_GetEntryIDEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_GET_ENTRY_ID_EEPROM_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(CS_VerifyCmdLength), 1, false); + + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_GetEntryIDEepromCmd, 0); +} + #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) void CS_UpdateCDS_Test_Nominal(void) @@ -2434,6 +3799,170 @@ void UtTest_Setup(void) UtTest_Add(CS_AppInit_Test_NominalPowerOnReset, CS_Test_Setup, CS_Test_TearDown, "CS_AppInit_Test_NominalPowerOnReset"); + + UtTest_Add(CS_ProcessCmd_NoopCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_NoopCmd_Test"); + UtTest_Add(CS_ProcessCmd_ResetCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ResetCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableAllCSCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableAllCSCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableAllCSCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableAllCSCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableCfeCoreCmd_Test"); + UtTest_Add(CS_ProcessCMD_EnableCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCMD_EnableCfeCoreCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableOSCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableOSCmd_Test"); + UtTest_Add(CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test"); + UtTest_Add(CS_ProcessCmd_ReportBaselineOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineOSCmd_Test"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineOSCmd_Test"); + UtTest_Add(CS_ProcessCmd_OneShotCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_OneShotCmd_Test"); + UtTest_Add(CS_ProcessCmd_CancelOneShotCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_CancelOneShotCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableTablesCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableTablesCmd_Test"); + UtTest_Add(CS_ProcessCmd_ReportBaselineTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineTablesCmd_Test"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineTablesCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableNameTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableNameTablesCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableNameTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableNameTablesCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableAppCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableAppCmd_Test"); + UtTest_Add(CS_ProcessCmd_ReportBaselineAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineAppCmd_Test"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineAppCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableNameAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableNameAppCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableNameAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableNameAppCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableEntryIDMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableEntryIDMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableEntryIDMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableEntryIDMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_GetEntryIDMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_GetEntryIDMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableEepromCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableEepromCmd_Test"); + UtTest_Add(CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineEepromCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableEntryIDEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableEntryIDEepromCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableEntryIDEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableEntryIDEepromCmd_Test"); + UtTest_Add(CS_ProcessCmd_GetEntryIDEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_GetEntryIDEepromCmd_Test"); + + UtTest_Add(CS_ProcessCmd_NoopCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_NoopCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ResetCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ResetCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableAllCSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableAllCSCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableAllCSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableAllCSCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableCfeCoreCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCMD_EnableCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCMD_EnableCfeCoreCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableOSCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableOSCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ReportBaselineOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineOSCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineOSCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_OneShotCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_OneShotCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_CancelOneShotCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_CancelOneShotCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableTablesCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableTablesCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ReportBaselineTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineTablesCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineTablesCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableNameTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableNameTablesCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableNameTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableNameTablesCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableAppCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableAppCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ReportBaselineAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineAppCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineAppCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableNameAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableNameAppCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableNameAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableNameAppCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableEntryIDMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableEntryIDMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_GetEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_GetEntryIDMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableEepromCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableEepromCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineEepromCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableEntryIDEepromCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableEntryIDEepromCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_GetEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_GetEntryIDEepromCmd_Test_VerifyError"); + + #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) UtTest_Add(CS_AppInit_Test_NominalProcReset, CS_Test_Setup, CS_Test_TearDown, "CS_AppInit_Test_NominalProcReset"); diff --git a/unit-test/cs_cmds_tests.c b/unit-test/cs_cmds_tests.c index 99d3d77..0864d5d 100644 --- a/unit-test/cs_cmds_tests.c +++ b/unit-test/cs_cmds_tests.c @@ -79,22 +79,6 @@ void CS_NoopCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_NoopCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_NoopCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_ResetCmd_Test(void) { CS_NoArgsCmd_t CmdPacket; @@ -142,22 +126,6 @@ void CS_ResetCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_ResetCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ResetCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_BackgroundCheckCycle_Test_InvalidMsgLength(void) { CS_NoArgsCmd_t CmdPacket; @@ -624,22 +592,6 @@ void CS_DisableAllCSCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableAllCSCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_DisableAllCSCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_EnableAllCSCmd_Test(void) { CS_NoArgsCmd_t CmdPacket; @@ -671,22 +623,6 @@ void CS_EnableAllCSCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableAllCSCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_EnableAllCSCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_DisableCfeCoreCmd_Test(void) { CS_NoArgsCmd_t CmdPacket; @@ -719,22 +655,6 @@ void CS_DisableCfeCoreCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableCfeCoreCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_DisableCfeCoreCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_EnableCfeCoreCmd_Test(void) { CS_NoArgsCmd_t CmdPacket; @@ -767,22 +687,6 @@ void CS_EnableCfeCoreCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableCfeCoreCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_EnableCfeCoreCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_DisableOSCmd_Test(void) { CS_NoArgsCmd_t CmdPacket; @@ -815,22 +719,6 @@ void CS_DisableOSCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableOSCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_DisableOSCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_EnableOSCmd_Test(void) { CS_NoArgsCmd_t CmdPacket; @@ -863,22 +751,6 @@ void CS_EnableOSCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableOSCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_EnableOSCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_ReportBaselineCfeCoreCmd_Test_Nominal(void) { CS_NoArgsCmd_t CmdPacket; @@ -942,22 +814,6 @@ void CS_ReportBaselineCfeCoreCmd_Test_NotComputedYet(void) call_count_CFE_EVS_SendEvent); } -void CS_ReportBaselineCfeCoreCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ReportBaselineCfeCoreCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_ReportBaselineOSCmd_Test_Nominal(void) { CS_NoArgsCmd_t CmdPacket; @@ -1022,22 +878,6 @@ void CS_ReportBaselineOSCmd_Test_NotComputedYet(void) call_count_CFE_EVS_SendEvent); } -void CS_ReportBaselineOSCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ReportBaselineOSCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_RecomputeBaselineCfeCoreCmd_Test_Nominal(void) { CS_NoArgsCmd_t CmdPacket; @@ -1149,22 +989,6 @@ void CS_RecomputeBaselineCfeCoreCmd_Test_ChildTaskError(void) call_count_CFE_EVS_SendEvent); } -void CS_RecomputeBaselineCfeCoreCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_RecomputeBaselineCfeCoreCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_RecomputeBaselineCfeCoreCmd_Test_OneShot(void) { CS_NoArgsCmd_t CmdPacket; @@ -1310,22 +1134,6 @@ void CS_RecomputeBaselineOSCmd_Test_ChildTaskError(void) call_count_CFE_EVS_SendEvent); } -void CS_RecomputeBaselineOSCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_RecomputeBaselineOSCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_RecomputeBaselineOSCmd_Test_OneShot(void) { CS_NoArgsCmd_t CmdPacket; @@ -1569,22 +1377,6 @@ void CS_OneShotCmd_Test_MemValidateRangeError(void) call_count_CFE_EVS_SendEvent); } -void CS_OneShotCmd_Test_VerifyError(void) -{ - CS_OneShotCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_OneShotCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_OneShotCmd_Test_OneShot(void) { CS_OneShotCmd_t CmdPacket; @@ -1726,22 +1518,6 @@ void CS_CancelOneShotCmd_Test_NoChildTaskError(void) call_count_CFE_EVS_SendEvent); } -void CS_CancelOneShotCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_CancelOneShotCmd(&CmdPacket); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_CancelOneShotCmd_Test_OneShot(void) { CS_NoArgsCmd_t CmdPacket; @@ -1781,10 +1557,8 @@ void CS_CancelOneShotCmd_Test_OneShot(void) void UtTest_Setup(void) { UtTest_Add(CS_NoopCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_NoopCmd_Test"); - UtTest_Add(CS_NoopCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, "CS_NoopCmd_Test_VerifyError"); UtTest_Add(CS_ResetCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_ResetCmd_Test"); - UtTest_Add(CS_ResetCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, "CS_ResetCmd_Test_VerifyError"); UtTest_Add(CS_BackgroundCheckCycle_Test_InvalidMsgLength, CS_Test_Setup, CS_Test_TearDown, "CS_BackgroundCheckCycle_Test_InvalidMsgLength"); @@ -1812,40 +1586,26 @@ void UtTest_Setup(void) "CS_BackgroundCheckCycle_Test_EndOfList"); UtTest_Add(CS_DisableAllCSCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_DisableAllCSCmd_Test"); - UtTest_Add(CS_DisableAllCSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableAllCSCmd_Test_VerifyError"); UtTest_Add(CS_EnableAllCSCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_EnableAllCSCmd_Test"); - UtTest_Add(CS_EnableAllCSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableAllCSCmd_Test_VerifyError"); UtTest_Add(CS_DisableCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_DisableCfeCoreCmd_Test"); - UtTest_Add(CS_DisableCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableCfeCoreCmd_Test_VerifyError"); - UtTest_Add(CS_EnableCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableCfeCoreCmd_Test_VerifyError"); UtTest_Add(CS_EnableCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_EnableCfeCoreCmd_Test"); UtTest_Add(CS_DisableOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_DisableOSCmd_Test"); - UtTest_Add(CS_DisableOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, "CS_DisableOSCmd_Test_VerifyError"); UtTest_Add(CS_EnableOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_EnableOSCmd_Test"); - UtTest_Add(CS_EnableOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, "CS_EnableOSCmd_Test_VerifyError"); UtTest_Add(CS_ReportBaselineCfeCoreCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_ReportBaselineCfeCoreCmd_Test_Nominal"); UtTest_Add(CS_ReportBaselineCfeCoreCmd_Test_NotComputedYet, CS_Test_Setup, CS_Test_TearDown, "CS_ReportBaselineCfeCoreCmd_Test_NotComputedYet"); - UtTest_Add(CS_ReportBaselineCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ReportBaselineCfeCoreCmd_Test_VerifyError"); UtTest_Add(CS_ReportBaselineOSCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_ReportBaselineOSCmd_Test_Nominal"); UtTest_Add(CS_ReportBaselineOSCmd_Test_NotComputedYet, CS_Test_Setup, CS_Test_TearDown, "CS_ReportBaselineOSCmd_Test_NotComputedYet"); - UtTest_Add(CS_ReportBaselineOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ReportBaselineOSCmd_Test_VerifyError"); UtTest_Add(CS_RecomputeBaselineCfeCoreCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineCfeCoreCmd_Test_Nominal"); @@ -1853,8 +1613,6 @@ void UtTest_Setup(void) "CS_RecomputeBaselineCfeCoreCmd_Test_CreateChildTaskError"); UtTest_Add(CS_RecomputeBaselineCfeCoreCmd_Test_ChildTaskError, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineCfeCoreCmd_Test_ChildTaskError"); - UtTest_Add(CS_RecomputeBaselineCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_RecomputeBaselineCfeCoreCmd_Test_VerifyError"); UtTest_Add(CS_RecomputeBaselineCfeCoreCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineCfeCoreCmd_Test_OneShot"); @@ -1864,8 +1622,6 @@ void UtTest_Setup(void) "CS_RecomputeBaselineOSCmd_Test_CreateChildTaskError"); UtTest_Add(CS_RecomputeBaselineOSCmd_Test_ChildTaskError, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineOSCmd_Test_ChildTaskError"); - UtTest_Add(CS_RecomputeBaselineOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_RecomputeBaselineOSCmd_Test_VerifyError"); UtTest_Add(CS_RecomputeBaselineOSCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineOSCmd_Test_OneShot"); @@ -1877,7 +1633,6 @@ void UtTest_Setup(void) UtTest_Add(CS_OneShotCmd_Test_ChildTaskError, CS_Test_Setup, CS_Test_TearDown, "CS_OneShotCmd_Test_ChildTaskError"); UtTest_Add(CS_OneShotCmd_Test_MemValidateRangeError, CS_Test_Setup, CS_Test_TearDown, "CS_OneShotCmd_Test_MemValidateRangeError"); - UtTest_Add(CS_OneShotCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, "CS_OneShotCmd_Test_VerifyError"); UtTest_Add(CS_OneShotCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_OneShotCmd_Test_OneShot"); UtTest_Add(CS_CancelOneShotCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_CancelOneShotCmd_Test_Nominal"); @@ -1885,7 +1640,5 @@ void UtTest_Setup(void) "CS_CancelOneShotCmd_Test_DeleteChildTaskError"); UtTest_Add(CS_CancelOneShotCmd_Test_NoChildTaskError, CS_Test_Setup, CS_Test_TearDown, "CS_CancelOneShotCmd_Test_NoChildTaskError"); - UtTest_Add(CS_CancelOneShotCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_CancelOneShotCmd_Test_VerifyError"); UtTest_Add(CS_CancelOneShotCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_CancelOneShotCmd_Test_OneShot"); } diff --git a/unit-test/cs_eeprom_cmds_tests.c b/unit-test/cs_eeprom_cmds_tests.c index e3816ce..2e1c7d3 100644 --- a/unit-test/cs_eeprom_cmds_tests.c +++ b/unit-test/cs_eeprom_cmds_tests.c @@ -75,24 +75,6 @@ void CS_DisableEepromCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableEepromCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_DisableEepromCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_DisableEepromCmd_Test_OneShot(void) { CS_NoArgsCmd_t CmdPacket; @@ -144,24 +126,6 @@ void CS_EnableEepromCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableEepromCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_EnableEepromCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_EnableEepromCmd_Test_OneShot(void) { CS_NoArgsCmd_t CmdPacket; @@ -318,24 +282,6 @@ void CS_ReportBaselineEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty(void) call_count_CFE_EVS_SendEvent); } -void CS_ReportBaselineEntryIDEepromCmd_Test_VerifyError(void) -{ - CS_EntryCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ReportBaselineEntryIDEepromCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_RecomputeBaselineEepromCmd_Test_Nominal(void) { CS_EntryCmd_t CmdPacket; @@ -523,24 +469,6 @@ void CS_RecomputeBaselineEepromCmd_Test_RecomputeInProgress(void) call_count_CFE_EVS_SendEvent); } -void CS_RecomputeBaselineEepromCmd_Test_VerifyError(void) -{ - CS_EntryCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_RecomputeBaselineEepromCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_RecomputeBaselineEepromCmd_Test_OneShot(void) { CS_EntryCmd_t CmdPacket; @@ -732,24 +660,6 @@ void CS_EnableEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableEntryIDEepromCmd_Test_VerifyError(void) -{ - CS_EntryCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_EnableEntryIDEepromCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_EnableEntryIDEepromCmd_Test_OneShot(void) { CS_EntryCmd_t CmdPacket; @@ -934,24 +844,6 @@ void CS_DisableEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableEntryIDEepromCmd_Test_VerifyError(void) -{ - CS_EntryCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_DisableEntryIDEepromCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_DisableEntryIDEepromCmd_Test_OneShot(void) { CS_EntryCmd_t CmdPacket; @@ -1110,34 +1002,12 @@ void CS_GetEntryIDEepromCmd_Test_State(void) call_count_CFE_EVS_SendEvent); } -void CS_GetEntryIDEepromCmd_Test_VerifyError(void) -{ - CS_GetEntryIDCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_GetEntryIDEepromCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void UtTest_Setup(void) { UtTest_Add(CS_DisableEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_DisableEepromCmd_Test"); - UtTest_Add(CS_DisableEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableEepromCmd_Test_VerifyError"); UtTest_Add(CS_DisableEepromCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_DisableEepromCmd_Test_OneShot"); UtTest_Add(CS_EnableEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_EnableEepromCmd_Test"); - UtTest_Add(CS_EnableEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableEepromCmd_Test_VerifyError"); UtTest_Add(CS_EnableEepromCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_EnableEepromCmd_Test_OneShot"); UtTest_Add(CS_ReportBaselineEntryIDEepromCmd_Test_Computed, CS_Test_Setup, CS_Test_TearDown, @@ -1148,8 +1018,6 @@ void UtTest_Setup(void) "CS_ReportBaselineEntryIDEepromCmd_Test_InvalidEntryErrorEntryIDTooHigh"); UtTest_Add(CS_ReportBaselineEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty, CS_Test_Setup, CS_Test_TearDown, "CS_ReportBaselineEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty"); - UtTest_Add(CS_ReportBaselineEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ReportBaselineEntryIDEepromCmd_Test_VerifyError"); UtTest_Add(CS_RecomputeBaselineEepromCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineEepromCmd_Test_Nominal"); @@ -1161,8 +1029,6 @@ void UtTest_Setup(void) "CS_RecomputeBaselineEepromCmd_Test_InvalidEntryErrorStateEmpty"); UtTest_Add(CS_RecomputeBaselineEepromCmd_Test_RecomputeInProgress, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineEepromCmd_Test_RecomputeInProgress"); - UtTest_Add(CS_RecomputeBaselineEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_RecomputeBaselineEepromCmd_Test_VerifyError"); UtTest_Add(CS_RecomputeBaselineEepromCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineEepromCmd_Test_OneShot"); @@ -1174,8 +1040,6 @@ void UtTest_Setup(void) "CS_EnableEntryIDEepromCmd_Test_InvalidEntryErrorEntryIDTooHigh"); UtTest_Add(CS_EnableEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty, CS_Test_Setup, CS_Test_TearDown, "CS_EnableEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty"); - UtTest_Add(CS_EnableEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableEntryIDEepromCmd_Test_VerifyError"); UtTest_Add(CS_EnableEntryIDEepromCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_EnableEntryIDEepromCmd_Test_OneShot"); @@ -1187,8 +1051,6 @@ void UtTest_Setup(void) "CS_DisableEntryIDEepromCmd_Test_InvalidEntryErrorEntryIDTooHigh"); UtTest_Add(CS_DisableEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty, CS_Test_Setup, CS_Test_TearDown, "CS_DisableEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty"); - UtTest_Add(CS_DisableEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableEntryIDEepromCmd_Test_VerifyError"); UtTest_Add(CS_DisableEntryIDEepromCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_DisableEntryIDEepromCmd_Test_OneShot"); @@ -1199,6 +1061,4 @@ void UtTest_Setup(void) UtTest_Add(CS_GetEntryIDEepromCmd_Test_AddressPtr, CS_Test_Setup, CS_Test_TearDown, "CS_GetEntryIDEepromCmd_Test_AddressPtr"); UtTest_Add(CS_GetEntryIDEepromCmd_Test_State, CS_Test_Setup, CS_Test_TearDown, "CS_GetEntryIDEepromCmd_Test_State"); - UtTest_Add(CS_GetEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_GetEntryIDEepromCmd_Test_VerifyError"); } diff --git a/unit-test/cs_memory_cmds_tests.c b/unit-test/cs_memory_cmds_tests.c index be6778c..bcda3ff 100644 --- a/unit-test/cs_memory_cmds_tests.c +++ b/unit-test/cs_memory_cmds_tests.c @@ -75,24 +75,6 @@ void CS_DisableMemoryCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableMemoryCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_DisableMemoryCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_DisableMemoryCmd_Test_OneShot(void) { CS_NoArgsCmd_t CmdPacket; @@ -144,24 +126,6 @@ void CS_EnableMemoryCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableMemoryCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_EnableMemoryCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_EnableMemoryCmd_Test_OneShot(void) { CS_NoArgsCmd_t CmdPacket; @@ -318,24 +282,6 @@ void CS_ReportBaselineEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty(void) call_count_CFE_EVS_SendEvent); } -void CS_ReportBaselineEntryIDMemoryCmd_Test_VerifyError(void) -{ - CS_EntryCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ReportBaselineEntryIDMemoryCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_RecomputeBaselineMemoryCmd_Test_Nominal(void) { CS_EntryCmd_t CmdPacket; @@ -523,24 +469,6 @@ void CS_RecomputeBaselineMemoryCmd_Test_RecomputeInProgress(void) call_count_CFE_EVS_SendEvent); } -void CS_RecomputeBaselineMemoryCmd_Test_VerifyError(void) -{ - CS_EntryCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_RecomputeBaselineMemoryCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_RecomputeBaselineMemoryCmd_Test_OneShot(void) { CS_EntryCmd_t CmdPacket; @@ -732,24 +660,6 @@ void CS_EnableEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableEntryIDMemoryCmd_Test_VerifyError(void) -{ - CS_EntryCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_EnableEntryIDMemoryCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_EnableEntryIDMemoryCmd_Test_OneShot(void) { CS_EntryCmd_t CmdPacket; @@ -934,24 +844,6 @@ void CS_DisableEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableEntryIDMemoryCmd_Test_VerifyError(void) -{ - CS_EntryCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_DisableEntryIDMemoryCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_DisableEntryIDMemoryCmd_Test_OneShot(void) { CS_EntryCmd_t CmdPacket; @@ -1110,34 +1002,12 @@ void CS_GetEntryIDMemoryCmd_Test_State(void) call_count_CFE_EVS_SendEvent); } -void CS_GetEntryIDMemoryCmd_Test_VerifyError(void) -{ - CS_GetEntryIDCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_GetEntryIDMemoryCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void UtTest_Setup(void) { UtTest_Add(CS_DisableMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_DisableMemoryCmd_Test"); - UtTest_Add(CS_DisableMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableMemoryCmd_Test_VerifyError"); UtTest_Add(CS_DisableMemoryCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_DisableMemoryCmd_Test_OneShot"); UtTest_Add(CS_EnableMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_EnableMemoryCmd_Test"); - UtTest_Add(CS_EnableMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableMemoryCmd_Test_VerifyError"); UtTest_Add(CS_EnableMemoryCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_EnableMemoryCmd_Test_OneShot"); UtTest_Add(CS_ReportBaselineEntryIDMemoryCmd_Test_Computed, CS_Test_Setup, CS_Test_TearDown, @@ -1148,8 +1018,6 @@ void UtTest_Setup(void) "CS_ReportBaselineEntryIDMemoryCmd_Test_InvalidEntryErrorEntryIDTooHigh"); UtTest_Add(CS_ReportBaselineEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty, CS_Test_Setup, CS_Test_TearDown, "CS_ReportBaselineEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty"); - UtTest_Add(CS_ReportBaselineEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ReportBaselineEntryIDMemoryCmd_Test_VerifyError"); UtTest_Add(CS_RecomputeBaselineMemoryCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineMemoryCmd_Test_Nominal"); @@ -1161,8 +1029,6 @@ void UtTest_Setup(void) "CS_RecomputeBaselineMemoryCmd_Test_InvalidEntryErrorStateEmpty"); UtTest_Add(CS_RecomputeBaselineMemoryCmd_Test_RecomputeInProgress, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineMemoryCmd_Test_RecomputeInProgress"); - UtTest_Add(CS_RecomputeBaselineMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_RecomputeBaselineMemoryCmd_Test_VerifyError"); UtTest_Add(CS_RecomputeBaselineMemoryCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineMemoryCmd_Test_OneShot"); @@ -1174,8 +1040,6 @@ void UtTest_Setup(void) "CS_EnableEntryIDMemoryCmd_Test_InvalidEntryErrorEntryIDTooHigh"); UtTest_Add(CS_EnableEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty, CS_Test_Setup, CS_Test_TearDown, "CS_EnableEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty"); - UtTest_Add(CS_EnableEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableEntryIDMemoryCmd_Test_VerifyError"); UtTest_Add(CS_EnableEntryIDMemoryCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_EnableEntryIDMemoryCmd_Test_OneShots"); @@ -1187,8 +1051,6 @@ void UtTest_Setup(void) "CS_DisableEntryIDMemoryCmd_Test_InvalidEntryErrorEntryIDTooHigh"); UtTest_Add(CS_DisableEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty, CS_Test_Setup, CS_Test_TearDown, "CS_DisableEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty"); - UtTest_Add(CS_DisableEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableEntryIDMemoryCmd_Test_VerifyError"); UtTest_Add(CS_DisableEntryIDMemoryCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_DisableEntryIDMemoryCmd_Test_OneShot"); @@ -1199,6 +1061,4 @@ void UtTest_Setup(void) UtTest_Add(CS_GetEntryIDMemoryCmd_Test_AddressPtr, CS_Test_Setup, CS_Test_TearDown, "CS_GetEntryIDMemoryCmd_Test_AddressPtr"); UtTest_Add(CS_GetEntryIDMemoryCmd_Test_State, CS_Test_Setup, CS_Test_TearDown, "CS_GetEntryIDMemoryCmd_Test_State"); - UtTest_Add(CS_GetEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_GetEntryIDMemoryCmd_Test_VerifyError"); } diff --git a/unit-test/cs_table_cmds_tests.c b/unit-test/cs_table_cmds_tests.c index 62059de..ff334fa 100644 --- a/unit-test/cs_table_cmds_tests.c +++ b/unit-test/cs_table_cmds_tests.c @@ -109,25 +109,6 @@ void CS_DisableTablesCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableTablesCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); - - /* Execute the function being tested */ - CS_DisableTablesCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_DisableTablesCmd_Test_OneShot(void) { CS_NoArgsCmd_t CmdPacket; @@ -180,25 +161,6 @@ void CS_EnableTablesCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableTablesCmd_Test_VerifyError(void) -{ - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); - - /* Execute the function being tested */ - CS_EnableTablesCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_EnableTablesCmd_Test_OneShot(void) { CS_NoArgsCmd_t CmdPacket; @@ -335,24 +297,6 @@ void CS_ReportBaselineTablesCmd_Test_TableNotFound(void) call_count_CFE_EVS_SendEvent); } -void CS_ReportBaselineTablesCmd_Test_VerifyError(void) -{ - CS_TableNameCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ReportBaselineTablesCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_RecomputeBaselineTablesCmd_Test_Nominal(void) { CS_TableNameCmd_t CmdPacket; @@ -514,24 +458,6 @@ void CS_RecomputeBaselineTablesCmd_Test_RecomputeInProgress(void) call_count_CFE_EVS_SendEvent); } -void CS_RecomputeBaselineTablesCmd_Test_VerifyError(void) -{ - CS_TableNameCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_RecomputeBaselineTablesCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_RecomputeBaselineTablesCmd_Test_OneShot(void) { CS_TableNameCmd_t CmdPacket; @@ -707,25 +633,6 @@ void CS_DisableNameTablesCmd_Test_TableNotFound(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableNameTablesCmd_Test_VerifyError(void) -{ - CS_TableNameCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); - - /* Execute the function being tested */ - CS_DisableNameTablesCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_DisableNameTablesCmd_Test_OneShot(void) { CS_TableNameCmd_t CmdPacket; @@ -878,25 +785,6 @@ void CS_EnableNameTablesCmd_Test_TableNotFound(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableNameTablesCmd_Test_VerifyError(void) -{ - CS_TableNameCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); - - /* Execute the function being tested */ - CS_EnableNameTablesCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.CmdCounter == 0, "CS_AppData.HkPacket.CmdCounter == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - void CS_EnableNameTablesCmd_Test_OneShot(void) { CS_TableNameCmd_t CmdPacket; @@ -919,13 +807,9 @@ void CS_EnableNameTablesCmd_Test_OneShot(void) void UtTest_Setup(void) { UtTest_Add(CS_DisableTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_DisableTablesCmd_Test"); - UtTest_Add(CS_DisableTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableTablesCmd_Test_VerifyError"); UtTest_Add(CS_DisableTablesCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_DisableTablesCmd_Test_OneShot"); UtTest_Add(CS_EnableTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_EnableTablesCmd_Test"); - UtTest_Add(CS_EnableTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableTablesCmd_Test_VerifyError"); UtTest_Add(CS_EnableTablesCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_EnableTablesCmd_Test_OneShot"); UtTest_Add(CS_ReportBaselineTablesCmd_Test_Computed, CS_Test_Setup, CS_Test_TearDown, @@ -934,8 +818,6 @@ void UtTest_Setup(void) "CS_ReportBaselineTablesCmd_Test_NotYetComputed"); UtTest_Add(CS_ReportBaselineTablesCmd_Test_TableNotFound, CS_Test_Setup, CS_Test_TearDown, "CS_ReportBaselineTablesCmd_Test_TableNotFound"); - UtTest_Add(CS_ReportBaselineTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ReportBaselineTablesCmd_Test_VerifyError"); UtTest_Add(CS_RecomputeBaselineTablesCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineTablesCmd_Test_Nominal"); @@ -945,8 +827,6 @@ void UtTest_Setup(void) "CS_RecomputeBaselineTablesCmd_Test_TableNotFound"); UtTest_Add(CS_RecomputeBaselineTablesCmd_Test_RecomputeInProgress, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineTablesCmd_Test_RecomputeInProgress"); - UtTest_Add(CS_RecomputeBaselineTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_RecomputeBaselineTablesCmd_Test_VerifyError"); UtTest_Add(CS_RecomputeBaselineTablesCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineTablesCmd_Test_OneShot"); @@ -956,8 +836,6 @@ void UtTest_Setup(void) "CS_DisableNameTablesCmd_Test_TableDefNotFound"); UtTest_Add(CS_DisableNameTablesCmd_Test_TableNotFound, CS_Test_Setup, CS_Test_TearDown, "CS_DisableNameTablesCmd_Test_TableNotFound"); - UtTest_Add(CS_DisableNameTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableNameTablesCmd_Test_VerifyError"); UtTest_Add(CS_DisableNameTablesCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_DisableNameTablesCmd_Test_OneShot"); @@ -967,8 +845,6 @@ void UtTest_Setup(void) "CS_EnableNameTablesCmd_Test_TableDefNotFound"); UtTest_Add(CS_EnableNameTablesCmd_Test_TableNotFound, CS_Test_Setup, CS_Test_TearDown, "CS_EnableNameTablesCmd_Test_TableNotFound"); - UtTest_Add(CS_EnableNameTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableNameTablesCmd_Test_VerifyError"); UtTest_Add(CS_EnableNameTablesCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_EnableNameTablesCmd_Test_OneShot"); }