From c24daf4f50277013feae0935313e41de283f44f4 Mon Sep 17 00:00:00 2001 From: Joseph Hickey Date: Fri, 13 Aug 2021 10:29:32 -0400 Subject: [PATCH] Fix #1812, Add SB API test cases Adds SB functional test cases to cover all missing items that were identified as part of the scrub in issue #1724. Where a specific condition is not testable because it requires a failure of another subsystem, it is marked as `covtest` to indicate it is only verifiable in coverage test environment. --- modules/cfe_testcase/src/sb_pipe_mang_test.c | 56 +++++++++- modules/cfe_testcase/src/sb_sendrecv_test.c | 104 +++++++++++++++++- .../cfe_testcase/src/sb_subscription_test.c | 45 ++++++++ modules/core_api/fsw/inc/cfe_sb.h | 24 ++-- 4 files changed, 209 insertions(+), 20 deletions(-) diff --git a/modules/cfe_testcase/src/sb_pipe_mang_test.c b/modules/cfe_testcase/src/sb_pipe_mang_test.c index da161d2dd..08be2171c 100644 --- a/modules/cfe_testcase/src/sb_pipe_mang_test.c +++ b/modules/cfe_testcase/src/sb_pipe_mang_test.c @@ -43,13 +43,63 @@ void TestPipeCreate(void) UtAssert_INT32_EQ(CFE_SB_CreatePipe(&PipeId1, PipeDepth, PipeName), CFE_SUCCESS); + UtAssert_INT32_EQ(CFE_SB_DeletePipe(PipeId1), CFE_SUCCESS); + UtAssert_INT32_EQ(CFE_SB_DeletePipe(PipeId1), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_DeletePipe(CFE_SB_INVALID_PIPE), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_CreatePipe(NULL, PipeDepth, PipeName), CFE_SB_BAD_ARGUMENT); UtAssert_INT32_EQ(CFE_SB_CreatePipe(&PipeId1, OS_QUEUE_MAX_DEPTH + 5, PipeName), CFE_SB_BAD_ARGUMENT); UtAssert_INT32_EQ(CFE_SB_CreatePipe(&PipeId1, 0, PipeName), CFE_SB_BAD_ARGUMENT); UtAssert_INT32_EQ(CFE_SB_CreatePipe(&PipeId1, PipeDepth, NULL), CFE_SB_PIPE_CR_ERR); +} - UtAssert_INT32_EQ(CFE_SB_DeletePipe(PipeId1), CFE_SUCCESS); - UtAssert_INT32_EQ(CFE_SB_DeletePipe(PipeId1), CFE_SB_BAD_ARGUMENT); +void TestPipeCreateMax(void) +{ + CFE_SB_PipeId_t PipeId[CFE_PLATFORM_SB_MAX_PIPES + 1]; + char PipeName[12]; + uint32 NumPipes; + + UtPrintf("Testing: CFE_SB_CreatePipe, maximum pipe limit"); + + /* + * NOTE: because any other running apps (including core apps) will likely have + * created some pipes already, it is not known how many more pipes can be created + * at this point. So this cannot assert directly on the return code of + * CFE_SB_CreatePipe because we do not know which iteration will return error, + * but it will be less than CFE_PLATFORM_SB_MAX_PIPES. + */ + NumPipes = 0; + while (NumPipes <= CFE_PLATFORM_SB_MAX_PIPES) + { + snprintf(PipeName, sizeof(PipeName), "TestPipe%u", (unsigned int)NumPipes); + CFE_Assert_STATUS_STORE(CFE_SB_CreatePipe(&PipeId[NumPipes], 10, PipeName)); + /* + * Normally, this will return CFE_SUCCESS, until the max number of pipes is reached. + * Confirm that the last creation attempt returned CFE_SB_MAX_PIPES_MET + * + * NOTE: this also mimics the same format as UtAssert_INT32_EQ so that any post-procesing + * test log analysis tools will see this call as well. + */ + if (CFE_Assert_STATUS_MAY_BE(CFE_SB_MAX_PIPES_MET)) + { + break; + } + + /* If not CFE_SB_MAX_PIPES_MET, then the only acceptable response is SUCCESS */ + CFE_Assert_STATUS_MUST_BE(CFE_SUCCESS); + + ++NumPipes; + } + + /* should have gotten CFE_SB_MAX_PIPES_MET before CFE_PLATFORM_SB_MAX_PIPES reached */ + UtAssert_UINT32_LT(NumPipes, CFE_PLATFORM_SB_MAX_PIPES); + + /* Cleanup: delete all pipes created above */ + while (NumPipes > 0) + { + --NumPipes; + UtAssert_INT32_EQ(CFE_SB_DeletePipe(PipeId[NumPipes]), CFE_SUCCESS); + } } void TestPipeIndex(void) @@ -119,6 +169,7 @@ void TestPipeName(void) UtAssert_INT32_EQ(CFE_SB_GetPipeName(PipeNameBuf, sizeof(PipeNameBuf), CFE_SB_INVALID_PIPE), CFE_SB_BAD_ARGUMENT); UtAssert_INT32_EQ(CFE_SB_GetPipeIdByName(NULL, PipeName), CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_GetPipeIdByName(&PipeIdBuff, NULL), CFE_SB_BAD_ARGUMENT); UtAssert_INT32_EQ(CFE_SB_GetPipeIdByName(&PipeIdBuff, InvalidPipeName), CFE_SB_BAD_ARGUMENT); UtAssert_INT32_EQ(CFE_SB_DeletePipe(PipeId), CFE_SUCCESS); @@ -127,6 +178,7 @@ void TestPipeName(void) void SBPipeMangSetup(void) { UtTest_Add(TestPipeCreate, NULL, NULL, "Test Pipe Create"); + UtTest_Add(TestPipeCreateMax, NULL, NULL, "Test Pipe Create Max Limit"); UtTest_Add(TestPipeIndex, NULL, NULL, "Test Pipe Index"); UtTest_Add(TestPipeOptions, NULL, NULL, "Test Pipe Options"); UtTest_Add(TestPipeName, NULL, NULL, "Test Pipe Name"); diff --git a/modules/cfe_testcase/src/sb_sendrecv_test.c b/modules/cfe_testcase/src/sb_sendrecv_test.c index 699a73123..22607ceb2 100644 --- a/modules/cfe_testcase/src/sb_sendrecv_test.c +++ b/modules/cfe_testcase/src/sb_sendrecv_test.c @@ -34,6 +34,8 @@ #include "cfe_test.h" #include "cfe_msgids.h" +#define CFE_FT_STRINGBUF_SIZE 12 + /* A simple command message */ typedef struct { @@ -49,10 +51,13 @@ typedef struct } CFE_FT_TestTlmMessage_t; /* A message intended to be (overall) larger than the CFE_MISSION_SB_MAX_SB_MSG_SIZE */ -typedef struct +typedef union { - CFE_MSG_Message_t Hdr; - uint8 MaxSize[CFE_MISSION_SB_MAX_SB_MSG_SIZE]; + CFE_MSG_Message_t Hdr; + CFE_MSG_CommandHeader_t CmdHeader; + CFE_MSG_TelemetryHeader_t TlmHeader; + uint8 MaxSize[CFE_MISSION_SB_MAX_SB_MSG_SIZE + 16]; + char StringBuffer[CFE_FT_STRINGBUF_SIZE]; } CFE_FT_TestBigMessage_t; /* @@ -262,22 +267,109 @@ void TestZeroCopyTransmitRecv(void) CFE_UtAssert_MSGID_EQ(MsgId, CFE_FT_CMD_MSGID); UtAssert_ADDRESS_EQ(MsgBuf, CmdBuf); /* should be the same actual buffer (not a copy) */ - UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(&MsgBuf, PipeId1, 100), CFE_SB_TIME_OUT); + UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(&MsgBuf, PipeId1, CFE_SB_POLL), CFE_SB_NO_MESSAGE); UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(&MsgBuf, PipeId2, 100), CFE_SUCCESS); UtAssert_INT32_EQ(CFE_MSG_GetMsgId(&MsgBuf->Msg, &MsgId), CFE_SUCCESS); CFE_UtAssert_MSGID_EQ(MsgId, CFE_FT_TLM_MSGID); UtAssert_ADDRESS_EQ(MsgBuf, TlmBuf); /* should be the same actual buffer (not a copy) */ - UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(&MsgBuf, PipeId2, 100), CFE_SB_TIME_OUT); + UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(&MsgBuf, PipeId2, CFE_SB_POLL), CFE_SB_NO_MESSAGE); + + /* Attempt to send a msg of maximum size */ + UtAssert_NOT_NULL(CmdBuf = CFE_SB_AllocateMessageBuffer(CFE_MISSION_SB_MAX_SB_MSG_SIZE)); + + /* First initialize to indicate its even bigger than the max (should fail to transmit) */ + UtAssert_INT32_EQ(CFE_MSG_Init(&CmdBuf->Msg, CFE_FT_CMD_MSGID, sizeof(CFE_FT_BigMsg)), CFE_SUCCESS); + UtAssert_INT32_EQ(CFE_SB_TransmitBuffer(CmdBuf, true), CFE_SB_MSG_TOO_BIG); + + /* reducing size should make it work */ + UtAssert_INT32_EQ(CFE_MSG_SetSize(&CmdBuf->Msg, CFE_MISSION_SB_MAX_SB_MSG_SIZE), CFE_SUCCESS); + UtAssert_INT32_EQ(CFE_SB_TransmitBuffer(CmdBuf, true), CFE_SUCCESS); + UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(&MsgBuf, PipeId1, CFE_SB_POLL), CFE_SUCCESS); + UtAssert_ADDRESS_EQ(MsgBuf, CmdBuf); /* should be the same actual buffer (not a copy) */ + UtAssert_INT32_EQ(CFE_SB_ReceiveBuffer(&MsgBuf, PipeId1, CFE_SB_POLL), CFE_SB_NO_MESSAGE); /* Cleanup */ UtAssert_INT32_EQ(CFE_SB_DeletePipe(PipeId1), CFE_SUCCESS); UtAssert_INT32_EQ(CFE_SB_DeletePipe(PipeId2), CFE_SUCCESS); } +void TestMiscMessageUtils(void) +{ + char TestString[CFE_FT_STRINGBUF_SIZE + 4]; + const char RefString1[] = "abc"; + const char RefString2[] = "defg"; + + memset(&CFE_FT_BigMsg, 'x', sizeof(CFE_FT_BigMsg)); + memset(TestString, 'y', sizeof(TestString)); + + /* nominal CFE_SB_MessageStringGet */ + UtAssert_INT32_EQ(CFE_SB_MessageStringGet(TestString, CFE_FT_BigMsg.StringBuffer, RefString1, sizeof(TestString), + sizeof(CFE_FT_BigMsg.StringBuffer)), + CFE_FT_STRINGBUF_SIZE); + + /* The result should be null terminated, even if the input was not */ + UtAssert_ZERO(TestString[CFE_FT_STRINGBUF_SIZE]); + UtAssert_STRINGBUF_EQ(TestString, sizeof(TestString), CFE_FT_BigMsg.StringBuffer, + sizeof(CFE_FT_BigMsg.StringBuffer)); + + /* No default */ + memset(&CFE_FT_BigMsg, 'w', sizeof(CFE_FT_BigMsg)); + UtAssert_INT32_EQ(CFE_SB_MessageStringGet(TestString, CFE_FT_BigMsg.StringBuffer, NULL, sizeof(TestString), + sizeof(CFE_FT_BigMsg.StringBuffer)), + CFE_FT_STRINGBUF_SIZE); + UtAssert_STRINGBUF_EQ(TestString, sizeof(TestString), CFE_FT_BigMsg.StringBuffer, + sizeof(CFE_FT_BigMsg.StringBuffer)); + UtAssert_ZERO(TestString[CFE_FT_STRINGBUF_SIZE]); + UtAssert_STRINGBUF_EQ(TestString, sizeof(TestString), CFE_FT_BigMsg.StringBuffer, + sizeof(CFE_FT_BigMsg.StringBuffer)); + + /* Check if the input is empty */ + memset(&CFE_FT_BigMsg, 0, sizeof(CFE_FT_BigMsg)); + UtAssert_INT32_EQ(CFE_SB_MessageStringGet(TestString, CFE_FT_BigMsg.StringBuffer, RefString1, sizeof(TestString), + sizeof(CFE_FT_BigMsg.StringBuffer)), + sizeof(RefString1) - 1); + UtAssert_STRINGBUF_EQ(TestString, sizeof(TestString), RefString1, sizeof(RefString1)); + UtAssert_INT32_EQ(CFE_SB_MessageStringGet(TestString, NULL, RefString2, sizeof(TestString), 0), + sizeof(RefString2) - 1); + UtAssert_STRINGBUF_EQ(TestString, sizeof(TestString), RefString2, sizeof(RefString2)); + + /* Neither source nor default */ + UtAssert_INT32_EQ(CFE_SB_MessageStringGet(TestString, NULL, NULL, sizeof(TestString), 0), CFE_SUCCESS); + UtAssert_STRINGBUF_EQ(TestString, sizeof(TestString), "", 1); + + /* bad inputs */ + UtAssert_INT32_EQ(CFE_SB_MessageStringGet(NULL, CFE_FT_BigMsg.StringBuffer, RefString1, sizeof(TestString), + sizeof(CFE_FT_BigMsg.StringBuffer)), + CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_MessageStringGet(TestString, CFE_FT_BigMsg.StringBuffer, RefString1, 0, + sizeof(CFE_FT_BigMsg.StringBuffer)), + CFE_SB_BAD_ARGUMENT); + + /* nominal CFE_SB_MessageStringSet */ + memset(TestString, 'z', sizeof(TestString)); + UtAssert_INT32_EQ(CFE_SB_MessageStringSet(CFE_FT_BigMsg.StringBuffer, TestString, + sizeof(CFE_FT_BigMsg.StringBuffer), sizeof(TestString)), + CFE_FT_STRINGBUF_SIZE); + UtAssert_STRINGBUF_EQ(TestString, CFE_FT_STRINGBUF_SIZE, CFE_FT_BigMsg.StringBuffer, CFE_FT_STRINGBUF_SIZE); + + /* The result should NOT be null terminated (fixed size msg string does not need it) */ + UtAssert_INT32_EQ(CFE_FT_BigMsg.StringBuffer[sizeof(CFE_FT_BigMsg.StringBuffer) - 1], 'z'); + /* Should not have overwritten anything beyond the fixed buffer */ + UtAssert_ZERO(CFE_FT_BigMsg.MaxSize[sizeof(CFE_FT_BigMsg.StringBuffer)]); + + /* bad inputs */ + UtAssert_INT32_EQ(CFE_SB_MessageStringSet(NULL, TestString, sizeof(CFE_FT_BigMsg.StringBuffer), sizeof(TestString)), + CFE_SB_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_SB_MessageStringSet(CFE_FT_BigMsg.StringBuffer, NULL, sizeof(CFE_FT_BigMsg.StringBuffer), + sizeof(TestString)), + CFE_SB_BAD_ARGUMENT); +} + void SBSendRecvTestSetup(void) { UtTest_Add(TestBasicTransmitRecv, NULL, NULL, "Test Basic Transmit/Receive"); UtTest_Add(TestZeroCopyTransmitRecv, NULL, NULL, "Test Zero Copy Transmit/Receive"); -} + UtTest_Add(TestMiscMessageUtils, NULL, NULL, "Test Miscellaneous Message Utility APIs"); +} \ No newline at end of file diff --git a/modules/cfe_testcase/src/sb_subscription_test.c b/modules/cfe_testcase/src/sb_subscription_test.c index 7fe51de5d..8e1745272 100644 --- a/modules/cfe_testcase/src/sb_subscription_test.c +++ b/modules/cfe_testcase/src/sb_subscription_test.c @@ -238,11 +238,56 @@ void TestSBMaxSubscriptions(void) UtAssert_INT32_EQ(CFE_SB_DeletePipe(PipeId), CFE_SUCCESS); } +/* This is a different flavor of the subscription limit - a single msgid can only + * have up to CFE_PLATFORM_SB_MAX_DEST_PER_PKT destinations */ +void TestSBMaxDestinations(void) +{ + CFE_SB_PipeId_t PipeId[CFE_PLATFORM_SB_MAX_DEST_PER_PKT + 1]; + char PipeName[CFE_MISSION_MAX_API_LEN]; + uint32 NumDests; + + UtPrintf("Testing: CFE_SB_Subscribe, max destination limit"); + + NumDests = 0; + while (NumDests <= CFE_PLATFORM_SB_MAX_DEST_PER_PKT) + { + snprintf(PipeName, sizeof(PipeName), "TestPipe%u", (unsigned int)NumDests); + if (!UtAssert_INT32_EQ(CFE_SB_CreatePipe(&PipeId[NumDests], 2, PipeName), CFE_SUCCESS)) + { + break; + } + + if (NumDests == CFE_PLATFORM_SB_MAX_DEST_PER_PKT) + { + /* All 3 variations of subscribe can be checked here, they should all fail identically */ + UtAssert_INT32_EQ(CFE_SB_Subscribe(CFE_FT_CMD_MSGID, PipeId[NumDests]), CFE_SB_MAX_DESTS_MET); + UtAssert_INT32_EQ(CFE_SB_SubscribeEx(CFE_FT_CMD_MSGID, PipeId[NumDests], CFE_SB_DEFAULT_QOS, 2), + CFE_SB_MAX_DESTS_MET); + UtAssert_INT32_EQ(CFE_SB_SubscribeLocal(CFE_FT_CMD_MSGID, PipeId[NumDests], 2), CFE_SB_MAX_DESTS_MET); + } + else + { + UtAssert_INT32_EQ(CFE_SB_Subscribe(CFE_FT_CMD_MSGID, PipeId[NumDests]), CFE_SUCCESS); + } + + ++NumDests; + } + + while (NumDests > 0) + { + --NumDests; + + /* Note this should also remove any subscriptions from the above loop */ + UtAssert_INT32_EQ(CFE_SB_DeletePipe(PipeId[NumDests]), CFE_SUCCESS); + } +} + void SBSubscriptionTestSetup(void) { UtTest_Add(TestSubscribeUnsubscribe, NULL, NULL, "Test SB Subscribe/Unsubscribe"); UtTest_Add(TestSubscribeUnsubscribeLocal, NULL, NULL, "Test SB SubscribeLocal/UnsubscribeLocal"); UtTest_Add(TestSubscribeEx, NULL, NULL, "Test SB SubscribeEx"); + UtTest_Add(TestSBMaxDestinations, NULL, NULL, "Test SB Max Destinations"); /* * NOTE: The TestSBMaxSubscriptions() is not included/added by default, as it will fill the diff --git a/modules/core_api/fsw/inc/cfe_sb.h b/modules/core_api/fsw/inc/cfe_sb.h index 6f11d8029..53c80348b 100644 --- a/modules/core_api/fsw/inc/cfe_sb.h +++ b/modules/core_api/fsw/inc/cfe_sb.h @@ -259,10 +259,10 @@ CFE_Status_t CFE_SB_GetPipeIdByName(CFE_SB_PipeId_t *PipeIdPtr, const char *Pipe ** ** \return Execution status, see \ref CFEReturnCodes ** \retval #CFE_SUCCESS \copybrief CFE_SUCCESS -** \retval #CFE_SB_MAX_MSGS_MET \copybrief CFE_SB_MAX_MSGS_MET +** \retval #CFE_SB_MAX_MSGS_MET \covtest \copybrief CFE_SB_MAX_MSGS_MET ** \retval #CFE_SB_MAX_DESTS_MET \copybrief CFE_SB_MAX_DESTS_MET ** \retval #CFE_SB_BAD_ARGUMENT \copybrief CFE_SB_BAD_ARGUMENT -** \retval #CFE_SB_BUF_ALOC_ERR \copybrief CFE_SB_BUF_ALOC_ERR +** \retval #CFE_SB_BUF_ALOC_ERR \covtest \copybrief CFE_SB_BUF_ALOC_ERR ** ** \sa #CFE_SB_Subscribe, #CFE_SB_SubscribeLocal, #CFE_SB_Unsubscribe, #CFE_SB_UnsubscribeLocal **/ @@ -294,10 +294,10 @@ CFE_Status_t CFE_SB_SubscribeEx(CFE_SB_MsgId_t MsgId, CFE_SB_PipeId_t PipeId, CF ** ** \return Execution status, see \ref CFEReturnCodes ** \retval #CFE_SUCCESS \copybrief CFE_SUCCESS -** \retval #CFE_SB_MAX_MSGS_MET \copybrief CFE_SB_MAX_MSGS_MET +** \retval #CFE_SB_MAX_MSGS_MET \covtest \copybrief CFE_SB_MAX_MSGS_MET ** \retval #CFE_SB_MAX_DESTS_MET \copybrief CFE_SB_MAX_DESTS_MET ** \retval #CFE_SB_BAD_ARGUMENT \copybrief CFE_SB_BAD_ARGUMENT -** \retval #CFE_SB_BUF_ALOC_ERR \copybrief CFE_SB_BUF_ALOC_ERR +** \retval #CFE_SB_BUF_ALOC_ERR \covtest \copybrief CFE_SB_BUF_ALOC_ERR ** ** \sa #CFE_SB_SubscribeEx, #CFE_SB_SubscribeLocal, #CFE_SB_Unsubscribe, #CFE_SB_UnsubscribeLocal **/ @@ -329,10 +329,10 @@ CFE_Status_t CFE_SB_Subscribe(CFE_SB_MsgId_t MsgId, CFE_SB_PipeId_t PipeId); ** ** \return Execution status, see \ref CFEReturnCodes ** \retval #CFE_SUCCESS \copybrief CFE_SUCCESS -** \retval #CFE_SB_MAX_MSGS_MET \copybrief CFE_SB_MAX_MSGS_MET +** \retval #CFE_SB_MAX_MSGS_MET \covtest \copybrief CFE_SB_MAX_MSGS_MET ** \retval #CFE_SB_MAX_DESTS_MET \copybrief CFE_SB_MAX_DESTS_MET ** \retval #CFE_SB_BAD_ARGUMENT \copybrief CFE_SB_BAD_ARGUMENT -** \retval #CFE_SB_BUF_ALOC_ERR \copybrief CFE_SB_BUF_ALOC_ERR +** \retval #CFE_SB_BUF_ALOC_ERR \covtest \copybrief CFE_SB_BUF_ALOC_ERR ** ** \sa #CFE_SB_Subscribe, #CFE_SB_SubscribeEx, #CFE_SB_Unsubscribe, #CFE_SB_UnsubscribeLocal **/ @@ -357,7 +357,7 @@ CFE_Status_t CFE_SB_SubscribeLocal(CFE_SB_MsgId_t MsgId, CFE_SB_PipeId_t PipeId, ** ** \return Execution status, see \ref CFEReturnCodes ** \retval #CFE_SUCCESS \copybrief CFE_SUCCESS -** \retval #CFE_SB_INTERNAL_ERR \copybrief CFE_SB_INTERNAL_ERR +** \retval #CFE_SB_BAD_ARGUMENT \copybrief CFE_SB_BAD_ARGUMENT ** ** \sa #CFE_SB_Subscribe, #CFE_SB_SubscribeEx, #CFE_SB_SubscribeLocal, #CFE_SB_UnsubscribeLocal **/ @@ -383,7 +383,7 @@ CFE_Status_t CFE_SB_Unsubscribe(CFE_SB_MsgId_t MsgId, CFE_SB_PipeId_t PipeId); ** ** \return Execution status, see \ref CFEReturnCodes ** \retval #CFE_SUCCESS \copybrief CFE_SUCCESS -** \retval #CFE_SB_INTERNAL_ERR \copybrief CFE_SB_INTERNAL_ERR +** \retval #CFE_SB_BAD_ARGUMENT \copybrief CFE_SB_BAD_ARGUMENT ** ** \sa #CFE_SB_Subscribe, #CFE_SB_SubscribeEx, #CFE_SB_SubscribeLocal, #CFE_SB_Unsubscribe **/ @@ -421,7 +421,7 @@ CFE_Status_t CFE_SB_UnsubscribeLocal(CFE_SB_MsgId_t MsgId, CFE_SB_PipeId_t PipeI ** \retval #CFE_SUCCESS \copybrief CFE_SUCCESS ** \retval #CFE_SB_BAD_ARGUMENT \copybrief CFE_SB_BAD_ARGUMENT ** \retval #CFE_SB_MSG_TOO_BIG \copybrief CFE_SB_MSG_TOO_BIG -** \retval #CFE_SB_BUF_ALOC_ERR \copybrief CFE_SB_BUF_ALOC_ERR +** \retval #CFE_SB_BUF_ALOC_ERR \covtest \copybrief CFE_SB_BUF_ALOC_ERR **/ CFE_Status_t CFE_SB_TransmitMsg(const CFE_MSG_Message_t *MsgPtr, bool IncrementSequenceCount); @@ -461,7 +461,7 @@ CFE_Status_t CFE_SB_TransmitMsg(const CFE_MSG_Message_t *MsgPtr, bool IncrementS ** \retval #CFE_SUCCESS \copybrief CFE_SUCCESS ** \retval #CFE_SB_BAD_ARGUMENT \copybrief CFE_SB_BAD_ARGUMENT ** \retval #CFE_SB_TIME_OUT \copybrief CFE_SB_TIME_OUT -** \retval #CFE_SB_PIPE_RD_ERR \copybrief CFE_SB_PIPE_RD_ERR +** \retval #CFE_SB_PIPE_RD_ERR \covtest \copybrief CFE_SB_PIPE_RD_ERR ** \retval #CFE_SB_NO_MESSAGE \copybrief CFE_SB_NO_MESSAGE **/ CFE_Status_t CFE_SB_ReceiveBuffer(CFE_SB_Buffer_t **BufPtr, CFE_SB_PipeId_t PipeId, int32 TimeOut); @@ -717,9 +717,9 @@ size_t CFE_SB_GetUserDataLength(const CFE_MSG_Message_t *MsgPtr); ** truncated, but it will still be null terminated. ** ** \param[out] DestStringPtr Pointer to destination buffer @nonnull -** \param[in] SourceStringPtr Pointer to source buffer (component of SB message definition) @nonnull +** \param[in] SourceStringPtr Pointer to source buffer (component of SB message definition) ** \param[in] DefaultString Default string to use if source is empty -** \param[in] DestMaxSize Size of destination storage buffer (must be at least 2) +** \param[in] DestMaxSize Size of destination storage buffer @nonzero ** \param[in] SourceMaxSize Size of source buffer as defined by the message definition ** ** \return Number of characters copied or error code, see \ref CFEReturnCodes