From 2287530971b560613060c5effe8eaa9e2120a46c Mon Sep 17 00:00:00 2001 From: Avi Weiss Date: Fri, 7 Jun 2024 08:46:33 +0200 Subject: [PATCH] Add test --- fsw/src/hs_cmds.c | 32 +++--- unit-test/hs_cmds_tests.c | 233 +++++++++++++++++++++++++++++++++++++- 2 files changed, 250 insertions(+), 15 deletions(-) diff --git a/fsw/src/hs_cmds.c b/fsw/src/hs_cmds.c index d137eed..d9faab2 100644 --- a/fsw/src/hs_cmds.c +++ b/fsw/src/hs_cmds.c @@ -299,10 +299,13 @@ CFE_Status_t HS_EnableEventMonCmd(const HS_EnableEventMonCmd_t *BufPtr) Status = CFE_SB_SubscribeEx(CFE_SB_ValueToMsgId(CFE_EVS_SHORT_EVENT_MSG_MID), HS_AppData.EventPipe, CFE_SB_DEFAULT_QOS, HS_EVENT_PIPE_DEPTH); - HS_AppData.CurrentEventMonState = HS_STATE_ENABLED; - CFE_EVS_SendEvent(HS_ENABLE_EVENTMON_INF_EID, CFE_EVS_EventType_INFORMATION, "Event Monitoring Enabled"); - - if (Status != CFE_SUCCESS) + if (Status == CFE_SUCCESS) + { + HS_AppData.CurrentEventMonState = HS_STATE_ENABLED; + CFE_EVS_SendEvent(HS_ENABLE_EVENTMON_INF_EID, CFE_EVS_EventType_INFORMATION, + "Event Monitoring Enabled"); + } + else { CFE_EVS_SendEvent(HS_EVENTMON_SHORT_SUB_EID, CFE_EVS_EventType_ERROR, "Event Monitor Enable: Error Subscribing to short-format Events,RC=0x%08X", @@ -341,7 +344,7 @@ CFE_Status_t HS_DisableEventMonCmd(const HS_DisableEventMonCmd_t *BufPtr) if (HS_AppData.CurrentEventMonState == HS_STATE_DISABLED) { CFE_EVS_SendEvent(HS_DISABLE_EVENTMON_INF_EID, CFE_EVS_EventType_INFORMATION, - "Event Monitoring is *already* Dnabled"); + "Event Monitoring is *already* Disabled"); } else { @@ -351,10 +354,13 @@ CFE_Status_t HS_DisableEventMonCmd(const HS_DisableEventMonCmd_t *BufPtr) { Status = CFE_SB_Unsubscribe(CFE_SB_ValueToMsgId(CFE_EVS_SHORT_EVENT_MSG_MID), HS_AppData.EventPipe); - HS_AppData.CurrentEventMonState = HS_STATE_DISABLED; - CFE_EVS_SendEvent(HS_DISABLE_EVENTMON_INF_EID, CFE_EVS_EventType_INFORMATION, "Event Monitoring Disabled"); - - if (Status != CFE_SUCCESS) + if (Status == CFE_SUCCESS) + { + HS_AppData.CurrentEventMonState = HS_STATE_DISABLED; + CFE_EVS_SendEvent(HS_DISABLE_EVENTMON_INF_EID, CFE_EVS_EventType_INFORMATION, + "Event Monitoring Disabled"); + } + else { CFE_EVS_SendEvent(HS_EVENTMON_SHORT_UNSUB_EID, CFE_EVS_EventType_ERROR, "Event Monitor Disable: Error Unsubscribing from short-format Events,RC=0x%08X", @@ -393,7 +399,7 @@ CFE_Status_t HS_EnableAlivenessCmd(const HS_EnableAlivenessCmd_t *BufPtr) if (HS_AppData.CurrentAlivenessState == HS_STATE_ENABLED) { CFE_EVS_SendEvent(HS_ENABLE_ALIVENESS_INF_EID, CFE_EVS_EventType_INFORMATION, - "Aliveness Indicator *already* Enabled"); + "Aliveness Indicator is *already* Enabled"); } else { @@ -416,7 +422,7 @@ CFE_Status_t HS_DisableAlivenessCmd(const HS_DisableAlivenessCmd_t *BufPtr) if (HS_AppData.CurrentAlivenessState == HS_STATE_DISABLED) { CFE_EVS_SendEvent(HS_DISABLE_ALIVENESS_INF_EID, CFE_EVS_EventType_INFORMATION, - "Aliveness Indicator *already* Disabled"); + "Aliveness Indicator is *already* Disabled"); } else { @@ -439,7 +445,7 @@ CFE_Status_t HS_EnableCpuHogCmd(const HS_EnableCpuHogCmd_t *BufPtr) if (HS_AppData.CurrentCPUHogState == HS_STATE_ENABLED) { CFE_EVS_SendEvent(HS_ENABLE_CPUHOG_INF_EID, CFE_EVS_EventType_INFORMATION, - "CPU Hogging Indicator *already* Enabled"); + "CPU Hogging Indicator is *already* Enabled"); } else { @@ -462,7 +468,7 @@ CFE_Status_t HS_DisableCpuHogCmd(const HS_DisableCpuHogCmd_t *BufPtr) if (HS_AppData.CurrentCPUHogState == HS_STATE_DISABLED) { CFE_EVS_SendEvent(HS_DISABLE_CPUHOG_INF_EID, CFE_EVS_EventType_INFORMATION, - "CPU Hogging Indicator *already* Disabled"); + "CPU Hogging Indicator is *already* Disabled"); } else { diff --git a/unit-test/hs_cmds_tests.c b/unit-test/hs_cmds_tests.c index 4b38d5d..a288a60 100644 --- a/unit-test/hs_cmds_tests.c +++ b/unit-test/hs_cmds_tests.c @@ -1084,6 +1084,9 @@ void HS_EnableAppMonCmd_Test(void) HS_AppData.AMTablePtr = AMTable; + /* Set to Disabled so the function can freshly set it to Enabled (without it already being set that way) */ + HS_AppData.CurrentAppMonState = HS_STATE_DISABLED; + /* Execute the function being tested */ HS_EnableAppMonCmd(&UT_CmdBuf.EnableAppMonCmd); @@ -1127,6 +1130,9 @@ void HS_EnableAppMonCmd_Test_AlreadyEnabled(void) HS_AppData.AMTablePtr = AMTable; + /* Set to Enabled to test response when already in the commanded state. */ + HS_AppData.CurrentAppMonState = HS_STATE_ENABLED; + /* Execute the function being tested */ HS_EnableAppMonCmd(&UT_CmdBuf.EnableAppMonCmd); @@ -1165,6 +1171,51 @@ void HS_DisableAppMonCmd_Test(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); + /* Set to Enabled so the function can freshly set it to Disabled (without it already being set that way) */ + HS_AppData.CurrentAppMonState = HS_STATE_ENABLED; + + /* Execute the function being tested */ + HS_DisableAppMonCmd(&UT_CmdBuf.DisableAppMonCmd); + + /* Verify results */ + UtAssert_True(HS_AppData.CmdCount == 1, "HS_AppData.CmdCount == 1"); + + UtAssert_True(HS_AppData.CurrentAppMonState == HS_STATE_DISABLED, + "HS_AppData.CurrentAppMonState == HS_STATE_DISABLED"); + + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, HS_DISABLE_APPMON_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); + + strCmpResult = + strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); + + UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", + call_count_CFE_EVS_SendEvent); +} + +void HS_DisableAppMonCmd_Test_AlreadyDisabled(void) +{ + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, + "Application Monitoring is *already* Disabled"); + + TestMsgId = CFE_SB_ValueToMsgId(HS_CMD_MID); + FcnCode = HS_DISABLE_APP_MON_CC; + MsgSize = sizeof(UT_CmdBuf.DisableAppMonCmd); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); + + /* Set to Disabled to test response when already in the commanded state. */ + HS_AppData.CurrentAppMonState = HS_STATE_DISABLED; + /* Execute the function being tested */ HS_DisableAppMonCmd(&UT_CmdBuf.DisableAppMonCmd); @@ -1234,7 +1285,7 @@ void HS_EnableEventMonCmd_Test_AlreadyEnabled(void) size_t MsgSize; int32 strCmpResult; char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Event Monitoring Enabled"); + snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Event Monitoring is *already* Enabled"); TestMsgId = CFE_SB_ValueToMsgId(HS_CMD_MID); FcnCode = HS_ENABLE_EVENT_MON_CC; @@ -1400,7 +1451,7 @@ void HS_DisableEventMonCmd_Test_AlreadyDisabled(void) size_t MsgSize; int32 strCmpResult; char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Event Monitoring Disabled"); + snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Event Monitoring is *already* Disabled"); TestMsgId = CFE_SB_ValueToMsgId(HS_CMD_MID); FcnCode = HS_DISABLE_EVENT_MON_CC; @@ -1559,6 +1610,46 @@ void HS_EnableAlivenessCmd_Test(void) call_count_CFE_EVS_SendEvent); } +void HS_EnableAlivenessCmd_Test_AlreadyEnabled(void) +{ + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Aliveness Indicator is *already* Enabled"); + + TestMsgId = CFE_SB_ValueToMsgId(HS_CMD_MID); + FcnCode = HS_ENABLE_ALIVENESS_CC; + MsgSize = sizeof(UT_CmdBuf.EnableAlivenessCmd); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); + + HS_AppData.CurrentAlivenessState = HS_STATE_ENABLED; + + /* Execute the function being tested */ + HS_EnableAlivenessCmd(&UT_CmdBuf.EnableAlivenessCmd); + + /* Verify results */ + UtAssert_True(HS_AppData.CmdCount == 1, "HS_AppData.CmdCount == 1"); + + UtAssert_True(HS_AppData.CurrentAlivenessState == HS_STATE_ENABLED, + "HS_AppData.CurrentAlivenessState == HS_STATE_ENABLED"); + + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, HS_ENABLE_ALIVENESS_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); + + strCmpResult = + strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); + + UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", + call_count_CFE_EVS_SendEvent); +} + void HS_DisableAlivenessCmd_Test(void) { CFE_SB_MsgId_t TestMsgId; @@ -1599,6 +1690,46 @@ void HS_DisableAlivenessCmd_Test(void) call_count_CFE_EVS_SendEvent); } +void HS_DisableAlivenessCmd_Test_AlreadyDisabled(void) +{ + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Aliveness Indicator is *already* Disabled"); + + TestMsgId = CFE_SB_ValueToMsgId(HS_CMD_MID); + FcnCode = HS_DISABLE_ALIVENESS_CC; + MsgSize = sizeof(UT_CmdBuf.DisableAlivenessCmd); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); + + HS_AppData.CurrentAlivenessState = HS_STATE_DISABLED; + + /* Execute the function being tested */ + HS_DisableAlivenessCmd(&UT_CmdBuf.DisableAlivenessCmd); + + /* Verify results */ + UtAssert_True(HS_AppData.CmdCount == 1, "HS_AppData.CmdCount == 1"); + + UtAssert_True(HS_AppData.CurrentAlivenessState == HS_STATE_DISABLED, + "HS_AppData.CurrentAlivenessState == HS_STATE_DISABLED"); + + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, HS_DISABLE_ALIVENESS_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); + + strCmpResult = + strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); + + UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", + call_count_CFE_EVS_SendEvent); +} + void HS_EnableCpuHogCmd_Test(void) { CFE_SB_MsgId_t TestMsgId; @@ -1639,6 +1770,46 @@ void HS_EnableCpuHogCmd_Test(void) call_count_CFE_EVS_SendEvent); } +void HS_EnableCpuHogCmd_Test_AlreadyEnabled(void) +{ + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "CPU Hogging Indicator is *already* Enabled"); + + TestMsgId = CFE_SB_ValueToMsgId(HS_CMD_MID); + FcnCode = HS_ENABLE_CPU_HOG_CC; + MsgSize = sizeof(UT_CmdBuf.EnableCpuHogCmd); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); + + HS_AppData.CurrentCPUHogState = HS_STATE_ENABLED; + + /* Execute the function being tested */ + HS_EnableCpuHogCmd(&UT_CmdBuf.EnableCpuHogCmd); + + /* Verify results */ + UtAssert_True(HS_AppData.CmdCount == 1, "HS_AppData.CmdCount == 1"); + + UtAssert_True(HS_AppData.CurrentCPUHogState == HS_STATE_ENABLED, + "HS_AppData.CurrentCPUHogState == HS_STATE_ENABLED"); + + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, HS_ENABLE_CPUHOG_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); + + strCmpResult = + strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); + + UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", + call_count_CFE_EVS_SendEvent); +} + void HS_DisableCpuHogCmd_Test(void) { CFE_SB_MsgId_t TestMsgId; @@ -1679,6 +1850,46 @@ void HS_DisableCpuHogCmd_Test(void) call_count_CFE_EVS_SendEvent); } +void HS_DisableCpuHogCmd_Test_AlreadyDisabled(void) +{ + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "CPU Hogging Indicator is *already* Disabled"); + + TestMsgId = CFE_SB_ValueToMsgId(HS_CMD_MID); + FcnCode = HS_DISABLE_CPU_HOG_CC; + MsgSize = sizeof(UT_CmdBuf.DisableCpuHogCmd); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); + + HS_AppData.CurrentCPUHogState = HS_STATE_DISABLED; + + /* Execute the function being tested */ + HS_DisableCpuHogCmd(&UT_CmdBuf.DisableCpuHogCmd); + + /* Verify results */ + UtAssert_True(HS_AppData.CmdCount == 1, "HS_AppData.CmdCount == 1"); + + UtAssert_True(HS_AppData.CurrentCPUHogState == HS_STATE_DISABLED, + "HS_AppData.CurrentCPUHogState == HS_STATE_DISABLED"); + + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, HS_DISABLE_CPUHOG_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); + + strCmpResult = + strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); + + UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", + call_count_CFE_EVS_SendEvent); +} + void HS_ResetResetsPerformedCmd_Test(void) { CFE_SB_MsgId_t TestMsgId; @@ -2356,8 +2567,14 @@ void UtTest_Setup(void) UtTest_Add(HS_EnableAppMonCmd_Test, HS_Test_Setup, HS_Test_TearDown, "HS_EnableAppMonCmd_Test"); + UtTest_Add(HS_EnableAppMonCmd_Test_AlreadyEnabled, HS_Test_Setup, HS_Test_TearDown, + "HS_EnableAppMonCmd_Test_AlreadyEnabled"); + UtTest_Add(HS_DisableAppMonCmd_Test, HS_Test_Setup, HS_Test_TearDown, "HS_DisableAppMonCmd_Test"); + UtTest_Add(HS_DisableAppMonCmd_Test_AlreadyDisabled, HS_Test_Setup, HS_Test_TearDown, + "HS_DisableAppMonCmd_Test_AlreadyDisabled"); + UtTest_Add(HS_EnableEventMonCmd_Test_Disabled, HS_Test_Setup, HS_Test_TearDown, "HS_EnableEventMonCmd_Test_Disabled"); @@ -2379,12 +2596,24 @@ void UtTest_Setup(void) UtTest_Add(HS_EnableAlivenessCmd_Test, HS_Test_Setup, HS_Test_TearDown, "HS_EnableAlivenessCmd_Test"); + UtTest_Add(HS_EnableAlivenessCmd_Test_AlreadyEnabled, HS_Test_Setup, HS_Test_TearDown, + "HS_EnableAlivenessCmd_Test_AlreadyEnabled"); + UtTest_Add(HS_DisableAlivenessCmd_Test, HS_Test_Setup, HS_Test_TearDown, "HS_DisableAlivenessCmd_Test"); + UtTest_Add(HS_DisableAlivenessCmd_Test_AlreadyDisabled, HS_Test_Setup, HS_Test_TearDown, + "HS_DisableAlivenessCmd_Test_AlreadyDisabled"); + UtTest_Add(HS_EnableCpuHogCmd_Test, HS_Test_Setup, HS_Test_TearDown, "HS_EnableCpuHogCmd_Test"); + UtTest_Add(HS_EnableCpuHogCmd_Test_AlreadyEnabled, HS_Test_Setup, HS_Test_TearDown, + "HS_EnableCpuHogCmd_Test_AlreadyEnabled"); + UtTest_Add(HS_DisableCpuHogCmd_Test, HS_Test_Setup, HS_Test_TearDown, "HS_DisableCpuHogCmd_Test"); + UtTest_Add(HS_DisableCpuHogCmd_Test_AlreadyDisabled, HS_Test_Setup, HS_Test_TearDown, + "HS_DisableCpuHogCmd_Test_AlreadyDisabled"); + UtTest_Add(HS_ResetResetsPerformedCmd_Test, HS_Test_Setup, HS_Test_TearDown, "HS_ResetResetsPerformedCmd_Test"); UtTest_Add(HS_SetMaxResetsCmd_Test, HS_Test_Setup, HS_Test_TearDown, "HS_SetMaxResetsCmd_Test");