Fix nasa#1677, Add Message Api Functional Test

modules/cfe_testcase/CMakeLists.txt

@@ -9,6 +9,7 @@ add_cfe_app(cfe_testcase
  src/es_mempool_test.c
  src/fs_header_test.c
  src/fs_util_test.c
+ src/msg_api_test.c
  src/sb_pipe_mang_test.c
  src/time_arithmetic_test.c
  src/time_current_test.c

modules/cfe_testcase/src/cfe_test.c

@@ -58,6 +58,7 @@ void CFE_TestMain(void)
  ESTaskTestSetup();
  FSHeaderTestSetup();
  FSUtilTestSetup();
+ MsgApiTestSetup();
  SBPipeMangSetup();
  TimeArithmeticTestSetup();
  TimeCurrentTestSetup();

modules/cfe_testcase/src/cfe_test.h

@@ -77,6 +77,9 @@ typedef struct
 /* Log calls to void functions */
 #define cFE_FTAssert_VOIDCALL(func) (func, UtAssert(true, #func, __FILE__, __LINE__))
 
+/* Assert if status is CFE_SUCCESS */
+#define cFE_FTAssert_SUCCESS(status) UtAssert_INT32_EQ(status, CFE_SUCCESS)
+
 void CFE_TestMain(void);
 void ESCDSTestSetup(void);
 void ESInfoTestSetup(void);
@@ -85,6 +88,7 @@ void ESMiscTestSetup(void);
 void ESTaskTestSetup(void);
 void FSHeaderTestSetup(void);
 void FSUtilTestSetup(void);
+void MsgApiTestSetup(void);
 void SBPipeMangSetup(void);
 void TimeArithmeticTestSetup(void);
 void TimeCurrentTestSetup(void);

modules/cfe_testcase/src/msg_api_test.c

@@ -0,0 +1,262 @@
+/*************************************************************************
+**
+** 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:https://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: msg_api_test.c
+**
+** Purpose:
+** Functional test of cFE Message header APIs.
+**
+*************************************************************************/
+
+/*
+ * Includes
+ */
+
+#include "cfe_test.h"
+#include <string.h>
+
+/* merged all test into one function to avoid creating new messages for each test */
+void TestMsgApi(void)
+{
+ UtPrintf("Testing: CFE_MSG_Init, CFE_MSG_GetSize, CFE_MSG_SetSize, CFE_MSG_GetType, "
+ "CFE_MSG_SetType, CFE_MSG_GetHeaderVersion, CFE_MSG_SetHeaderVersion, "
+ "CFE_MSG_GetHasSecondaryHeader, CFE_MSG_SetHasSecondaryHeader, CFE_MSG_GetApId, "
+ "CFE_MSG_SetApId, CFE_MSG_GetSegmentationFlag, CFE_MSG_SetSegmentationFlag, "
+ "CFE_MSG_GetSequenceCount, CFE_MSG_SetSequenceCount, CFE_MSG_GetNextSequenceCount, "
+ "CFE_MSG_GetEDSVersion, CFE_MSG_SetEDSVersion, CFE_MSG_GetEndian, CFE_MSG_SetEndian, "
+ "CFE_MSG_GetPlaybackFlag, CFE_MSG_SetPlaybackFlag, CFE_MSG_GetSubsystem, "
+ "CFE_MSG_SetSubsystem, CFE_MSG_GetSystem, CFE_MSG_SetSystem, CFE_MSG_GenerateChecksum, "
+ "CFE_MSG_ValidateChecksum, CFE_MSG_SetFcnCode, CFE_MSG_GetFcnCode, "
+ "CFE_MSG_GetMsgTime, CFE_MSG_SetMsgTime ");
+
+ /* declare local vars */
+ CFE_MSG_CommandHeader_t cmd;
+ CFE_MSG_Size_t size;
+ CFE_MSG_Type_t type;
+ CFE_SB_MsgId_t msgId;
+ CFE_MSG_HeaderVersion_t hdrVer;
+ CFE_MSG_ApId_t appId;
+ CFE_MSG_SegmentationFlag_t segFlag;
+ CFE_MSG_SequenceCount_t seqCnt;
+ CFE_MSG_EDSVersion_t edsVersion;
+ CFE_MSG_Endian_t endian;
+ CFE_MSG_PlaybackFlag_t playbackFlag;
+ CFE_MSG_Subsystem_t subSystem;
+ CFE_MSG_System_t system;
+ CFE_MSG_FcnCode_t fcnCode;
+ CFE_TIME_SysTime_t msgTime;
+
+ memset(&cmd, 0xFF, sizeof(cmd));
+ msgId = CFE_SB_ValueToMsgId(0);
+
+ /* test msg-init */
+ UtAssert_INT32_EQ(CFE_MSG_Init(NULL, CFE_SB_ValueToMsgId(0), sizeof(cmd)), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_Init(&cmd.Msg, msgId, 0), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_Init(&cmd.Msg, msgId, sizeof(cmd)));
+
+ /* test set-msg-size */
+ UtAssert_INT32_EQ(CFE_MSG_SetSize(NULL, 12), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetSize(&cmd.Msg, 12));
+
+ /* test get-msg-size */
+ UtAssert_INT32_EQ(CFE_MSG_GetSize(NULL, &size), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetSize(&cmd.Msg, &size));
+ UtAssert_UINT32_EQ(size, 12);
+
+ /* test get-type */
+ UtAssert_INT32_EQ(CFE_MSG_SetType(NULL, CFE_MSG_Type_Cmd), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetType(NULL, &type), CFE_MSG_BAD_ARGUMENT);
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetType(&cmd.Msg, CFE_MSG_Type_Cmd));
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetType(&cmd.Msg, &type));
+ UtAssert_INT32_EQ(type, CFE_MSG_Type_Cmd);
+
+ /* test msg set-type */
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetType(&cmd.Msg, CFE_MSG_Type_Tlm));
+ /* check if set-type works like expected */
+ UtAssert_INT32_EQ(CFE_MSG_GetType(&cmd.Msg, &type), CFE_MSG_Type_Tlm);
+
+ /* test get header-version */
+ UtAssert_INT32_EQ(CFE_MSG_GetHeaderVersion(NULL, &hdrVer), CFE_MSG_BAD_ARGUMENT);
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetHeaderVersion(&cmd.Msg, &hdrVer));
+ UtAssert_INT32_EQ(CFE_MSG_GetHeaderVersion(&cmd.Msg, NULL), CFE_MSG_BAD_ARGUMENT);
+
+ /* test set header-version */
+ UtAssert_INT32_EQ(CFE_MSG_SetHeaderVersion(NULL, hdrVer), CFE_MSG_BAD_ARGUMENT);
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetHeaderVersion(&cmd.Msg, 0));
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetHeaderVersion(&cmd.Msg, &hdrVer));
+ UtAssert_True(hdrVer == 0, "hdrVer = 0");
+
+ /* test get-has-secondary-header and set-has-scondary-header*/
+ bool _expected = true;
+ bool _returned = false;
+
+ UtAssert_INT32_EQ(CFE_MSG_GetHasSecondaryHeader(NULL, &_expected), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetHasSecondaryHeader(&cmd.Msg, NULL), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetHasSecondaryHeader(&cmd.Msg, &_expected));
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetHasSecondaryHeader(&cmd.Msg, &_returned));
+ UtAssert_UINT32_EQ(_expected, _returned);
+
+ /* test get-apid */
+ UtAssert_INT32_EQ(CFE_MSG_GetApId(NULL, &appId), CFE_MSG_BAD_ARGUMENT);
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetApId(&cmd.Msg, &appId));
+ UtAssert_INT32_EQ(CFE_MSG_GetApId(&cmd.Msg, NULL), CFE_MSG_BAD_ARGUMENT);
+
+ /* test set-apid */
+ UtAssert_INT32_EQ(CFE_MSG_GetApId(NULL, 0), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_SetApId(&cmd.Msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetApId(&cmd.Msg, 0));
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetApId(&cmd.Msg, &appId));
+ UtAssert_True(appId == 0, "CFE_MSG_SetApId => apid = 0");
+
+ /* test get/set-segmentation-flag */
+ UtAssert_INT32_EQ(CFE_MSG_GetSegmentationFlag(NULL, &segFlag), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetSegmentationFlag(&cmd.Msg, NULL), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_SetSegmentationFlag(NULL, CFE_MSG_SegFlag_Continue), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetSegmentationFlag(&cmd.Msg, CFE_MSG_SegFlag_Continue));
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetSegmentationFlag(&cmd.Msg, &segFlag));
+ UtAssert_True(segFlag == CFE_MSG_SegFlag_Continue,
+ "CFE_MSG_SetSegmentationFlag => segFlag = CFE_MSG_SegFlag_Continue");
+
+ /* test set/get-sequence-count */
+ UtAssert_INT32_EQ(CFE_MSG_SetSequenceCount(NULL, 2), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetSequenceCount(NULL, &seqCnt), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetSequenceCount(&cmd.Msg, NULL), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetSequenceCount(&cmd.Msg, 2));
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetSequenceCount(&cmd.Msg, &seqCnt));
+
+ UtAssert_True(seqCnt == 2, "CFE_MSG_SetSequenceCount => seqCnt = 2");
+
+ /* test get-next-sequence-count */
+
+ /* 0x3FFF <- bad because defined CFE_MSG_SEQCNT_MASK value but not public */
+ /* UtAssert_True(CFE_MSG_GetNextSequenceCount(0x3FFF) == 0, "CFE_MSG_GetNextSequenceCount(0x3FFF) = 0"); */
+ UtAssert_True(CFE_MSG_GetNextSequenceCount(2) == 3, "CFE_MSG_GetNextSequenceCount(2) = 3");
+
+ /* test get/set-eds-version */
+ UtAssert_INT32_EQ(CFE_MSG_SetEDSVersion(NULL, 5), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetEDSVersion(NULL, &edsVersion), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetEDSVersion(&cmd.Msg, NULL), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetEDSVersion(&cmd.Msg, 5));
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetEDSVersion(&cmd.Msg, &edsVersion));
+
+ UtAssert_True(edsVersion == 5, "CFE_MSG_SetEDSVersion => edsVersion = 5");
+
+ /* test get/set-endian */
+ CFE_MSG_Endian_t _expectedEndian = CFE_MSG_Endian_Little;
+
+ UtAssert_INT32_EQ(CFE_MSG_SetEndian(NULL, _expectedEndian), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_SetEndian(&cmd.Msg, CFE_MSG_Endian_Invalid), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetEndian(&cmd.Msg, NULL), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetEndian(NULL, &endian), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetEndian(&cmd.Msg, _expectedEndian));
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetEndian(&cmd.Msg, &endian));
+
+ UtAssert_True(endian == _expectedEndian, "CFE_MSG_SetEndian => endian = CFE_MSG_Endian_Little");
+
+ /* test get/set-playback-flag */
+ CFE_MSG_PlaybackFlag_t _expectedPlayFlag = CFE_MSG_PlayFlag_Playback;
+
+ UtAssert_INT32_EQ(CFE_MSG_SetPlaybackFlag(NULL, _expectedPlayFlag), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_SetPlaybackFlag(&cmd.Msg, CFE_MSG_PlayFlag_Invalid), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetPlaybackFlag(&cmd.Msg, NULL), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetPlaybackFlag(NULL, &playbackFlag), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetPlaybackFlag(&cmd.Msg, _expectedPlayFlag));
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetPlaybackFlag(&cmd.Msg, &playbackFlag));
+
+ UtAssert_True(playbackFlag == _expectedPlayFlag,
+ "CFE_MSG_SetPlaybackFlag => playbackFlag = CFE_MSG_PlayFlag_Playback");
+
+ /* test get/set-subsystem */
+ UtAssert_INT32_EQ(CFE_MSG_GetSubsystem(NULL, &subSystem), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetSubsystem(&cmd.Msg, NULL), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_SetSubsystem(NULL, 3), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetSubsystem(&cmd.Msg, 3));
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetSubsystem(&cmd.Msg, &subSystem));
+
+ UtAssert_True(subSystem == 3, "CFE_MSG_SetSubsystem => subSystem = 3");
+
+ /* test get/set-system */
+ UtAssert_INT32_EQ(CFE_MSG_GetSystem(NULL, &subSystem), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetSystem(&cmd.Msg, NULL), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_SetSystem(NULL, 3), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetSystem(&cmd.Msg, 3));
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetSystem(&cmd.Msg, &system));
+
+ UtAssert_True(system == 3, "CFE_MSG_SetSystem => system = 3");
+
+ /* test generate-checksum */
+ UtAssert_INT32_EQ(CFE_MSG_GenerateChecksum(NULL), CFE_MSG_BAD_ARGUMENT);
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetType(&cmd.Msg, CFE_MSG_Type_Tlm));
+ UtAssert_INT32_EQ(CFE_MSG_GenerateChecksum(&cmd.Msg), CFE_MSG_BAD_ARGUMENT);
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetType(&cmd.Msg, CFE_MSG_Type_Cmd));
+
+ /* create new cmd message */
+ CFE_MSG_CommandHeader_t cmd2;
+ bool isValid = true;
+
+ memset(&cmd2, 0, sizeof(cmd2));
+ cFE_FTAssert_SUCCESS(CFE_MSG_Init(&cmd2.Msg, CFE_SB_ValueToMsgId(1), sizeof(cmd2)));
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_ValidateChecksum(&cmd2.Msg, &isValid));
+ UtAssert_True(!isValid, "Is checksum valid = false");
+ cFE_FTAssert_SUCCESS(CFE_MSG_GenerateChecksum(&cmd2.Msg));
+ cFE_FTAssert_SUCCESS(CFE_MSG_ValidateChecksum(&cmd2.Msg, &isValid));
+ UtAssert_True(isValid, "Checksum is valid");
+
+ /* test get/set-fcn-code */
+ UtAssert_INT32_EQ(CFE_MSG_SetFcnCode(NULL, 4), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetFcnCode(&cmd.Msg, NULL), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetFcnCode(NULL, &fcnCode), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetFcnCode(&cmd.Msg, 4));
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetFcnCode(&cmd.Msg, &fcnCode));
+
+ UtAssert_True(fcnCode == 4, "CFE_MSG_SetFcnCode => fcnCode = 4");
+
+ /* test get/set-msg-time */
+ CFE_TIME_SysTime_t currentTime = CFE_TIME_GetTime();
+
+ UtAssert_INT32_EQ(CFE_MSG_GetMsgTime(NULL, &msgTime), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_GetMsgTime(&cmd.Msg, NULL), CFE_MSG_BAD_ARGUMENT);
+ UtAssert_INT32_EQ(CFE_MSG_SetMsgTime(NULL, currentTime), CFE_MSG_BAD_ARGUMENT);
+
+ cFE_FTAssert_SUCCESS(CFE_MSG_SetMsgTime(&cmd.Msg, currentTime));
+ cFE_FTAssert_SUCCESS(CFE_MSG_GetMsgTime(&cmd.Msg, &msgTime));
+
+ UtAssert_UINT32_EQ(CFE_TIME_Compare(msgTime, currentTime), CFE_TIME_EQUAL);
+}
+
+void MsgApiTestSetup(void)
+{
+ UtTest_Add(TestMsgApi, NULL, NULL, "Test message header apis");
+}