diff --git a/README.md b/README.md index 0de722f20..193d0ad04 100644 --- a/README.md +++ b/README.md @@ -10,6 +10,18 @@ The detailed cFE user's guide can be viewed at and + ### Development Build: v6.8.0-rc1+dev789 - Correct return code check diff --git a/docs/cFE_FunctionalRequirements.csv b/docs/cFE_FunctionalRequirements.csv index 3cc9009ae..9197e107e 100644 --- a/docs/cFE_FunctionalRequirements.csv +++ b/docs/cFE_FunctionalRequirements.csv @@ -350,7 +350,6 @@ SB: Receive Message No Timeout,cSB4306,"Upon receipt of a Request to receive a S SB: Receive Message With Timeout,cSB4307,"Upon receipt of a Request to receive a SB Message from a Pipe with a pending timeout, the cFE shall suspend execution of the Application until a SB Message is present on the Pipe or the timeout has expired.","A receive Request with a suspension timeout provides a blocking method of retrieving SB messages. This is useful for data driven Applications and has been used on all heritage missions with a SB. The timeout is useful for fault recovery for Applications that always expect data to arrive or to allow periodic processing for Applications that are not purely data driven. If a SB Message is queued on the Pipe then the SB Message will be provided to the Application and the Application’s execution will not be suspended. Tasks that process telemetry packets often receive many types of packets from different sources. There should be a mechanism that allows a task to wait for many different types of messages simultaneously. Heritage implementations of SB do this by directing the messages into one queue (or several queues, to implement priority levels). " SB: Receive Message Infinite Timeout,cSB4308,"Upon receipt of a Request to receive a SB Message from a Pipe with an infinite timeout, the cFE shall suspend execution of the Application until a SB Message is present on the Pipe.",This mode of receiving has been the most commonly used mode on the heritage SB. -SB: Last Message Sender Info,cSB4309,"Upon receipt of a Request, the cFE shall provide sender information for the last message received on an Application's Pipe.","Heritage SB did a 'valid senders check' before delivering a packet to a pipe. Since the cFE supports a dynamic environment and the sender of a packet is somewhat unknown, the cFE must provide a means for the application to do the 'valid sender check'." SB: Get Message ID,cSB4311,"Upon receipt of a Request, the cFE shall provide the message ID of the requested message.",Message management utility. SB: Set Message ID,cSB4312,"Upon receipt of a Request, the cFE shall set the received message with the received message ID.",Message management utility. SB: Get Message String,cSB4313,"Upon receipt of a Request, the cFE shall provide the requested string from the requested message.",Message management utility. diff --git a/modules/cfe_testcase/CMakeLists.txt b/modules/cfe_testcase/CMakeLists.txt index 1318d7926..8189dba9b 100644 --- a/modules/cfe_testcase/CMakeLists.txt +++ b/modules/cfe_testcase/CMakeLists.txt @@ -7,11 +7,14 @@ add_cfe_app(cfe_testcase src/es_cds_test.c src/es_misc_test.c src/es_mempool_test.c + src/evs_send_test.c src/fs_header_test.c src/fs_util_test.c + src/message_id_test.c src/sb_pipe_mang_test.c src/time_arithmetic_test.c src/time_current_test.c + src/time_conversion_test.c ) # register the dependency on cfe_assert diff --git a/modules/cfe_testcase/src/cfe_test.c b/modules/cfe_testcase/src/cfe_test.c index 016eadc57..b1dbe4767 100644 --- a/modules/cfe_testcase/src/cfe_test.c +++ b/modules/cfe_testcase/src/cfe_test.c @@ -56,11 +56,14 @@ void CFE_TestMain(void) ESMemPoolTestSetup(); ESMiscTestSetup(); ESTaskTestSetup(); + EVSSendTestSetup(); FSHeaderTestSetup(); FSUtilTestSetup(); + MessageIdTestSetup(); SBPipeMangSetup(); TimeArithmeticTestSetup(); TimeCurrentTestSetup(); + TimeConversionTestSetup(); /* * Execute the tests diff --git a/modules/cfe_testcase/src/cfe_test.h b/modules/cfe_testcase/src/cfe_test.h index e661c6849..558b0a1f6 100644 --- a/modules/cfe_testcase/src/cfe_test.h +++ b/modules/cfe_testcase/src/cfe_test.h @@ -77,16 +77,21 @@ typedef struct /* Log calls to void functions */ #define cFE_FTAssert_VOIDCALL(func) (func, UtAssert(true, #func, __FILE__, __LINE__)) +bool TimeInRange(CFE_TIME_SysTime_t Time, CFE_TIME_SysTime_t Target, OS_time_t difference); + void CFE_TestMain(void); void ESCDSTestSetup(void); void ESInfoTestSetup(void); void ESMemPoolTestSetup(void); void ESMiscTestSetup(void); void ESTaskTestSetup(void); +void EVSSendTestSetup(void); void FSHeaderTestSetup(void); void FSUtilTestSetup(void); +void MessageIdTestSetup(void); void SBPipeMangSetup(void); void TimeArithmeticTestSetup(void); void TimeCurrentTestSetup(void); +void TimeConversionTestSetup(void); #endif /* CFE_TEST_H */ diff --git a/modules/cfe_testcase/src/es_misc_test.c b/modules/cfe_testcase/src/es_misc_test.c index f86d660d6..61073a2e1 100644 --- a/modules/cfe_testcase/src/es_misc_test.c +++ b/modules/cfe_testcase/src/es_misc_test.c @@ -64,8 +64,7 @@ void TestWriteToSysLog(void) CFE_ES_WriteToSysLog(NULL); CFE_ES_WriteToSysLog("%s", TestString); - UtAssertEx(false, UTASSERT_CASETYPE_MIR, __FILE__, __LINE__, "%s", - "MIR (Manual Inspection Required) for CFE_ES_WriteToSysLog"); + UtAssert_MIR("MIR (Manual Inspection Required) for CFE_ES_WriteToSysLog"); } void ESMiscTestSetup(void) diff --git a/modules/cfe_testcase/src/evs_send_test.c b/modules/cfe_testcase/src/evs_send_test.c new file mode 100644 index 000000000..bd25184c1 --- /dev/null +++ b/modules/cfe_testcase/src/evs_send_test.c @@ -0,0 +1,74 @@ +/************************************************************************* +** +** GSC-18128-1, "Core Flight Executive Version 6.7" +** +** Copyright (c) 2006-2019 United States Government as represented by +** the Administrator of the National Aeronautics and Space Administration. +** All Rights Reserved. +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +** +** File: evs_send_test.c +** +** Purpose: +** Functional test of basic EVS Send Event APIs +** +** Demonstration of how to register and use the UT assert functions. +** +*************************************************************************/ + +/* + * Includes + */ + +#include "cfe_test.h" + +void TestSendEvent(void) +{ + UtPrintf("Testing: CFE_EVS_SendEvent"); + + UtAssert_INT32_EQ(CFE_EVS_SendEvent(0, CFE_EVS_EventType_INFORMATION, "OK Send"), CFE_SUCCESS); + UtAssert_INT32_EQ(CFE_EVS_SendEvent(0, CFE_EVS_EventType_INFORMATION, NULL), CFE_EVS_INVALID_PARAMETER); +} + +void TestSendEventAppID(void) +{ + CFE_ES_AppId_t AppId; + + UtPrintf("Testing: CFE_EVS_SendEventWithAppID"); + + CFE_ES_GetAppID(&AppId); + + UtAssert_INT32_EQ(CFE_EVS_SendEventWithAppID(0, CFE_EVS_EventType_INFORMATION, AppId, "OK App ID"), CFE_SUCCESS); + + UtAssert_INT32_EQ(CFE_EVS_SendEventWithAppID(0, CFE_EVS_EventType_INFORMATION, AppId, NULL), + CFE_EVS_INVALID_PARAMETER); + UtAssert_INT32_EQ(CFE_EVS_SendEventWithAppID(0, CFE_EVS_EventType_INFORMATION, CFE_ES_APPID_UNDEFINED, "OK"), + CFE_EVS_APP_ILLEGAL_APP_ID); +} + +void TestSendTimedEvent(void) +{ + CFE_TIME_SysTime_t Time = {1000, 1000}; + UtPrintf("Testing: CFE_EVS_SendTimedEvent"); + + UtAssert_INT32_EQ(CFE_EVS_SendTimedEvent(Time, 0, CFE_EVS_EventType_INFORMATION, "OK Time"), CFE_SUCCESS); + UtAssert_INT32_EQ(CFE_EVS_SendTimedEvent(Time, 0, CFE_EVS_EventType_INFORMATION, NULL), CFE_EVS_INVALID_PARAMETER); +} + +void EVSSendTestSetup(void) +{ + UtTest_Add(TestSendEvent, NULL, NULL, "Test Send Event"); + UtTest_Add(TestSendEventAppID, NULL, NULL, "Test Send Event with App ID"); + UtTest_Add(TestSendTimedEvent, NULL, NULL, "Test Send Timed Event"); +} diff --git a/modules/cfe_testcase/src/fs_header_test.c b/modules/cfe_testcase/src/fs_header_test.c index ef7499891..cf89387e7 100644 --- a/modules/cfe_testcase/src/fs_header_test.c +++ b/modules/cfe_testcase/src/fs_header_test.c @@ -56,6 +56,7 @@ void TestCreateHeader(void) cFE_FTAssert_VOIDCALL(CFE_FS_InitHeader(&Header, TestDescription, CFE_FS_SubType_ES_ERLOG)); UtAssert_INT32_EQ(CFE_FS_WriteHeader(fd, &Header), sizeof(CFE_FS_Header_t)); + UtAssert_INT32_EQ(OS_lseek(fd, 0, OS_SEEK_CUR), sizeof(CFE_FS_Header_t)); UtAssert_INT32_EQ(CFE_FS_WriteHeader(fd, NULL), CFE_FS_BAD_ARGUMENT); cFE_FTAssert_NOT_CFE_SUCCESS(CFE_FS_WriteHeader(OS_OBJECT_ID_UNDEFINED, &Header)); @@ -80,6 +81,7 @@ void TestReadHeader(void) cFE_FTAssert_VOIDCALL(CFE_FS_InitHeader(&Header, TestDescription, CFE_FS_SubType_ES_ERLOG)); UtAssert_INT32_EQ(CFE_FS_WriteHeader(fd, &Header), sizeof(CFE_FS_Header_t)); UtAssert_INT32_EQ(CFE_FS_ReadHeader(&ReadHeader, fd), sizeof(CFE_FS_Header_t)); + UtAssert_INT32_EQ(OS_lseek(fd, 0, OS_SEEK_CUR), sizeof(CFE_FS_Header_t)); UtAssert_INT32_EQ(Header.ContentType, ReadHeader.ContentType); UtAssert_INT32_EQ(Header.SubType, ReadHeader.SubType); @@ -105,6 +107,8 @@ void TestTimeStamp(void) cFE_FTAssert_VOIDCALL(CFE_FS_InitHeader(&Header, TestDescription, CFE_FS_SubType_ES_ERLOG)); UtAssert_INT32_EQ(CFE_FS_WriteHeader(fd, &Header), sizeof(CFE_FS_Header_t)); UtAssert_INT32_EQ(CFE_FS_SetTimestamp(fd, NewTimestamp), CFE_SUCCESS); + UtAssert_INT32_EQ(OS_lseek(fd, 0, OS_SEEK_CUR), (offsetof(CFE_FS_Header_t, TimeSeconds) + sizeof(NewTimestamp))); + UtAssert_INT32_EQ(CFE_FS_ReadHeader(&ReadHeader, fd), sizeof(CFE_FS_Header_t)); UtAssert_UINT32_EQ(0xFFFFFFFF, ReadHeader.TimeSeconds); diff --git a/modules/cfe_testcase/src/message_id_test.c b/modules/cfe_testcase/src/message_id_test.c new file mode 100644 index 000000000..6561aea8e --- /dev/null +++ b/modules/cfe_testcase/src/message_id_test.c @@ -0,0 +1,83 @@ +/************************************************************************* +** +** GSC-18128-1, "Core Flight Executive Version 6.7" +** +** Copyright (c) 2006-2019 United States Government as represented by +** the Administrator of the National Aeronautics and Space Administration. +** All Rights Reserved. +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +** +** File: message_id_test.c +** +** Purpose: +** Functional test of Message ID APIs +** +** Demonstration.... +** +*************************************************************************/ + +/* + * Includes + */ + +#include "cfe_test.h" + +void TestMsgId(void) +{ + UtPrintf("Testing: CFE_MSG_SetMsgId, CFE_MSG_GetMsgId"); + CFE_MSG_Message_t msg; + CFE_SB_MsgId_t msgid; + CFE_SB_MsgId_t expectedmsgid = CFE_SB_ValueToMsgId(1); + + UtAssert_INT32_EQ(CFE_MSG_SetMsgId(&msg, expectedmsgid), CFE_SUCCESS); + UtAssert_INT32_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + UtAssert_UINT32_EQ(msgid, expectedmsgid); + + UtAssert_INT32_EQ(CFE_MSG_SetMsgId(NULL, msgid), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_SetMsgId(&msg, CFE_SB_INVALID_MSG_ID), CFE_MSG_BAD_ARGUMENT); + + UtAssert_INT32_EQ(CFE_MSG_GetMsgId(NULL, &msgid), CFE_MSG_BAD_ARGUMENT); + UtAssert_INT32_EQ(CFE_MSG_GetMsgId(&msg, NULL), CFE_MSG_BAD_ARGUMENT); +} + +void TestGetTypeFromMsgId(void) +{ + UtPrintf("Testing: CFE_MSG_GetTypeFromMsgId"); + CFE_SB_MsgId_t msgid = CFE_SB_ValueToMsgId(0); + CFE_MSG_Type_t msgtype; + int32 status; + + /* + * Response not verified because msgid 0 could be out of range based on implementation and + * the msg to type relationship is also implementation defined, black box test just calls the routine + * to confirm things don't "break" with full range values and the implementation exists. + */ + + status = CFE_MSG_GetTypeFromMsgId(msgid, &msgtype); + UtAssert_True(status == CFE_SUCCESS || status == CFE_MSG_BAD_ARGUMENT, "CFE_MSG_GetTypeFromMsgId() == (%ld)", + (long)status); + + memset(&msgid, 0xFF, sizeof(msgid)); + status = CFE_MSG_GetTypeFromMsgId(msgid, &msgtype); + UtAssert_True(status == CFE_SUCCESS || status == CFE_MSG_BAD_ARGUMENT, "CFE_MSG_GetTypeFromMsgId() == (%ld)", + (long)status); + + UtAssert_INT32_EQ(CFE_MSG_GetTypeFromMsgId(msgid, NULL), CFE_MSG_BAD_ARGUMENT); +} + +void MessageIdTestSetup(void) +{ + UtTest_Add(TestMsgId, NULL, NULL, "Test Set/Get Message ID"); + UtTest_Add(TestGetTypeFromMsgId, NULL, NULL, "Test Get Type From Message ID"); +} \ No newline at end of file diff --git a/modules/cfe_testcase/src/time_conversion_test.c b/modules/cfe_testcase/src/time_conversion_test.c new file mode 100644 index 000000000..528fdf681 --- /dev/null +++ b/modules/cfe_testcase/src/time_conversion_test.c @@ -0,0 +1,135 @@ +/************************************************************************* +** +** GSC-18128-1, "Core Flight Executive Version 6.7" +** +** Copyright (c) 2006-2021 United States Government as represented by +** the Administrator of the National Aeronautics and Space Administration. +** All Rights Reserved. +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +** +** File: time_conversion_test.c +** +** Purpose: +** Functional test of basic Time Conversion APIs +** +*************************************************************************/ + +/* + * Includes + */ +#include "cfe_test.h" + +void TestConvertMET2SCTime(void) +{ + UtPrintf("Testing: CFE_TIME_MET2SCTime"); + + /* Mission Elapsed Time */ + CFE_TIME_SysTime_t MET; + /* MET + SCTF */ + CFE_TIME_SysTime_t TAI; + /* MET + SCTF - Leap Seconds */ + CFE_TIME_SysTime_t UTC; + /* Spacecraft Time */ + CFE_TIME_SysTime_t SCTime; + + OS_time_t start; + OS_time_t end; + OS_time_t difference; + + /* Print buffers */ + char timeBuf1[sizeof("yyyy-ddd-hh:mm:ss.xxxxx_")]; + char timeBuf2[sizeof("yyyy-ddd-hh:mm:ss.xxxxx_")]; + + OS_GetLocalTime(&start); + + /* Get Times */ + MET = CFE_TIME_GetMET(); + TAI = CFE_TIME_GetTAI(); + UTC = CFE_TIME_GetUTC(); + + OS_GetLocalTime(&end); + + /* Convert - should produce a TAI or UTC at the moment of GetMET() */ + SCTime = CFE_TIME_MET2SCTime(MET); + + /* write Spacecraft Time into second buffer */ + CFE_TIME_Print(timeBuf2, SCTime); + + difference = OS_TimeSubtract(end, start); + + /* Check conversion */ +#if (CFE_MISSION_TIME_CFG_DEFAULT_TAI == true) + /* SCTime is TAI format */ + + /* avoid unused compiler warning */ + (void)UTC; + + /* write TAI into first buffer */ + CFE_TIME_Print(timeBuf1, TAI); + + UtAssert_True(TimeInRange(SCTime, TAI, difference), "TAI (%s) = MET2SCTime (%s)", timeBuf1, timeBuf2); +#else + /* SCTime is UTC format */ + + /* avoid unused compiler warning */ + (void)TAI; + + /* write UTC into first buffer */ + CFE_TIME_Print(timeBuf1, UTC); + + UtAssert_True(TimeInRange(SCTime, UTC, difference), "UTC (%s) = MET2SCTime (%s)", timeBuf1, timeBuf2); +#endif +} + +void TestConvertSubSeconds2MicroSeconds(void) +{ + UtPrintf("Testing: CFE_TIME_Sub2MicroSecs"); + + /* predefined amount of sub-seconds */ + uint32 SUB = 31000; + /* correct micro-seconds equal to the predefined sub-seconds */ + uint32 ExpectedMS = 7; + uint32 Sub2Micro; + + /* run Sub2MicroSecs with predefined amount of sub-seconds and save result */ + Sub2Micro = CFE_TIME_Sub2MicroSecs(SUB); + + UtAssert_UINT32_EQ(ExpectedMS, Sub2Micro); +} + +void TestConvertMicroSeconds2SubSeconds(void) +{ + UtPrintf("Testing: CFE_TIME_Micro2SubSecs"); + + /* predefined micro-seconds */ + uint32 MS = 64512; + /* predefined sub-seconds equal to predefined ms above */ + uint32 ExpectedSUB = 277076931; + uint32 Micro2Sub; + + /* convert and assert */ + Micro2Sub = CFE_TIME_Micro2SubSecs(MS); + UtAssert_UINT32_EQ(ExpectedSUB, Micro2Sub); + + /* assert for ms > 999999 >= 1 second */ + Micro2Sub = CFE_TIME_Micro2SubSecs(999999 + 1); + UtAssert_UINT32_EQ(0xFFFFFFFF, Micro2Sub); +} + +void TimeConversionTestSetup(void) +{ + UtTest_Add(TestConvertMET2SCTime, NULL, NULL, "Test convert MET into spacecraft time"); + UtTest_Add(TestConvertSubSeconds2MicroSeconds, NULL, NULL, "Test Convert sub-seconds into micro-seconds"); + UtTest_Add(TestConvertMicroSeconds2SubSeconds, NULL, NULL, "Test Convert micro-seconds into sub-seconds"); +} diff --git a/modules/core_api/fsw/inc/cfe_fs.h b/modules/core_api/fsw/inc/cfe_fs.h index c89a884ed..d55cfb5ba 100644 --- a/modules/core_api/fsw/inc/cfe_fs.h +++ b/modules/core_api/fsw/inc/cfe_fs.h @@ -57,6 +57,8 @@ ** \par Assumptions, External Events, and Notes: ** -# The File has already been successfully opened using #OS_OpenCreate and ** the caller has a legitimate File Descriptor. +** -# File offset behavior: Agnostic on entry since it will move the offset to the start of the file, +** on success the offset will be at the end of the header, undefined offset behavior for error cases. ** ** \param[in, out] Hdr Pointer to a variable of type #CFE_FS_Header_t that will be ** filled with the contents of the Standard cFE File Header. *Hdr is the contents of the @@ -120,6 +122,8 @@ void CFE_FS_InitHeader(CFE_FS_Header_t *Hdr, const char *Description, uint32 Sub ** the caller has a legitimate File Descriptor. ** -# The \c SubType field has been filled appropriately by the Application. ** -# The \c Description field has been filled appropriately by the Application. +** -# File offset behavior: Agnostic on entry since it will move the offset to the start of the file, +** on success the offset will be at the end of the header, undefined offset behavior for error cases. ** ** \param[in] FileDes File Descriptor obtained from a previous call to #OS_OpenCreate ** that is associated with the file whose header is to be read. @@ -152,6 +156,8 @@ CFE_Status_t CFE_FS_WriteHeader(osal_id_t FileDes, CFE_FS_Header_t *Hdr); ** -# The File has already been successfully opened using #OS_OpenCreate and ** the caller has a legitimate File Descriptor. ** -# The \c NewTimestamp field has been filled appropriately by the Application. +** -# File offset behavior: Agnostic on entry since it will move the offset, +** on success the offset will be at the end of the time stamp, undefined offset behavior for error cases. ** ** \param[in] FileDes File Descriptor obtained from a previous call to #OS_OpenCreate ** that is associated with the file whose header is to be read. diff --git a/modules/core_api/fsw/inc/cfe_version.h b/modules/core_api/fsw/inc/cfe_version.h index 07583ddc9..763966e2e 100644 --- a/modules/core_api/fsw/inc/cfe_version.h +++ b/modules/core_api/fsw/inc/cfe_version.h @@ -28,7 +28,7 @@ #define CFE_VERSION_H /* Development Build Macro Definitions */ -#define CFE_BUILD_NUMBER 789 /**< @brief Development: Number of development commits since baseline */ +#define CFE_BUILD_NUMBER 810 /**< @brief Development: Number of development commits since baseline */ #define CFE_BUILD_BASELINE "v6.8.0-rc1" /**< @brief Development: Reference git tag for build number */ /* Version Macro Definitions updated for official releases only */ diff --git a/modules/msg/fsw/src/cfe_msg_msgid_shared.c b/modules/msg/fsw/src/cfe_msg_msgid_shared.c index 84ebb1d94..0aa29e92c 100644 --- a/modules/msg/fsw/src/cfe_msg_msgid_shared.c +++ b/modules/msg/fsw/src/cfe_msg_msgid_shared.c @@ -35,8 +35,8 @@ *-----------------------------------------------------------------*/ CFE_Status_t CFE_MSG_GetTypeFromMsgId(CFE_SB_MsgId_t MsgId, CFE_MSG_Type_t *Type) { - CFE_MSG_Message_t msg; + int32 Status; /* Memset to initialize avoids possible GCC bug 53119 */ memset(&msg, 0, sizeof(msg)); @@ -46,8 +46,11 @@ CFE_Status_t CFE_MSG_GetTypeFromMsgId(CFE_SB_MsgId_t MsgId, CFE_MSG_Type_t *Type return CFE_MSG_BAD_ARGUMENT; } - CFE_MSG_SetMsgId(&msg, MsgId); - CFE_MSG_GetType(&msg, Type); + Status = CFE_MSG_SetMsgId(&msg, MsgId); + if (Status == CFE_SUCCESS) + { + Status = CFE_MSG_GetType(&msg, Type); + } - return CFE_SUCCESS; + return Status; } diff --git a/modules/tbl/fsw/src/cfe_tbl_api.c b/modules/tbl/fsw/src/cfe_tbl_api.c index c51f7188b..9bac32276 100644 --- a/modules/tbl/fsw/src/cfe_tbl_api.c +++ b/modules/tbl/fsw/src/cfe_tbl_api.c @@ -1068,7 +1068,7 @@ CFE_Status_t CFE_TBL_GetAddresses(void **TblPtrs[], uint16 NumTables, const CFE_ int32 Status; CFE_ES_AppId_t ThisAppId; - if (TblPtrs == NULL) + if (TblPtrs == NULL || TblHandles == NULL) { return CFE_TBL_BAD_ARGUMENT; } @@ -1120,6 +1120,11 @@ CFE_Status_t CFE_TBL_ReleaseAddresses(uint16 NumTables, const CFE_TBL_Handle_t T CFE_Status_t Status = CFE_SUCCESS; uint16 i; + if (TblHandles == NULL) + { + return CFE_TBL_BAD_ARGUMENT; + } + for (i = 0; i < NumTables; i++) { /* Continue to get the return status until one returns something other than CFE_SUCCESS */ diff --git a/modules/time/ut-coverage/time_UT.c b/modules/time/ut-coverage/time_UT.c index b83de9ec7..931eb45e7 100644 --- a/modules/time/ut-coverage/time_UT.c +++ b/modules/time/ut-coverage/time_UT.c @@ -848,9 +848,8 @@ void Test_Print(void) } else { - UtAssertEx(false, UTASSERT_CASETYPE_MIR, __FILE__, __LINE__, - "Confirm adding seconds = %u, subseconds = %u to configured EPOCH results in time %s", - (unsigned int)time.Seconds, (unsigned int)time.Subseconds, timeBuf); + UtAssert_MIR("Confirm adding seconds = %u, subseconds = %u to configured EPOCH results in time %s", + (unsigned int)time.Seconds, (unsigned int)time.Subseconds, timeBuf); } /* Test with a time value that causes seconds >= 60 when @@ -867,9 +866,8 @@ void Test_Print(void) } else { - UtAssertEx(false, UTASSERT_CASETYPE_MIR, __FILE__, __LINE__, - "Confirm adding seconds = %u, subseconds = %u to configured EPOCH results in time %s", - (unsigned int)time.Seconds, (unsigned int)time.Subseconds, timeBuf); + UtAssert_MIR("Confirm adding seconds = %u, subseconds = %u to configured EPOCH results in time %s", + (unsigned int)time.Seconds, (unsigned int)time.Subseconds, timeBuf); } /* Test with mission representative time values */ @@ -884,9 +882,8 @@ void Test_Print(void) } else { - UtAssertEx(false, UTASSERT_CASETYPE_MIR, __FILE__, __LINE__, - "Confirm adding seconds = %u, subseconds = %u to configured EPOCH results in time %s", - (unsigned int)time.Seconds, (unsigned int)time.Subseconds, timeBuf); + UtAssert_MIR("Confirm adding seconds = %u, subseconds = %u to configured EPOCH results in time %s", + (unsigned int)time.Seconds, (unsigned int)time.Subseconds, timeBuf); } /* Test with maximum seconds and subseconds values */ @@ -901,9 +898,8 @@ void Test_Print(void) } else { - UtAssertEx(false, UTASSERT_CASETYPE_MIR, __FILE__, __LINE__, - "Confirm adding seconds = %u, subseconds = %u to configured EPOCH results in time %s", - (unsigned int)time.Seconds, (unsigned int)time.Subseconds, timeBuf); + UtAssert_MIR("Confirm adding seconds = %u, subseconds = %u to configured EPOCH results in time %s", + (unsigned int)time.Seconds, (unsigned int)time.Subseconds, timeBuf); } }