From a563e13332a1c1041687360877a2599b45943a2b Mon Sep 17 00:00:00 2001 From: Joseph Hickey Date: Tue, 22 Jun 2021 09:04:35 -0400 Subject: [PATCH] Partial #596, UtAssert macros for SB test Update SB coverage test to use preferred macros. Adds a dedicated assert macro for checking SB MsgId values. --- .../core_private/ut-stubs/inc/ut_support.h | 17 + modules/sb/ut-coverage/sb_UT.c | 307 +++++++++--------- 2 files changed, 172 insertions(+), 152 deletions(-) diff --git a/modules/core_private/ut-stubs/inc/ut_support.h b/modules/core_private/ut-stubs/inc/ut_support.h index b14ca27f7..1aa67edc3 100644 --- a/modules/core_private/ut-stubs/inc/ut_support.h +++ b/modules/core_private/ut-stubs/inc/ut_support.h @@ -978,6 +978,23 @@ bool CFE_UtAssert_GenericSignedCompare_Impl(int32 ActualValue, CFE_UtAssert_Comp CFE_UtAssert_GenericUnsignedCompare_Impl(off1, CFE_UtAssert_Compare_EQ, off2, __FILE__, __LINE__, \ "Offset Check: ", #off1, #off2) +/*****************************************************************************/ +/** +** \brief Macro to check CFE message ID for equality +** +** \par Description +** A macro that checks two message ID values for equality. +** +** \par Assumptions, External Events, and Notes: +** The generic #UtAssert_UINT32_EQ check should not be used, as CFE_SB_MsgId_t values +** and integers may not be interchangable with strict type checking. +** +******************************************************************************/ +#define CFE_UtAssert_MSGID_EQ(mid1, mid2) \ + CFE_UtAssert_GenericUnsignedCompare_Impl(CFE_SB_MsgIdToValue(mid1), CFE_UtAssert_Compare_EQ, \ + CFE_SB_MsgIdToValue(mid2), __FILE__, __LINE__, "MsgId Check: ", #mid1, \ + #mid2) + /*****************************************************************************/ /** ** \brief Macro to check string buffers for equality diff --git a/modules/sb/ut-coverage/sb_UT.c b/modules/sb/ut-coverage/sb_UT.c index 9a325b62e..bd2d498d0 100644 --- a/modules/sb/ut-coverage/sb_UT.c +++ b/modules/sb/ut-coverage/sb_UT.c @@ -201,7 +201,7 @@ void Test_SB_AppInit_EVSRegFail(void) int32 ForcedRtnVal = -1; UT_SetDeferredRetcode(UT_KEY(CFE_EVS_Register), 1, ForcedRtnVal); - CFE_UtAssert_EQUAL(CFE_SB_AppInit(), ForcedRtnVal); + UtAssert_INT32_EQ(CFE_SB_AppInit(), ForcedRtnVal); CFE_UtAssert_EVENTCOUNT(0); @@ -228,7 +228,7 @@ void Test_SB_AppInit_EVSSendEvtFail(void) * (The others use SendEventWithAppID which is a different counter). */ UT_SetDeferredRetcode(UT_KEY(CFE_EVS_SendEvent), 1, ForcedRtnVal); - CFE_UtAssert_EQUAL(CFE_SB_AppInit(), ForcedRtnVal); + UtAssert_INT32_EQ(CFE_SB_AppInit(), ForcedRtnVal); CFE_UtAssert_EVENTCOUNT(4); @@ -245,7 +245,7 @@ void Test_SB_AppInit_CrPipeFail(void) * type of error code. */ UT_SetDeferredRetcode(UT_KEY(OS_QueueCreate), 1, OS_ERROR); - CFE_UtAssert_EQUAL(CFE_SB_AppInit(), CFE_SB_PIPE_CR_ERR); + UtAssert_INT32_EQ(CFE_SB_AppInit(), CFE_SB_PIPE_CR_ERR); CFE_UtAssert_EVENTCOUNT(1); @@ -259,7 +259,7 @@ void Test_SB_AppInit_CrPipeFail(void) void Test_SB_AppInit_Sub1Fail(void) { UT_SetDeferredRetcode(UT_KEY(CFE_ES_GetPoolBuf), 1, -1); - CFE_UtAssert_EQUAL(CFE_SB_AppInit(), CFE_SB_BUF_ALOC_ERR); + UtAssert_INT32_EQ(CFE_SB_AppInit(), CFE_SB_BUF_ALOC_ERR); CFE_UtAssert_EVENTCOUNT(3); @@ -275,7 +275,7 @@ void Test_SB_AppInit_Sub1Fail(void) void Test_SB_AppInit_Sub2Fail(void) { UT_SetDeferredRetcode(UT_KEY(CFE_ES_GetPoolBuf), 2, -1); - CFE_UtAssert_EQUAL(CFE_SB_AppInit(), CFE_SB_BUF_ALOC_ERR); + UtAssert_INT32_EQ(CFE_SB_AppInit(), CFE_SB_BUF_ALOC_ERR); CFE_UtAssert_EVENTCOUNT(4); @@ -294,7 +294,7 @@ void Test_SB_AppInit_GetPoolFail(void) UT_SetDeferredRetcode(UT_KEY(CFE_ES_GetPoolBuf), 4, ForcedRtnVal); - CFE_UtAssert_EQUAL(CFE_SB_AppInit(), ForcedRtnVal); + UtAssert_INT32_EQ(CFE_SB_AppInit(), ForcedRtnVal); CFE_UtAssert_EVENTCOUNT(4); @@ -311,7 +311,7 @@ void Test_SB_AppInit_PutPoolFail(void) UT_SetDeferredRetcode(UT_KEY(CFE_ES_PutPoolBuf), 1, ForcedRtnVal); - CFE_UtAssert_EQUAL(CFE_SB_AppInit(), ForcedRtnVal); + UtAssert_INT32_EQ(CFE_SB_AppInit(), ForcedRtnVal); CFE_UtAssert_EVENTCOUNT(4); @@ -592,7 +592,7 @@ void Test_SB_Cmds_RoutingInfoDataGetter(void) LocalBuffer = NULL; LocalBufSize = 0; - CFE_UtAssert_TRUE(!CFE_SB_WriteRouteInfoDataGetter(&State, 0, &LocalBuffer, &LocalBufSize)); + CFE_UtAssert_FALSE(CFE_SB_WriteRouteInfoDataGetter(&State, 0, &LocalBuffer, &LocalBufSize)); UtAssert_NOT_NULL(LocalBuffer); UtAssert_NONZERO(LocalBufSize); @@ -705,10 +705,10 @@ void Test_SB_Cmds_PipeInfoDataGetter(void) LocalBufSize = 0; /* Note that CFE_SB_CreatePipe() fills entry 1 first, so entry 0 is unused */ - CFE_UtAssert_TRUE(!CFE_SB_WritePipeInfoDataGetter(&State, 0, &LocalBuffer, &LocalBufSize)); + CFE_UtAssert_FALSE(CFE_SB_WritePipeInfoDataGetter(&State, 0, &LocalBuffer, &LocalBufSize)); UtAssert_ZERO(LocalBufSize); - CFE_UtAssert_TRUE(!CFE_SB_WritePipeInfoDataGetter(&State, 1, &LocalBuffer, &LocalBufSize)); + CFE_UtAssert_FALSE(CFE_SB_WritePipeInfoDataGetter(&State, 1, &LocalBuffer, &LocalBufSize)); UtAssert_NOT_NULL(LocalBuffer); UtAssert_NONZERO(LocalBufSize); @@ -789,7 +789,7 @@ void Test_SB_Cmds_MapInfoDataGetter(void) LocalBuffer = NULL; LocalBufSize = 0; - CFE_UtAssert_TRUE(!CFE_SB_WriteMsgMapInfoDataGetter(&State, 0, &LocalBuffer, &LocalBufSize)); + CFE_UtAssert_FALSE(CFE_SB_WriteMsgMapInfoDataGetter(&State, 0, &LocalBuffer, &LocalBufSize)); UtAssert_NOT_NULL(LocalBuffer); UtAssert_NONZERO(LocalBufSize); @@ -1335,7 +1335,7 @@ void Test_SB_Cmds_SendPrevSubs(void) /* Event count is only exact if there were no collisions */ if (UT_EventIsInHistory(CFE_SB_HASHCOLLISION_EID)) { - CFE_UtAssert_TRUE(UT_GetNumEventsSent() > NumEvts); + CFE_UtAssert_ATLEAST(UT_GetNumEventsSent(), NumEvts + 1); } else { @@ -1377,7 +1377,7 @@ void Test_SB_Cmds_SendPrevSubs(void) /* Event count is only exact if there were no collisions */ if (UT_EventIsInHistory(CFE_SB_HASHCOLLISION_EID)) { - CFE_UtAssert_TRUE(UT_GetNumEventsSent() > NumEvts); + CFE_UtAssert_ATLEAST(UT_GetNumEventsSent(), NumEvts + 1); } else { @@ -1521,8 +1521,7 @@ void Test_SB_EarlyInit(void) void Test_SB_EarlyInit_SemCreateError(void) { UT_SetDeferredRetcode(UT_KEY(OS_MutSemCreate), 1, OS_ERR_NO_FREE_IDS); - UT_Report(__FILE__, __LINE__, CFE_SB_EarlyInit() == OS_ERR_NO_FREE_IDS, "CFE_SB_EarlyInit", - "Sem Create error logic"); + UtAssert_INT32_EQ(CFE_SB_EarlyInit(), OS_ERR_NO_FREE_IDS); } /* end Test_SB_EarlyInit_SemCreateError */ /* @@ -1531,8 +1530,7 @@ void Test_SB_EarlyInit_SemCreateError(void) void Test_SB_EarlyInit_PoolCreateError(void) { UT_SetDeferredRetcode(UT_KEY(CFE_ES_PoolCreateEx), 1, CFE_ES_BAD_ARGUMENT); - UT_Report(__FILE__, __LINE__, CFE_SB_EarlyInit() == CFE_ES_BAD_ARGUMENT, "CFE_SB_EarlyInit", - "PoolCreateEx error logic"); + UtAssert_INT32_EQ(CFE_SB_EarlyInit(), CFE_ES_BAD_ARGUMENT); } /* end Test_SB_EarlyInit_PoolCreateError */ /* @@ -1541,7 +1539,7 @@ void Test_SB_EarlyInit_PoolCreateError(void) void Test_SB_EarlyInit_NoErrors(void) { CFE_SB_EarlyInit(); - UT_Report(__FILE__, __LINE__, CFE_SB_EarlyInit() == CFE_SUCCESS, "CFE_SB_EarlyInit", "No errors test"); + CFE_UtAssert_SUCCESS(CFE_SB_EarlyInit()); } /* end Test_SB_EarlyInit_NoErrors */ /* @@ -1567,7 +1565,7 @@ void Test_CreatePipe_NullPtr(void) UT_SetDeferredRetcode(UT_KEY(CFE_ES_GetTaskInfo), 1, CFE_ES_ERR_RESOURCEID_NOT_VALID); UT_SetDeferredRetcode(UT_KEY(OS_QueueCreate), 1, OS_SUCCESS); /* Avoids creating socket */ - CFE_UtAssert_EQUAL(CFE_SB_CreatePipe(NULL, PipeDepth, "TestPipe"), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_CreatePipe(NULL, PipeDepth, "TestPipe"), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(1); @@ -1602,12 +1600,12 @@ void Test_CreatePipe_InvalPipeDepth(void) CFE_SB_PipeId_t PipeIdReturned[3]; UT_SetDeferredRetcode(UT_KEY(OS_QueueCreate), 1, OS_SUCCESS); /* Avoid creating socket */ - CFE_UtAssert_EQUAL(CFE_SB_CreatePipe(&PipeIdReturned[0], 0, "TestPipe1"), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_CreatePipe(&PipeIdReturned[0], 0, "TestPipe1"), CFE_SB_BAD_ARGUMENT); UT_SetDeferredRetcode(UT_KEY(OS_QueueCreate), 1, OS_SUCCESS); - CFE_UtAssert_EQUAL(CFE_SB_CreatePipe(&PipeIdReturned[1], OS_QUEUE_MAX_DEPTH + 1, "TestPipeMaxDepPlus1"), - CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_CreatePipe(&PipeIdReturned[1], OS_QUEUE_MAX_DEPTH + 1, "TestPipeMaxDepPlus1"), + CFE_SB_BAD_ARGUMENT); UT_SetDeferredRetcode(UT_KEY(OS_QueueCreate), 1, OS_SUCCESS); - CFE_UtAssert_EQUAL(CFE_SB_CreatePipe(&PipeIdReturned[2], 0xffff, "TestPipeffff"), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_CreatePipe(&PipeIdReturned[2], 0xffff, "TestPipeffff"), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(3); @@ -1639,7 +1637,7 @@ void Test_CreatePipe_MaxPipes(void) } else { - CFE_UtAssert_EQUAL(CFE_SB_CreatePipe(&PipeIdReturned[i], PipeDepth, PipeName), CFE_SB_MAX_PIPES_MET); + UtAssert_INT32_EQ(CFE_SB_CreatePipe(&PipeIdReturned[i], PipeDepth, PipeName), CFE_SB_MAX_PIPES_MET); } } @@ -1658,7 +1656,7 @@ void Test_CreatePipe_MaxPipes(void) CFE_SB_Global.PipeTbl[1].PipeId = CFE_SB_PIPEID_C(UT_SB_MakePipeIdForIndex(1)); CFE_SB_Global.PipeTbl[2].PipeId = CFE_SB_INVALID_PIPE; CFE_UtAssert_TRUE(CFE_SB_CheckPipeDescSlotUsed(UT_SB_MakePipeIdForIndex(1))); - CFE_UtAssert_TRUE(!CFE_SB_CheckPipeDescSlotUsed(UT_SB_MakePipeIdForIndex(2))); + CFE_UtAssert_FALSE(CFE_SB_CheckPipeDescSlotUsed(UT_SB_MakePipeIdForIndex(2))); } /* end Test_CreatePipe_MaxPipes */ @@ -1682,9 +1680,9 @@ void Test_CreatePipe_SamePipeName(void) FirstPipeId = PipeId; /* Second call to CFE_SB_CreatePipe with same PipeName should fail */ - CFE_UtAssert_EQUAL(CFE_SB_CreatePipe(&PipeId, PipeDepth, PipeName), CFE_SB_PIPE_CR_ERR); + UtAssert_INT32_EQ(CFE_SB_CreatePipe(&PipeId, PipeDepth, PipeName), CFE_SB_PIPE_CR_ERR); - CFE_UtAssert_TRUE(CFE_RESOURCEID_TEST_EQUAL(PipeId, FirstPipeId)); + CFE_UtAssert_RESOURCEID_EQ(PipeId, FirstPipeId); CFE_UtAssert_EVENTCOUNT(2); @@ -1757,7 +1755,7 @@ void Test_DeletePipe_InvalidPipeId(void) { CFE_SB_PipeId_t PipeId = SB_UT_ALTERNATE_INVALID_PIPEID; - CFE_UtAssert_EQUAL(CFE_SB_DeletePipe(PipeId), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_DeletePipe(PipeId), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(1); @@ -1783,7 +1781,7 @@ void Test_DeletePipe_InvalidPipeOwner(void) /* Choose a value that is sure not to be owner */ PipeDscPtr->AppId = UT_SB_AppID_Modify(RealOwner, 1); - CFE_UtAssert_EQUAL(CFE_SB_DeletePipe(PipedId), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_DeletePipe(PipedId), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(2); @@ -1848,7 +1846,7 @@ void Test_GetPipeName_NullPtr(void) CFE_SB_PipeId_t PipeId; CFE_UtAssert_SETUP(CFE_SB_CreatePipe(&PipeId, 4, "TestPipe")); - CFE_UtAssert_EQUAL(CFE_SB_GetPipeName(NULL, OS_MAX_API_NAME, PipeId), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_GetPipeName(NULL, OS_MAX_API_NAME, PipeId), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTSENT(CFE_SB_GETPIPENAME_NULL_PTR_EID); @@ -1867,7 +1865,7 @@ void Test_GetPipeName_InvalidId(void) CFE_UtAssert_SETUP(CFE_SB_CreatePipe(&PipeId, 4, "TestPipe")); UT_SetDeferredRetcode(UT_KEY(OS_GetResourceName), 1, OS_ERROR); - CFE_UtAssert_EQUAL(CFE_SB_GetPipeName(PipeName, sizeof(PipeName), PipeId), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_GetPipeName(PipeName, sizeof(PipeName), PipeId), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTSENT(CFE_SB_GETPIPENAME_ID_ERR_EID); @@ -1914,11 +1912,11 @@ void Test_GetPipeIdByName_NullPtrs(void) { CFE_SB_PipeId_t PipeIDOut; - CFE_UtAssert_EQUAL(CFE_SB_GetPipeIdByName(&PipeIDOut, NULL), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_GetPipeIdByName(&PipeIDOut, NULL), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTSENT(CFE_SB_GETPIPEIDBYNAME_NULL_ERR_EID); - CFE_UtAssert_EQUAL(CFE_SB_GetPipeIdByName(NULL, "invalid"), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_GetPipeIdByName(NULL, "invalid"), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTSENT(CFE_SB_GETPIPEIDBYNAME_NULL_ERR_EID); @@ -1932,7 +1930,7 @@ void Test_GetPipeIdByName_InvalidName(void) CFE_SB_PipeId_t PipeIdOut; UT_SetDeferredRetcode(UT_KEY(OS_QueueGetIdByName), 1, OS_ERR_NAME_NOT_FOUND); - CFE_UtAssert_EQUAL(CFE_SB_GetPipeIdByName(&PipeIdOut, "invalid"), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_GetPipeIdByName(&PipeIdOut, "invalid"), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTSENT(CFE_SB_GETPIPEIDBYNAME_NAME_ERR_EID); @@ -1964,7 +1962,7 @@ void Test_GetPipeIdByName(void) */ void Test_SetPipeOpts_BadID(void) { - CFE_UtAssert_EQUAL(CFE_SB_SetPipeOpts(SB_UT_ALTERNATE_INVALID_PIPEID, 0), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_SetPipeOpts(SB_UT_ALTERNATE_INVALID_PIPEID, 0), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTSENT(CFE_SB_SETPIPEOPTS_ID_ERR_EID); @@ -1986,7 +1984,7 @@ void Test_SetPipeOpts_NotOwner(void) OrigOwner = PipeDscPtr->AppId; PipeDscPtr->AppId = UT_SB_AppID_Modify(OrigOwner, 1); - CFE_UtAssert_EQUAL(CFE_SB_SetPipeOpts(PipeID, 0), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_SetPipeOpts(PipeID, 0), CFE_SB_BAD_ARGUMENT); PipeDscPtr->AppId = OrigOwner; @@ -2020,7 +2018,7 @@ void Test_GetPipeOpts_BadID(void) { uint8 Opts = 0; - CFE_UtAssert_EQUAL(CFE_SB_GetPipeOpts(SB_UT_ALTERNATE_INVALID_PIPEID, &Opts), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_GetPipeOpts(SB_UT_ALTERNATE_INVALID_PIPEID, &Opts), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTSENT(CFE_SB_GETPIPEOPTS_ID_ERR_EID); @@ -2035,7 +2033,7 @@ void Test_GetPipeOpts_BadPtr(void) CFE_UtAssert_SETUP(CFE_SB_CreatePipe(&PipeID, 4, "TestPipe1")); - CFE_UtAssert_EQUAL(CFE_SB_GetPipeOpts(PipeID, NULL), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_GetPipeOpts(PipeID, NULL), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTSENT(CFE_SB_GETPIPEOPTS_PTR_ERR_EID); @@ -2112,7 +2110,7 @@ void Test_Subscribe_InvalidPipeId(void) CFE_SB_PipeId_t PipeId = SB_UT_PIPEID_2; CFE_SB_MsgId_t MsgId = SB_UT_ALTERNATE_INVALID_MID; - CFE_UtAssert_EQUAL(CFE_SB_Subscribe(MsgId, PipeId), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_Subscribe(MsgId, PipeId), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(2); @@ -2131,7 +2129,7 @@ void Test_Subscribe_InvalidMsgId(void) CFE_UtAssert_SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "TestPipe")); - CFE_UtAssert_EQUAL(CFE_SB_Subscribe(MsgId, PipeId), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_Subscribe(MsgId, PipeId), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(3); @@ -2238,7 +2236,7 @@ void Test_Subscribe_MaxDestCount(void) } else { - CFE_UtAssert_EQUAL(CFE_SB_Subscribe(MsgId, PipeId[i]), CFE_SB_MAX_DESTS_MET); + UtAssert_INT32_EQ(CFE_SB_Subscribe(MsgId, PipeId[i]), CFE_SB_MAX_DESTS_MET); } } @@ -2278,7 +2276,7 @@ void Test_Subscribe_MaxMsgIdCount(void) } else { - CFE_UtAssert_EQUAL(CFE_SB_Subscribe(CFE_SB_ValueToMsgId(i), PipeId2), CFE_SB_MAX_MSGS_MET); + UtAssert_INT32_EQ(CFE_SB_Subscribe(CFE_SB_ValueToMsgId(i), PipeId2), CFE_SB_MAX_MSGS_MET); } } @@ -2347,7 +2345,7 @@ void Test_Subscribe_PipeNonexistent(void) CFE_SB_MsgId_t MsgId = SB_UT_CMD_MID; CFE_SB_PipeId_t PipeId = SB_UT_ALTERNATE_INVALID_PIPEID; - CFE_UtAssert_EQUAL(CFE_SB_Subscribe(MsgId, PipeId), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_Subscribe(MsgId, PipeId), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(2); @@ -2510,14 +2508,14 @@ void Test_Unsubscribe_InvalParam(void) CFE_UtAssert_SETUP(CFE_SB_CreatePipe(&TestPipe, PipeDepth, "TestPipe")); /* Perform test using a bad message ID */ - CFE_UtAssert_EQUAL(CFE_SB_Unsubscribe(SB_UT_ALTERNATE_INVALID_MID, TestPipe), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_Unsubscribe(SB_UT_ALTERNATE_INVALID_MID, TestPipe), CFE_SB_BAD_ARGUMENT); /* Get the caller's Application ID */ CFE_UtAssert_SUCCESS(CFE_ES_GetAppID(&CallerId)); /* Perform test using a bad scope value */ - CFE_UtAssert_EQUAL(CFE_SB_UnsubscribeFull(SB_UT_FIRST_VALID_MID, TestPipe, CFE_SB_MSG_LOCAL + 1, CallerId), - CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_UnsubscribeFull(SB_UT_FIRST_VALID_MID, TestPipe, CFE_SB_MSG_LOCAL + 1, CallerId), + CFE_SB_BAD_ARGUMENT); /* Perform test using an invalid pipe ID for branch path coverage. * This situation cannot happen in normal circumstances since the @@ -2527,7 +2525,7 @@ void Test_Unsubscribe_InvalParam(void) PipeDscPtr = CFE_SB_LocatePipeDescByID(TestPipe); SavedPipeId = CFE_SB_PipeDescGetID(PipeDscPtr); PipeDscPtr->PipeId = SB_UT_ALTERNATE_INVALID_PIPEID; - CFE_UtAssert_EQUAL(CFE_SB_Unsubscribe(SB_UT_FIRST_VALID_MID, TestPipe), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_Unsubscribe(SB_UT_FIRST_VALID_MID, TestPipe), CFE_SB_BAD_ARGUMENT); /* We must restore the old value so CFE_SB_DeletePipe() works */ PipeDscPtr->PipeId = SavedPipeId; @@ -2581,7 +2579,7 @@ void Test_Unsubscribe_InvalidPipe(void) CFE_UtAssert_SETUP(CFE_SB_CreatePipe(&TestPipe, PipeDepth, "TestPipe")); CFE_UtAssert_SETUP(CFE_SB_Subscribe(MsgId, TestPipe)); - CFE_UtAssert_EQUAL(CFE_SB_Unsubscribe(MsgId, SB_UT_ALTERNATE_INVALID_PIPEID), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_Unsubscribe(MsgId, SB_UT_ALTERNATE_INVALID_PIPEID), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(3); @@ -2612,7 +2610,7 @@ void Test_Unsubscribe_InvalidPipeOwner(void) /* Choose a value that is sure not be owner */ PipeDscPtr->AppId = UT_SB_AppID_Modify(RealOwner, 1); - CFE_UtAssert_EQUAL(CFE_SB_Unsubscribe(MsgId, PipeId), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_Unsubscribe(MsgId, PipeId), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(3); @@ -2708,7 +2706,7 @@ void Test_Unsubscribe_GetDestPtr(void) /* For now just get route id and use it, will need update when stubbed */ RouteId = CFE_SBR_GetRouteId(MsgId); - CFE_UtAssert_TRUE(CFE_SB_GetDestPtr(RouteId, TestPipe2) == NULL); + UtAssert_NULL(CFE_SB_GetDestPtr(RouteId, TestPipe2)); CFE_UtAssert_EVENTCOUNT(5); @@ -2750,7 +2748,7 @@ void Test_TransmitMsg_API(void) */ void Test_TransmitMsg_NullPtr(void) { - CFE_UtAssert_EQUAL(CFE_SB_TransmitMsg(NULL, true), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_TransmitMsg(NULL, true), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(1); @@ -2790,7 +2788,7 @@ void Test_TransmitMsg_MaxMsgSizePlusOne(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); - CFE_UtAssert_EQUAL(CFE_SB_TransmitMsg(&TlmPkt.Hdr.Msg, true), CFE_SB_MSG_TOO_BIG); + UtAssert_INT32_EQ(CFE_SB_TransmitMsg(&TlmPkt.Hdr.Msg, true), CFE_SB_MSG_TOO_BIG); CFE_UtAssert_EVENTCOUNT(1); @@ -2863,18 +2861,18 @@ void Test_TransmitMsg_SequenceCount(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &Type, sizeof(Type), false); CFE_UtAssert_SETUP(CFE_SB_TransmitMsg(&TlmPkt.Hdr.Msg, true)); - CFE_UtAssert_EQUAL(UT_GetStubCount(UT_KEY(CFE_MSG_SetSequenceCount)), 1); - CFE_UtAssert_EQUAL(UT_GetStubCount(UT_KEY(CFE_MSG_GetNextSequenceCount)), 1); - CFE_UtAssert_EQUAL(SeqCnt, SeqCntExpected); + UtAssert_STUB_COUNT(CFE_MSG_SetSequenceCount, 1); + UtAssert_STUB_COUNT(CFE_MSG_GetNextSequenceCount, 1); + UtAssert_INT32_EQ(SeqCnt, SeqCntExpected); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &Type, sizeof(Type), false); CFE_UtAssert_SUCCESS(CFE_SB_TransmitMsg(&TlmPkt.Hdr.Msg, false)); - /* CFE_UtAssert_SUCCESS sequence count wasn't set */ - CFE_UtAssert_EQUAL(UT_GetStubCount(UT_KEY(CFE_MSG_GetNextSequenceCount)), 1); - CFE_UtAssert_EQUAL(UT_GetStubCount(UT_KEY(CFE_MSG_SetSequenceCount)), 1); + /* Assert sequence count wasn't set */ + UtAssert_STUB_COUNT(CFE_MSG_GetNextSequenceCount, 1); + UtAssert_STUB_COUNT(CFE_MSG_SetSequenceCount, 1); SeqCntExpected = 2; UT_SetDefaultReturnValue(UT_KEY(CFE_MSG_GetNextSequenceCount), SeqCntExpected); @@ -2882,9 +2880,9 @@ void Test_TransmitMsg_SequenceCount(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &Type, sizeof(Type), false); CFE_UtAssert_SUCCESS(CFE_SB_TransmitMsg(&TlmPkt.Hdr.Msg, true)); - CFE_UtAssert_EQUAL(SeqCnt, SeqCntExpected); - CFE_UtAssert_EQUAL(UT_GetStubCount(UT_KEY(CFE_MSG_SetSequenceCount)), 2); - CFE_UtAssert_EQUAL(UT_GetStubCount(UT_KEY(CFE_MSG_GetNextSequenceCount)), 2); + UtAssert_INT32_EQ(SeqCnt, SeqCntExpected); + UtAssert_STUB_COUNT(CFE_MSG_SetSequenceCount, 2); + UtAssert_STUB_COUNT(CFE_MSG_GetNextSequenceCount, 2); CFE_UtAssert_EVENTCOUNT(2); CFE_UtAssert_EVENTSENT(CFE_SB_SUBSCRIPTION_RCVD_EID); @@ -2897,8 +2895,8 @@ void Test_TransmitMsg_SequenceCount(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &Type, sizeof(Type), false); CFE_UtAssert_SETUP(CFE_SB_TransmitMsg(&TlmPkt.Hdr.Msg, true)); /* increment to 3 */ - CFE_UtAssert_EQUAL(UT_GetStubCount(UT_KEY(CFE_MSG_SetSequenceCount)), 3); - CFE_UtAssert_EQUAL(UT_GetStubCount(UT_KEY(CFE_MSG_GetNextSequenceCount)), 3); + UtAssert_STUB_COUNT(CFE_MSG_SetSequenceCount, 3); + UtAssert_STUB_COUNT(CFE_MSG_GetNextSequenceCount, 3); CFE_UtAssert_SETUP(CFE_SB_Subscribe(MsgId, PipeId)); /* resubscribe so we can receive a msg */ @@ -2908,9 +2906,9 @@ void Test_TransmitMsg_SequenceCount(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &Type, sizeof(Type), false); CFE_UtAssert_SETUP(CFE_SB_TransmitMsg(&TlmPkt.Hdr.Msg, true)); /* increment to 4 */ - CFE_UtAssert_EQUAL(SeqCnt, SeqCntExpected); - CFE_UtAssert_EQUAL(UT_GetStubCount(UT_KEY(CFE_MSG_SetSequenceCount)), 4); - CFE_UtAssert_EQUAL(UT_GetStubCount(UT_KEY(CFE_MSG_GetNextSequenceCount)), 4); + UtAssert_INT32_EQ(SeqCnt, SeqCntExpected); + UtAssert_STUB_COUNT(CFE_MSG_SetSequenceCount, 4); + UtAssert_STUB_COUNT(CFE_MSG_GetNextSequenceCount, 4); CFE_UtAssert_TEARDOWN(CFE_SB_DeletePipe(PipeId)); @@ -3046,7 +3044,7 @@ void Test_TransmitMsg_GetPoolBufErr(void) * allocation failed) */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_GetPoolBuf), 1, CFE_ES_ERR_MEM_BLOCK_SIZE); - CFE_UtAssert_EQUAL(CFE_SB_TransmitMsg(&TlmPkt.Hdr.Msg, true), CFE_SB_BUF_ALOC_ERR); + UtAssert_INT32_EQ(CFE_SB_TransmitMsg(&TlmPkt.Hdr.Msg, true), CFE_SB_BUF_ALOC_ERR); CFE_UtAssert_EVENTCOUNT(3); @@ -3069,7 +3067,7 @@ void Test_AllocateMessageBuffer(void) * allocation failed) */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_GetPoolBuf), 1, CFE_ES_ERR_MEM_BLOCK_SIZE); - CFE_UtAssert_TRUE(CFE_SB_AllocateMessageBuffer(MsgSize) == NULL); + UtAssert_NULL(CFE_SB_AllocateMessageBuffer(MsgSize)); CFE_UtAssert_EVENTCOUNT(0); @@ -3082,13 +3080,13 @@ void Test_AllocateMessageBuffer(void) CFE_SB_Global.StatTlmMsg.Payload.MemInUse = 0; CFE_SB_Global.StatTlmMsg.Payload.PeakMemInUse = MemUse + 10; CFE_SB_Global.StatTlmMsg.Payload.PeakSBBuffersInUse = CFE_SB_Global.StatTlmMsg.Payload.SBBuffersInUse + 2; - CFE_UtAssert_TRUE(CFE_SB_AllocateMessageBuffer(MsgSize) != NULL); + UtAssert_NOT_NULL(CFE_SB_AllocateMessageBuffer(MsgSize)); - CFE_UtAssert_EQUAL(CFE_SB_Global.StatTlmMsg.Payload.PeakMemInUse, MemUse + 10); /* unchanged */ - CFE_UtAssert_EQUAL(CFE_SB_Global.StatTlmMsg.Payload.MemInUse, MemUse); /* predicted value */ + UtAssert_INT32_EQ(CFE_SB_Global.StatTlmMsg.Payload.PeakMemInUse, MemUse + 10); /* unchanged */ + UtAssert_INT32_EQ(CFE_SB_Global.StatTlmMsg.Payload.MemInUse, MemUse); /* predicted value */ - CFE_UtAssert_EQUAL(CFE_SB_Global.StatTlmMsg.Payload.PeakSBBuffersInUse, - CFE_SB_Global.StatTlmMsg.Payload.SBBuffersInUse + 1); + UtAssert_INT32_EQ(CFE_SB_Global.StatTlmMsg.Payload.PeakSBBuffersInUse, + CFE_SB_Global.StatTlmMsg.Payload.SBBuffersInUse + 1); CFE_UtAssert_EVENTCOUNT(0); @@ -3112,16 +3110,16 @@ void Test_TransmitMsg_ZeroCopyBufferValidate(void) memset(&BadZeroCpyBuf, 0, sizeof(BadZeroCpyBuf)); /* Null Buffer => BAD_ARGUMENT */ - CFE_UtAssert_EQUAL(CFE_SB_ZeroCopyBufferValidate(NULL, &BufDscPtr), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_ZeroCopyBufferValidate(NULL, &BufDscPtr), CFE_SB_BAD_ARGUMENT); /* Non-null buffer pointer but Non Zero-Copy => CFE_SB_BUFFER_INVALID */ - CFE_UtAssert_EQUAL(CFE_SB_ZeroCopyBufferValidate(&BadZeroCpyBuf.Content, &BufDscPtr), CFE_SB_BUFFER_INVALID); + UtAssert_INT32_EQ(CFE_SB_ZeroCopyBufferValidate(&BadZeroCpyBuf.Content, &BufDscPtr), CFE_SB_BUFFER_INVALID); /* Good buffer pointer + Good Handle => SUCCESS */ - CFE_UtAssert_EQUAL(CFE_SB_ZeroCopyBufferValidate(SendPtr, &BufDscPtr), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_SB_ZeroCopyBufferValidate(SendPtr, &BufDscPtr)); /* Confirm that the computed pointer was correct */ - CFE_UtAssert_TRUE(&BufDscPtr->Content == SendPtr); + UtAssert_ADDRESS_EQ(&BufDscPtr->Content, SendPtr); /* Clean-up */ CFE_SB_ReleaseMessageBuffer(SendPtr); @@ -3166,9 +3164,9 @@ void Test_TransmitBuffer_IncrementSeqCnt(void) CFE_UtAssert_SUCCESS(CFE_SB_ReceiveBuffer(&ReceivePtr, PipeId, CFE_SB_PEND_FOREVER)); - CFE_UtAssert_TRUE(SendPtr == ReceivePtr); + UtAssert_ADDRESS_EQ(SendPtr, ReceivePtr); - CFE_UtAssert_EQUAL(SeqCnt, 1); + UtAssert_INT32_EQ(SeqCnt, 1); CFE_UtAssert_EVENTCOUNT(2); @@ -3213,8 +3211,8 @@ void Test_TransmitBuffer_NoIncrement(void) CFE_UtAssert_SUCCESS(CFE_SB_TransmitBuffer(SendPtr, false)); CFE_UtAssert_SUCCESS(CFE_SB_ReceiveBuffer(&ReceivePtr, PipeId, CFE_SB_PEND_FOREVER)); - CFE_UtAssert_TRUE(SendPtr == ReceivePtr); - CFE_UtAssert_EQUAL(SeqCnt, 22); + UtAssert_ADDRESS_EQ(SendPtr, ReceivePtr); + UtAssert_INT32_EQ(SeqCnt, 22); CFE_UtAssert_EVENTCOUNT(2); @@ -3240,14 +3238,14 @@ void Test_ReleaseMessageBuffer(void) CFE_UtAssert_SETUP(CFE_SB_ReleaseMessageBuffer(ZeroCpyMsgPtr2)); /* Test response to an invalid buffer (has been released already) */ - CFE_UtAssert_EQUAL(CFE_SB_ReleaseMessageBuffer(ZeroCpyMsgPtr2), CFE_SB_BUFFER_INVALID); + UtAssert_INT32_EQ(CFE_SB_ReleaseMessageBuffer(ZeroCpyMsgPtr2), CFE_SB_BUFFER_INVALID); /* Test response to a null message pointer */ - CFE_UtAssert_EQUAL(CFE_SB_ReleaseMessageBuffer(NULL), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_ReleaseMessageBuffer(NULL), CFE_SB_BAD_ARGUMENT); /* Test response to an invalid message pointer */ memset(&BadBufferDesc, 0, sizeof(BadBufferDesc)); - CFE_UtAssert_EQUAL(CFE_SB_ReleaseMessageBuffer(&BadBufferDesc.Content), CFE_SB_BUFFER_INVALID); + UtAssert_INT32_EQ(CFE_SB_ReleaseMessageBuffer(&BadBufferDesc.Content), CFE_SB_BUFFER_INVALID); /* Test successful release of the second buffer */ CFE_UtAssert_SUCCESS(CFE_SB_ReleaseMessageBuffer(ZeroCpyMsgPtr3)); @@ -3341,10 +3339,10 @@ void Test_TransmitMsgValidate_MaxMsgSizePlusOne(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); - CFE_UtAssert_EQUAL(CFE_SB_TransmitMsgValidate(&TlmPkt.Hdr.Msg, &MsgIdRtn, &SizeRtn, &RouteIdRtn), - CFE_SB_MSG_TOO_BIG); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(MsgIdRtn), CFE_SB_MsgIdToValue(MsgId)); - CFE_UtAssert_EQUAL(SizeRtn, Size); + UtAssert_INT32_EQ(CFE_SB_TransmitMsgValidate(&TlmPkt.Hdr.Msg, &MsgIdRtn, &SizeRtn, &RouteIdRtn), + CFE_SB_MSG_TOO_BIG); + CFE_UtAssert_MSGID_EQ(MsgIdRtn, MsgId); + UtAssert_INT32_EQ(SizeRtn, Size); CFE_UtAssert_EVENTCOUNT(1); @@ -3367,9 +3365,9 @@ void Test_TransmitMsgValidate_NoSubscribers(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); CFE_UtAssert_SUCCESS(CFE_SB_TransmitMsgValidate(&TlmPkt.Hdr.Msg, &MsgIdRtn, &SizeRtn, &RouteIdRtn)); - CFE_UtAssert_EQUAL(CFE_SB_MsgIdToValue(MsgIdRtn), CFE_SB_MsgIdToValue(MsgId)); - CFE_UtAssert_EQUAL(SizeRtn, Size); - CFE_UtAssert_TRUE(!CFE_SBR_IsValidRouteId(RouteIdRtn)); + CFE_UtAssert_MSGID_EQ(MsgIdRtn, MsgId); + UtAssert_INT32_EQ(SizeRtn, Size); + CFE_UtAssert_FALSE(CFE_SBR_IsValidRouteId(RouteIdRtn)); CFE_UtAssert_EVENTCOUNT(1); @@ -3398,7 +3396,7 @@ void Test_ReceiveBuffer_InvalidPipeId(void) CFE_SB_Buffer_t *SBBufPtr; CFE_SB_PipeId_t InvalidPipeId = SB_UT_ALTERNATE_INVALID_PIPEID; - CFE_UtAssert_EQUAL(CFE_SB_ReceiveBuffer(&SBBufPtr, InvalidPipeId, CFE_SB_POLL), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(&SBBufPtr, InvalidPipeId, CFE_SB_POLL), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(1); @@ -3418,7 +3416,7 @@ void Test_ReceiveBuffer_InvalidTimeout(void) CFE_UtAssert_SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "RcvTestPipe")); - CFE_UtAssert_EQUAL(CFE_SB_ReceiveBuffer(&SBBufPtr, PipeId, TimeOut), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(&SBBufPtr, PipeId, TimeOut), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(2); @@ -3439,7 +3437,7 @@ void Test_ReceiveBuffer_Poll(void) CFE_UtAssert_SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "RcvTestPipe")); - CFE_UtAssert_EQUAL(CFE_SB_ReceiveBuffer(&SBBufPtr, PipeId, CFE_SB_POLL), CFE_SB_NO_MESSAGE); + UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(&SBBufPtr, PipeId, CFE_SB_POLL), CFE_SB_NO_MESSAGE); CFE_UtAssert_EVENTCOUNT(1); @@ -3462,7 +3460,7 @@ void Test_ReceiveBuffer_Timeout(void) CFE_UtAssert_SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "RcvTestPipe")); UT_SetDeferredRetcode(UT_KEY(OS_QueueGet), 1, OS_QUEUE_TIMEOUT); - CFE_UtAssert_EQUAL(CFE_SB_ReceiveBuffer(&SBBufPtr, PipeId, TimeOut), CFE_SB_TIME_OUT); + UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(&SBBufPtr, PipeId, TimeOut), CFE_SB_TIME_OUT); CFE_UtAssert_EVENTCOUNT(1); @@ -3483,7 +3481,7 @@ void Test_ReceiveBuffer_PipeReadError(void) CFE_UtAssert_SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "RcvTestPipe")); UT_SetDeferredRetcode(UT_KEY(OS_QueueGet), 1, OS_ERROR); - CFE_UtAssert_EQUAL(CFE_SB_ReceiveBuffer(&SBBufPtr, PipeId, CFE_SB_PEND_FOREVER), CFE_SB_PIPE_RD_ERR); + UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(&SBBufPtr, PipeId, CFE_SB_PEND_FOREVER), CFE_SB_PIPE_RD_ERR); CFE_UtAssert_EVENTCOUNT(2); @@ -3515,7 +3513,7 @@ void Test_ReceiveBuffer_PendForever(void) CFE_UtAssert_SUCCESS(CFE_SB_ReceiveBuffer(&SBBufPtr, PipeId, CFE_SB_PEND_FOREVER)); - CFE_UtAssert_TRUE(SBBufPtr != NULL); + UtAssert_NOT_NULL(SBBufPtr); CFE_UtAssert_EVENTCOUNT(2); @@ -3597,7 +3595,7 @@ void Test_ReceiveBuffer_InvalidBufferPtr(void) CFE_UtAssert_SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "RcvTestPipe")); - CFE_UtAssert_EQUAL(CFE_SB_ReceiveBuffer(NULL, PipeId, CFE_SB_PEND_FOREVER), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(NULL, PipeId, CFE_SB_PEND_FOREVER), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(2); @@ -3632,26 +3630,26 @@ void Test_CFE_SB_MsgHdrSize(void) type = CFE_MSG_Type_Invalid; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); - CFE_UtAssert_EQUAL(CFE_SB_MsgHdrSize(&msg), sizeof(CFE_MSG_Message_t)); + CFE_UtAssert_MEMOFFSET_EQ(CFE_SB_MsgHdrSize(&msg), sizeof(CFE_MSG_Message_t)); /* Has secondary, tlm type */ hassec = true; type = CFE_MSG_Type_Tlm; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); - CFE_UtAssert_EQUAL(CFE_SB_MsgHdrSize(&msg), sizeof(CFE_MSG_TelemetryHeader_t)); + CFE_UtAssert_MEMOFFSET_EQ(CFE_SB_MsgHdrSize(&msg), sizeof(CFE_MSG_TelemetryHeader_t)); /* Has secondary, cmd type */ type = CFE_MSG_Type_Cmd; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); - CFE_UtAssert_EQUAL(CFE_SB_MsgHdrSize(&msg), sizeof(CFE_MSG_CommandHeader_t)); + CFE_UtAssert_MEMOFFSET_EQ(CFE_SB_MsgHdrSize(&msg), sizeof(CFE_MSG_CommandHeader_t)); /* Has secondary, invalid type */ type = CFE_MSG_Type_Invalid; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); - CFE_UtAssert_EQUAL(CFE_SB_MsgHdrSize(&msg), 0); + CFE_UtAssert_MEMOFFSET_EQ(CFE_SB_MsgHdrSize(&msg), 0); } /* end Test_CFE_SB_MsgHdrSize */ @@ -3761,7 +3759,7 @@ void Test_CFE_SB_SetGetUserDataLength(void) UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &size, sizeof(size), false); - CFE_UtAssert_EQUAL(CFE_SB_GetUserDataLength(&msg), size - sizeof(CCSDS_SpacePacket_t)); + UtAssert_INT32_EQ(CFE_SB_GetUserDataLength(&msg), size - sizeof(CCSDS_SpacePacket_t)); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); @@ -3778,11 +3776,11 @@ void Test_CFE_SB_ValidateMsgId(void) /* Validate Msg Id */ MsgId = SB_UT_LAST_VALID_MID; - CFE_UtAssert_EQUAL(CFE_SB_ValidateMsgId(MsgId), CFE_SUCCESS); + CFE_UtAssert_SUCCESS(CFE_SB_ValidateMsgId(MsgId)); /* Test for invalid msg id */ MsgId = SB_UT_ALTERNATE_INVALID_MID; - CFE_UtAssert_EQUAL(CFE_SB_ValidateMsgId(MsgId), CFE_SB_FAILED); + UtAssert_INT32_EQ(CFE_SB_ValidateMsgId(MsgId), CFE_SB_FAILED); } /* @@ -3841,12 +3839,12 @@ void Test_ReqToSendEvent_ErrLogic(void) */ CFE_ES_GetTaskID(&TaskId); CFE_SB_Global.StopRecurseFlags[0] = 0x0000; - CFE_UtAssert_EQUAL(CFE_SB_RequestToSendEvent(TaskId, Bit), CFE_SB_GRANTED); + UtAssert_INT32_EQ(CFE_SB_RequestToSendEvent(TaskId, Bit), CFE_SB_GRANTED); /* Call the function a second time; the result should indicate that the * bit is already set */ - CFE_UtAssert_EQUAL(CFE_SB_RequestToSendEvent(TaskId, Bit), CFE_SB_DENIED); + UtAssert_INT32_EQ(CFE_SB_RequestToSendEvent(TaskId, Bit), CFE_SB_DENIED); CFE_UtAssert_EVENTCOUNT(0); @@ -3858,7 +3856,7 @@ void Test_ReqToSendEvent_ErrLogic(void) */ void Test_PutDestBlk_ErrLogic(void) { - CFE_UtAssert_EQUAL(CFE_SB_PutDestinationBlk(NULL), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_PutDestinationBlk(NULL), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(0); @@ -3877,7 +3875,7 @@ void Test_CFE_SB_Buffers(void) CFE_SB_Global.StatTlmMsg.Payload.PeakMemInUse = sizeof(CFE_SB_BufferD_t) * 4; bd = CFE_SB_GetBufferFromPool(0); - CFE_UtAssert_EQUAL(CFE_SB_Global.StatTlmMsg.Payload.PeakMemInUse, sizeof(CFE_SB_BufferD_t) * 4); + UtAssert_INT32_EQ(CFE_SB_Global.StatTlmMsg.Payload.PeakMemInUse, sizeof(CFE_SB_BufferD_t) * 4); CFE_UtAssert_EVENTCOUNT(0); @@ -3888,13 +3886,13 @@ void Test_CFE_SB_Buffers(void) ExpRtn = CFE_SB_Global.StatTlmMsg.Payload.SBBuffersInUse - 1; UT_SetDeferredRetcode(UT_KEY(CFE_ES_PutPoolBuf), 1, -1); CFE_SB_ReturnBufferToPool(bd); - CFE_UtAssert_EQUAL(CFE_SB_Global.StatTlmMsg.Payload.SBBuffersInUse, ExpRtn); + UtAssert_INT32_EQ(CFE_SB_Global.StatTlmMsg.Payload.SBBuffersInUse, ExpRtn); CFE_UtAssert_EVENTCOUNT(0); bd->UseCount = 0; CFE_SB_DecrBufUseCnt(bd); - CFE_UtAssert_EQUAL(bd->UseCount, 0); + UtAssert_INT32_EQ(bd->UseCount, 0); CFE_UtAssert_EVENTCOUNT(0); @@ -3902,7 +3900,7 @@ void Test_CFE_SB_Buffers(void) CFE_SB_Global.StatTlmMsg.Payload.MemInUse = 0; CFE_SB_PutDestinationBlk((CFE_SB_DestinationD_t *)bd); - CFE_UtAssert_EQUAL(CFE_SB_Global.StatTlmMsg.Payload.MemInUse, 0); + UtAssert_INT32_EQ(CFE_SB_Global.StatTlmMsg.Payload.MemInUse, 0); CFE_UtAssert_EVENTCOUNT(0); @@ -3924,14 +3922,14 @@ void Test_CFE_SB_BadPipeInfo(void) PipeDscPtr = CFE_SB_LocatePipeDescByID(PipeId); PipeDscPtr->PipeId = SB_UT_PIPEID_1; CFE_ES_GetAppID(&AppID); - CFE_UtAssert_EQUAL(CFE_SB_DeletePipeFull(SB_UT_PIPEID_0, AppID), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_DeletePipeFull(SB_UT_PIPEID_0, AppID), CFE_SB_BAD_ARGUMENT); CFE_UtAssert_EVENTCOUNT(2); /* Reset the pipe ID and delete the pipe */ PipeDscPtr->PipeId = PipeId; - CFE_UtAssert_EQUAL( + UtAssert_INT32_EQ( CFE_SB_SubscribeFull(SB_UT_FIRST_VALID_MID, PipeId, CFE_SB_DEFAULT_QOS, CFE_PLATFORM_SB_DEFAULT_MSG_LIMIT, 2), CFE_SB_BAD_ARGUMENT); @@ -3974,8 +3972,8 @@ void Test_SB_TransmitMsgPaths_Nominal(void) CFE_SB_ProcessCmdPipePkt(&Housekeeping.SBBuf); /* The no subs event should not be in history but count should increment */ - CFE_UtAssert_TRUE(!UT_EventIsInHistory(CFE_SB_SEND_NO_SUBS_EID)); - CFE_UtAssert_EQUAL(CFE_SB_Global.HKTlmMsg.Payload.NoSubscribersCounter, 1); + CFE_UtAssert_EVENTNOTSENT(CFE_SB_SEND_NO_SUBS_EID); + UtAssert_INT32_EQ(CFE_SB_Global.HKTlmMsg.Payload.NoSubscribersCounter, 1); /* Repress get buffer error */ CFE_SB_Global.HKTlmMsg.Payload.MsgSendErrorCounter = 0; @@ -3993,9 +3991,9 @@ void Test_SB_TransmitMsgPaths_Nominal(void) UT_SetDeferredRetcode(UT_KEY(CFE_ES_GetPoolBuf), 1, CFE_ES_ERR_MEM_BLOCK_SIZE); CFE_SB_ProcessCmdPipePkt(&Housekeeping.SBBuf); - CFE_UtAssert_EQUAL(CFE_SB_Global.HKTlmMsg.Payload.MsgSendErrorCounter, 0); + UtAssert_INT32_EQ(CFE_SB_Global.HKTlmMsg.Payload.MsgSendErrorCounter, 0); - CFE_UtAssert_TRUE(!UT_EventIsInHistory(CFE_SB_GET_BUF_ERR_EID)); + CFE_UtAssert_EVENTNOTSENT(CFE_SB_GET_BUF_ERR_EID); CFE_UtAssert_EVENTCOUNT(0); @@ -4008,7 +4006,7 @@ void Test_SB_TransmitMsgPaths_Nominal(void) CFE_UtAssert_SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "TestPipe")); /* Will fail because of deferred CFE_ES_GetPoolBuf failure return */ - CFE_UtAssert_EQUAL(CFE_SB_Subscribe(MsgId, PipeId), CFE_SB_BUF_ALOC_ERR); + UtAssert_INT32_EQ(CFE_SB_Subscribe(MsgId, PipeId), CFE_SB_BUF_ALOC_ERR); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); @@ -4052,7 +4050,7 @@ void Test_SB_TransmitMsgPaths_LimitErr(void) CFE_UtAssert_SUCCESS(CFE_SB_TransmitMsg(&TlmPkt.Hdr.Msg, true)); CFE_SB_Global.StopRecurseFlags[1] = 0; - CFE_UtAssert_TRUE(!UT_EventIsInHistory(CFE_SB_MSGID_LIM_ERR_EID)); + CFE_UtAssert_EVENTNOTSENT(CFE_SB_MSGID_LIM_ERR_EID); CFE_UtAssert_TEARDOWN(CFE_SB_DeletePipe(PipeId)); @@ -4089,7 +4087,7 @@ void Test_SB_TransmitMsgPaths_FullErr(void) CFE_UtAssert_SUCCESS(CFE_SB_TransmitMsg(&TlmPkt.Hdr.Msg, true)); CFE_SB_Global.StopRecurseFlags[1] = 0; - CFE_UtAssert_TRUE(!UT_EventIsInHistory(CFE_SB_Q_FULL_ERR_EID_BIT)); + CFE_UtAssert_EVENTNOTSENT(CFE_SB_Q_FULL_ERR_EID_BIT); CFE_UtAssert_EVENTCOUNT(2); @@ -4127,7 +4125,7 @@ void Test_SB_TransmitMsgPaths_WriteErr(void) CFE_UtAssert_EVENTCOUNT(2); - CFE_UtAssert_TRUE(!UT_EventIsInHistory(CFE_SB_Q_WR_ERR_EID)); + CFE_UtAssert_EVENTNOTSENT(CFE_SB_Q_WR_ERR_EID); CFE_UtAssert_TEARDOWN(CFE_SB_DeletePipe(PipeId)); @@ -4185,7 +4183,7 @@ void Test_ReceiveBuffer_UnsubResubPath(void) CFE_UtAssert_SETUP(CFE_SB_Subscribe(MsgId, PipeId)); CFE_UtAssert_SUCCESS(CFE_SB_ReceiveBuffer(&SBBufPtr, PipeId, CFE_SB_PEND_FOREVER)); - CFE_UtAssert_TRUE(SBBufPtr != NULL); + UtAssert_NOT_NULL(SBBufPtr); CFE_UtAssert_EVENTCOUNT(4); @@ -4201,49 +4199,54 @@ void Test_ReceiveBuffer_UnsubResubPath(void) */ void Test_MessageString(void) { - const char *SrcString = "abcdefg"; - char DestString[20]; - char * DestStringPtr = DestString; - const char *DefString = "default"; + char SrcString[12]; + char DestString[12]; + const char DefString[] = "default"; + + strcpy(SrcString, "abcdefg"); + memset(DestString, 'q', sizeof(DestString)); /* Test setting string where the destination size > source string size */ - CFE_SB_MessageStringSet(DestStringPtr, SrcString, sizeof(DestString), strlen(SrcString)); - UT_Report(__FILE__, __LINE__, strcmp(DestString, SrcString) == 0, "CFE_SB_MessageStringSet", - "Destination size > source string size"); + CFE_SB_MessageStringSet(DestString, SrcString, sizeof(DestString), sizeof(SrcString)); + CFE_UtAssert_STRINGBUF_EQ(DestString, sizeof(DestString), SrcString, sizeof(SrcString)); /* Test setting string where the source string is empty */ - CFE_SB_MessageStringSet(DestStringPtr, "", sizeof(DestString), strlen(SrcString)); - UT_Report(__FILE__, __LINE__, strcmp(DestString, SrcString) != 0, "CFE_SB_MessageStringSet", "Empty source string"); + memset(SrcString, 0, sizeof(SrcString)); + memset(DestString, 'q', sizeof(DestString)); + CFE_SB_MessageStringSet(DestString, SrcString, sizeof(DestString), sizeof(SrcString)); + CFE_UtAssert_STRINGBUF_EQ(DestString, sizeof(DestString), SrcString, sizeof(SrcString)); /* Test setting string where the destination size < source string size */ - CFE_SB_MessageStringSet(DestStringPtr, SrcString, strlen(SrcString) - 1, strlen(SrcString)); - UT_Report(__FILE__, __LINE__, strncmp(DestString, SrcString, strlen(SrcString) - 1) == 0, "CFE_SB_MessageStringSet", - "Destination size < source string size"); + strcpy(SrcString, "abcdefg"); + memset(DestString, 'q', sizeof(DestString)); + CFE_SB_MessageStringSet(DestString, SrcString, 4, sizeof(SrcString)); + CFE_UtAssert_STRINGBUF_EQ(DestString, 4, SrcString, 4); /* Test getting string where the destination size > source string size */ - CFE_SB_MessageStringGet(DestStringPtr, SrcString, DefString, sizeof(DestString), strlen(SrcString)); - UT_Report(__FILE__, __LINE__, strcmp(DestString, SrcString) == 0, "CFE_SB_MessageStringGet", - "Destination size > source string size"); + strcpy(SrcString, "abcdefg"); + memset(DestString, 'q', sizeof(DestString)); + CFE_SB_MessageStringGet(DestString, SrcString, DefString, sizeof(DestString), 5); + CFE_UtAssert_STRINGBUF_EQ(DestString, sizeof(DestString), SrcString, 5); /* Test getting string where the destination size is zero */ - DestString[0] = '\0'; - CFE_SB_MessageStringGet(DestStringPtr, SrcString, DefString, 0, strlen(SrcString)); - UT_Report(__FILE__, __LINE__, strcmp(DestString, SrcString) != 0, "CFE_SB_MessageStringGet", - "Destination size = 0"); + memset(DestString, 'q', sizeof(DestString)); + memset(SrcString, 'k', sizeof(SrcString)); + CFE_SB_MessageStringGet(DestString, SrcString, DefString, 0, sizeof(SrcString)); + memset(SrcString, 'q', sizeof(SrcString)); + CFE_UtAssert_STRINGBUF_EQ(DestString, sizeof(DestString), SrcString, sizeof(SrcString)); /* Test getting string where the default string is NULL */ - CFE_SB_MessageStringGet(DestStringPtr, SrcString, NULL, sizeof(DestString), 0); - UT_Report(__FILE__, __LINE__, strcmp(DefString, SrcString) != 0, "CFE_SB_MessageStringGet", - "Default string = NULL"); + memset(DestString, 'q', sizeof(DestString)); + CFE_SB_MessageStringGet(DestString, SrcString, NULL, sizeof(DestString), 0); + CFE_UtAssert_STRINGBUF_EQ(DestString, sizeof(DestString), "", 0); /* Test getting string where the source string size is zero */ - CFE_SB_MessageStringGet(DestStringPtr, SrcString, DefString, sizeof(DestString), 0); - UT_Report(__FILE__, __LINE__, strcmp(DestString, SrcString) != 0, "CFE_SB_MessageStringGet", - "Source string size = 0"); + CFE_SB_MessageStringGet(DestString, SrcString, DefString, sizeof(DestString), 0); + CFE_UtAssert_STRINGBUF_EQ(DestString, sizeof(DestString), DefString, sizeof(DefString)); /* Test getting string where the destination size < source string size */ - DestString[0] = '\0'; - CFE_SB_MessageStringGet(DestStringPtr, SrcString, DefString, strlen(SrcString) - 1, strlen(SrcString)); - UT_Report(__FILE__, __LINE__, strncmp(DestString, SrcString, strlen(DestString)) == 0, "CFE_SB_MessageStringGet", - "Destination size < source string size"); + strcpy(SrcString, "abcdefg"); + memset(DestString, 'q', sizeof(DestString)); + CFE_SB_MessageStringGet(DestString, SrcString, DefString, 4, sizeof(SrcString)); + CFE_UtAssert_STRINGBUF_EQ(DestString, 4, SrcString, 3); } /* end Test_MessageString */