nasa · astrogeco · Aug 24, 2021 · Aug 13, 2021
diff --git 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
@@ -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");
+}
diff --git 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
@@ -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