From b5467c14c776797bcb95e4c85e02f82499cffaf5 Mon Sep 17 00:00:00 2001 From: Jacob Hageman Date: Thu, 16 Jul 2020 17:15:53 -0400 Subject: [PATCH] Fix #711, Add unit tests and improve error logic --- modules/msg/src/cfe_msg_ccsdsext.c | 29 +- modules/msg/src/cfe_msg_ccsdspri.c | 17 +- .../test_cfe_msg_ccsdspri.c | 469 ++++++++++++++++++ .../test_cfe_msg_ccsdspri.h | 39 ++ .../test_cfe_msg_msgid_shared.c | 79 +++ .../test_cfe_msg_msgid_shared.h | 33 ++ .../test_cfe_msg_msgid_v2.c | 124 +++++ .../test_cfe_msg_msgid_v2.h | 33 ++ modules/msg/unit-test-coverage/test_msg_not.c | 178 +++++++ modules/msg/unit-test-coverage/test_msg_not.h | 63 +++ .../msg/unit-test-coverage/test_msg_utils.c | 66 +++ .../msg/unit-test-coverage/test_msg_utils.h | 45 ++ 12 files changed, 1160 insertions(+), 15 deletions(-) create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_ccsdspri.c create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_ccsdspri.h create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_msgid_shared.c create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_msgid_shared.h create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_msgid_v2.c create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_msgid_v2.h create mode 100644 modules/msg/unit-test-coverage/test_msg_not.c create mode 100644 modules/msg/unit-test-coverage/test_msg_not.h create mode 100644 modules/msg/unit-test-coverage/test_msg_utils.c create mode 100644 modules/msg/unit-test-coverage/test_msg_utils.h diff --git a/modules/msg/src/cfe_msg_ccsdsext.c b/modules/msg/src/cfe_msg_ccsdsext.c index 07e843d11..441f52fa1 100644 --- a/modules/msg/src/cfe_msg_ccsdsext.c +++ b/modules/msg/src/cfe_msg_ccsdsext.c @@ -74,13 +74,12 @@ int32 CFE_MSG_GetEDSVersion(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_EDSVersion_ */ int32 CFE_MSG_SetEDSVersion(CFE_MSG_Message_t *MsgPtr, CFE_MSG_EDSVersion_t Version) { - Version <<= CFE_MSG_EDSVER_SHIFT; - if (MsgPtr == NULL || ((Version & ~CFE_MSG_EDSVER_MASK) != 0)) + if (MsgPtr == NULL || (Version > (CFE_MSG_EDSVER_MASK >> CFE_MSG_EDSVER_SHIFT))) { return CFE_MSG_BAD_ARGUMENT; } - CFE_MSG_SetHeaderField(MsgPtr->CCSDS.Ext.Subsystem, Version, CFE_MSG_EDSVER_MASK); + CFE_MSG_SetHeaderField(MsgPtr->CCSDS.Ext.Subsystem, Version << CFE_MSG_EDSVER_SHIFT, CFE_MSG_EDSVER_MASK); return CFE_SUCCESS; } @@ -113,7 +112,9 @@ int32 CFE_MSG_GetEndian(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Endian_t *Endia */ int32 CFE_MSG_SetEndian(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Endian_t Endian) { - if (MsgPtr == NULL || Endian == CFE_MSG_Endian_Invalid) + int32 status = CFE_SUCCESS; + + if (MsgPtr == NULL) { return CFE_MSG_BAD_ARGUMENT; } @@ -122,12 +123,16 @@ int32 CFE_MSG_SetEndian(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Endian_t Endian) { MsgPtr->CCSDS.Ext.Subsystem[0] |= CFE_MSG_ENDIAN_MASK >> 8; } - else + else if (Endian == CFE_MSG_Endian_Big) { MsgPtr->CCSDS.Ext.Subsystem[0] &= ~(CFE_MSG_ENDIAN_MASK >> 8); } + else + { + status = CFE_MSG_BAD_ARGUMENT; + } - return CFE_SUCCESS; + return status; } /****************************************************************************** @@ -158,7 +163,9 @@ int32 CFE_MSG_GetPlaybackFlag(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_PlaybackF */ int32 CFE_MSG_SetPlaybackFlag(CFE_MSG_Message_t *MsgPtr, CFE_MSG_PlaybackFlag_t PlayFlag) { - if (MsgPtr == NULL || PlayFlag == CFE_MSG_PlayFlag_Invalid) + int32 status = CFE_SUCCESS; + + if (MsgPtr == NULL) { return CFE_MSG_BAD_ARGUMENT; } @@ -167,12 +174,16 @@ int32 CFE_MSG_SetPlaybackFlag(CFE_MSG_Message_t *MsgPtr, CFE_MSG_PlaybackFlag_t { MsgPtr->CCSDS.Ext.Subsystem[0] |= CFE_MSG_PLAYBACK_MASK >> 8; } - else + else if (PlayFlag == CFE_MSG_PlayFlag_Original) { MsgPtr->CCSDS.Ext.Subsystem[0] &= ~(CFE_MSG_PLAYBACK_MASK >> 8); } + else + { + status = CFE_MSG_BAD_ARGUMENT; + } - return CFE_SUCCESS; + return status; } /****************************************************************************** diff --git a/modules/msg/src/cfe_msg_ccsdspri.c b/modules/msg/src/cfe_msg_ccsdspri.c index d9543272a..b7d73679d 100644 --- a/modules/msg/src/cfe_msg_ccsdspri.c +++ b/modules/msg/src/cfe_msg_ccsdspri.c @@ -81,13 +81,12 @@ int32 CFE_MSG_GetHeaderVersion(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_HeaderVe */ int32 CFE_MSG_SetHeaderVersion(CFE_MSG_Message_t *MsgPtr, CFE_MSG_HeaderVersion_t Version) { - Version <<= CFE_MSG_CCSDSVER_SHIFT; - if (MsgPtr == NULL || ((Version & ~CFE_MSG_CCSDSVER_MASK) != 0)) + if (MsgPtr == NULL || (Version > (CFE_MSG_CCSDSVER_MASK >> CFE_MSG_CCSDSVER_SHIFT))) { return CFE_MSG_BAD_ARGUMENT; } - CFE_MSG_SetHeaderField(MsgPtr->CCSDS.Pri.StreamId, Version, CFE_MSG_CCSDSVER_MASK); + CFE_MSG_SetHeaderField(MsgPtr->CCSDS.Pri.StreamId, Version << CFE_MSG_CCSDSVER_SHIFT, CFE_MSG_CCSDSVER_MASK); return CFE_SUCCESS; } @@ -120,7 +119,9 @@ int32 CFE_MSG_GetType(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Type_t *Type) */ int32 CFE_MSG_SetType(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Type_t Type) { - if (MsgPtr == NULL || Type == CFE_MSG_Type_Invalid) + int32 status = CFE_SUCCESS; + + if (MsgPtr == NULL) { return CFE_MSG_BAD_ARGUMENT; } @@ -129,12 +130,16 @@ int32 CFE_MSG_SetType(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Type_t Type) { MsgPtr->CCSDS.Pri.StreamId[0] |= CFE_MSG_TYPE_MASK >> 8; } - else + else if (Type == CFE_MSG_Type_Tlm) { MsgPtr->CCSDS.Pri.StreamId[0] &= ~(CFE_MSG_TYPE_MASK >> 8); } + else + { + status = CFE_MSG_BAD_ARGUMENT; + } - return CFE_SUCCESS; + return status; } /****************************************************************************** diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_ccsdspri.c b/modules/msg/unit-test-coverage/test_cfe_msg_ccsdspri.c new file mode 100644 index 000000000..4889a16df --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_ccsdspri.c @@ -0,0 +1,469 @@ +/* +** 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. +*/ + +/* + * Test CCSDS Primary header accessors + */ + +/* + * Includes + */ +#include "utassert.h" +#include "ut_support.h" +#include "cfe_msg_api.h" +#include "test_msg_not.h" +#include "test_msg_utils.h" +#include "test_cfe_msg_ccsdspri.h" +#include "cfe_error.h" +#include + +/* + * Defines + */ +#define TEST_CCSDSVER_MAX 7 /* Maximum value for CCSDS Version field */ +#define TEST_APID_MAX 0x7FF /* Maximum value for CCSDS ApId field */ +#define TEST_SEQUENCE_MAX 0x3FFF /* Maximum value for CCSDS Sequence field */ + +void Test_MSG_Size(void) +{ + CFE_MSG_Message_t msg; + CFE_MSG_Size_t input[] = {TEST_MSG_SIZE_OFFSET, 0x8000, 0xFFFF, 0xFFFF + TEST_MSG_SIZE_OFFSET}; + CFE_MSG_Size_t actual = 0; + int i; + + UT_Text("Bad parameter tests, Null pointers and invalid (0, min valid - 1, max valid + 1, max)"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSize(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_GetSize(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetSize(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetSize(&msg, 0), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetSize(&msg, TEST_MSG_SIZE_OFFSET - 1), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetSize(&msg, 0xFFFF + TEST_MSG_SIZE_OFFSET + 1), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetSize(&msg, 0xFFFFFFFF), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + + UT_Text("Set to all F's, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&msg, 0xFF, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSize(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, 0xFFFF + TEST_MSG_SIZE_OFFSET); + ASSERT_EQ(CFE_MSG_SetSize(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSize(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == 0xFFFF + TEST_MSG_SIZE_OFFSET) + { + ASSERT_EQ(Test_MSG_NotF(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_LENGTH_FLAG); + } + } + + UT_Text("Set to all 0, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSize(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, TEST_MSG_SIZE_OFFSET); + ASSERT_EQ(CFE_MSG_SetSize(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSize(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == TEST_MSG_SIZE_OFFSET) + { + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_LENGTH_FLAG); + } + } +} + +void Test_MSG_Type(void) +{ + CFE_MSG_Message_t msg; + CFE_MSG_Type_t input[] = {CFE_MSG_Type_Cmd, CFE_MSG_Type_Tlm}; + CFE_MSG_Type_t actual = 0; + int i; + + UT_Text("Bad parameter tests, Null pointers and invalid (CFE_MSG_Type_Invalid, CFE_MSG_Type_Tlm + 1"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetType(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_GetType(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetType(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetType(&msg, CFE_MSG_Type_Invalid), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetType(&msg, CFE_MSG_Type_Tlm + 1), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + + UT_Text("Set to all F's, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&msg, 0xFF, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetType(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, CFE_MSG_Type_Cmd); + ASSERT_EQ(CFE_MSG_SetType(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetType(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == CFE_MSG_Type_Cmd) + { + ASSERT_EQ(Test_MSG_NotF(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_TYPE_FLAG); + } + } + + UT_Text("Set to all 0, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetType(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, CFE_MSG_Type_Tlm); + ASSERT_EQ(CFE_MSG_SetType(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetType(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == CFE_MSG_Type_Tlm) + { + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_TYPE_FLAG); + } + } +} + +void Test_MSG_HeaderVersion(void) +{ + CFE_MSG_Message_t msg; + CFE_MSG_HeaderVersion_t input[] = {0, TEST_CCSDSVER_MAX/2, TEST_CCSDSVER_MAX}; + CFE_MSG_HeaderVersion_t actual = TEST_CCSDSVER_MAX; + int i; + + UT_Text("Bad parameter tests, Null pointers and invalid (max valid + 1, max)"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetHeaderVersion(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, TEST_CCSDSVER_MAX); + ASSERT_EQ(CFE_MSG_GetHeaderVersion(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetHeaderVersion(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetHeaderVersion(&msg, TEST_CCSDSVER_MAX + 1), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetHeaderVersion(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + + UT_Text("Set to all F's, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&msg, 0xFF, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetHeaderVersion(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, TEST_CCSDSVER_MAX); + ASSERT_EQ(CFE_MSG_SetHeaderVersion(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetHeaderVersion(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == TEST_CCSDSVER_MAX) + { + ASSERT_EQ(Test_MSG_NotF(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_HDRVER_FLAG); + } + } + + UT_Text("Set to all 0, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetHeaderVersion(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_SetHeaderVersion(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetHeaderVersion(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == 0) + { + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_HDRVER_FLAG); + } + } +} + +void Test_MSG_HasSecondaryHeader(void) +{ + CFE_MSG_Message_t msg; + bool actual = true; + + UT_Text("Bad parameter tests, Null pointers"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetHasSecondaryHeader(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, true); + ASSERT_EQ(CFE_MSG_GetHasSecondaryHeader(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetHasSecondaryHeader(NULL, false), CFE_MSG_BAD_ARGUMENT); + + UT_Text("Set to all F's, true and false inputs"); + memset(&msg, 0xFF, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetHasSecondaryHeader(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, true); + + ASSERT_EQ(CFE_MSG_SetHasSecondaryHeader(&msg, true), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetHasSecondaryHeader(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, true); + ASSERT_EQ(Test_MSG_NotF(&msg), 0); + + ASSERT_EQ(CFE_MSG_SetHasSecondaryHeader(&msg, false), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetHasSecondaryHeader(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, false); + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_HASSEC_FLAG); + + UT_Text("Set to all 0, true and false inputs"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetHasSecondaryHeader(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, false); + + ASSERT_EQ(CFE_MSG_SetHasSecondaryHeader(&msg, false), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetHasSecondaryHeader(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, false); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + + ASSERT_EQ(CFE_MSG_SetHasSecondaryHeader(&msg, true), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetHasSecondaryHeader(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, true); + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_HASSEC_FLAG); +} + +void Test_MSG_ApId(void) +{ + CFE_MSG_Message_t msg; + CFE_MSG_ApId_t input[] = {0, TEST_APID_MAX/2, TEST_APID_MAX}; + CFE_MSG_ApId_t actual = TEST_APID_MAX; + int i; + + UT_Text("Bad parameter tests, Null pointers and invalid (max valid + 1, max)"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetApId(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, TEST_APID_MAX); + ASSERT_EQ(CFE_MSG_GetApId(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetApId(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetApId(&msg, TEST_APID_MAX + 1), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetApId(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + + UT_Text("Set to all F's, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&msg, 0xFF, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetApId(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, TEST_APID_MAX); + ASSERT_EQ(CFE_MSG_SetApId(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetApId(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == TEST_APID_MAX) + { + ASSERT_EQ(Test_MSG_NotF(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_APID_FLAG); + } + } + + UT_Text("Set to all 0, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetApId(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_SetApId(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetApId(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == 0) + { + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_APID_FLAG); + } + } +} + +void Test_MSG_SegmentationFlag(void) +{ + CFE_MSG_Message_t msg; + CFE_MSG_SegmentationFlag_t input[] = {CFE_MSG_SegFlag_Continue, CFE_MSG_SegFlag_First, + CFE_MSG_SegFlag_Last, CFE_MSG_SegFlag_Unsegmented}; + CFE_MSG_SegmentationFlag_t actual = CFE_MSG_SegFlag_Invalid; + int i; + + UT_Text("Bad parameter tests, Null pointers and invalid (*_Invalid, max valid + 1"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSegmentationFlag(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, CFE_MSG_SegFlag_Invalid); + ASSERT_EQ(CFE_MSG_GetSegmentationFlag(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetSegmentationFlag(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetSegmentationFlag(&msg, CFE_MSG_SegFlag_Invalid), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetSegmentationFlag(&msg, CFE_MSG_SegFlag_Unsegmented + 1), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + + UT_Text("Set to all F's, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&msg, 0xFF, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSegmentationFlag(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, CFE_MSG_SegFlag_Unsegmented); + ASSERT_EQ(CFE_MSG_SetSegmentationFlag(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSegmentationFlag(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == CFE_MSG_SegFlag_Unsegmented) + { + ASSERT_EQ(Test_MSG_NotF(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_SEGMENT_FLAG); + } + } + + UT_Text("Set to all 0, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSegmentationFlag(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, CFE_MSG_SegFlag_Continue); + ASSERT_EQ(CFE_MSG_SetSegmentationFlag(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSegmentationFlag(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == CFE_MSG_SegFlag_Continue) + { + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_SEGMENT_FLAG); + } + } +} + +void Test_MSG_SequenceCount(void) +{ + CFE_MSG_Message_t msg; + CFE_MSG_ApId_t input[] = {0, TEST_SEQUENCE_MAX/2, TEST_SEQUENCE_MAX}; + CFE_MSG_ApId_t actual = TEST_SEQUENCE_MAX; + int i; + + UT_Text("Bad parameter tests, Null pointers and invalid (max valid + 1, max)"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSequenceCount(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, TEST_SEQUENCE_MAX); + ASSERT_EQ(CFE_MSG_GetSequenceCount(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetSequenceCount(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetSequenceCount(&msg, TEST_SEQUENCE_MAX + 1), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetSequenceCount(&msg, 0xFFFF), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + + UT_Text("Set to all F's, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&msg, 0xFF, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSequenceCount(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, TEST_SEQUENCE_MAX); + ASSERT_EQ(CFE_MSG_SetSequenceCount(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSequenceCount(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == TEST_SEQUENCE_MAX) + { + ASSERT_EQ(Test_MSG_NotF(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_SEQUENCE_FLAG); + } + } + + UT_Text("Set to all 0, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSequenceCount(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_SetSequenceCount(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSequenceCount(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == 0) + { + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_SEQUENCE_FLAG); + } + } +} + +/* + * Test MSG ccsdspri + */ +void Test_MSG_CCSDSPri(void) +{ + MSG_UT_ADD_SUBTEST(Test_MSG_Size); + MSG_UT_ADD_SUBTEST(Test_MSG_Type); + MSG_UT_ADD_SUBTEST(Test_MSG_HeaderVersion); + MSG_UT_ADD_SUBTEST(Test_MSG_HasSecondaryHeader); + MSG_UT_ADD_SUBTEST(Test_MSG_ApId); + MSG_UT_ADD_SUBTEST(Test_MSG_SegmentationFlag); + MSG_UT_ADD_SUBTEST(Test_MSG_SequenceCount); +} diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_ccsdspri.h b/modules/msg/unit-test-coverage/test_cfe_msg_ccsdspri.h new file mode 100644 index 000000000..c85e21961 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_ccsdspri.h @@ -0,0 +1,39 @@ +/* +** 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. +*/ + +/* + * cfe_msg_ccsdspri test header + */ +#ifndef test_cfe_msg_ccsdspri_ +#define test_cfe_msg_ccsdspri_ + +/* + * Defines + */ + +#define TEST_MSG_SIZE_OFFSET 7 /* CCSDS Message length offset */ + +/* + * Functions + */ +/* Test CCSDS Primary header accessor functions */ +void Test_MSG_CCSDSPri(void); + +#endif /* test_cfe_msg_ccsdspri_ */ diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_msgid_shared.c b/modules/msg/unit-test-coverage/test_cfe_msg_msgid_shared.c new file mode 100644 index 000000000..bacad99b1 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_msgid_shared.c @@ -0,0 +1,79 @@ +/* +** 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. +*/ + +/* + * Test MsgId shared accessors + */ + +/* + * Includes + */ +#include "utassert.h" +#include "ut_support.h" +#include "cfe_msg_api.h" +#include "test_msg_not.h" +#include "test_msg_utils.h" +#include "test_cfe_msg_msgid_shared.h" +#include "cfe_error.h" +#include + +void Test_MSG_GetTypeFromMsgId(void) +{ + CFE_MSG_Message_t msg; + CFE_SB_MsgId_t msgid = CFE_SB_ValueToMsgId(0); + CFE_MSG_Type_t actual = CFE_MSG_Type_Invalid; + + UT_Text("Bad parameter tests, Null pointer"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetTypeFromMsgId(msgid, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + + UT_Text("Set to all F's, test cmd and tlm"); + memset(&msg, 0xFF, sizeof(msg)); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(CFE_PLATFORM_SB_HIGHEST_VALID_MSGID)), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_SetType(&msg, CFE_MSG_Type_Tlm), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetTypeFromMsgId(msgid, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, CFE_MSG_Type_Tlm); + + ASSERT_EQ(CFE_MSG_SetType(&msg, CFE_MSG_Type_Cmd), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetTypeFromMsgId(msgid, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, CFE_MSG_Type_Cmd); + + UT_Text("Set to all 0, test cmd and tlm"); + ASSERT_EQ(CFE_MSG_SetType(&msg, CFE_MSG_Type_Cmd), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetTypeFromMsgId(msgid, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, CFE_MSG_Type_Cmd); + + ASSERT_EQ(CFE_MSG_SetType(&msg, CFE_MSG_Type_Tlm), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetTypeFromMsgId(msgid, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, CFE_MSG_Type_Tlm); +} + +/* + * Test MSG MsgId Shared + */ +void Test_MSG_MsgId_Shared(void) +{ + MSG_UT_ADD_SUBTEST(Test_MSG_GetTypeFromMsgId); +} diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_msgid_shared.h b/modules/msg/unit-test-coverage/test_cfe_msg_msgid_shared.h new file mode 100644 index 000000000..469f65408 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_msgid_shared.h @@ -0,0 +1,33 @@ +/* +** 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. +*/ + +/* + * cfe_msg_msgid_shared test header + */ +#ifndef test_cfe_msg_msgid_shared_ +#define test_cfe_msg_msgid_shared_ + +/* + * Functions + */ +/* Test msgid shared accessor functions */ +void Test_MSG_MsgId_Shared(void); + +#endif /* test_cfe_msg_msgid_shared_ */ diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_msgid_v2.c b/modules/msg/unit-test-coverage/test_cfe_msg_msgid_v2.c new file mode 100644 index 000000000..6a0e40daa --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_msgid_v2.c @@ -0,0 +1,124 @@ +/* +** 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. +*/ + +/* + * Test MsgId V2 accessors + */ + +/* + * Includes + */ +#include "utassert.h" +#include "ut_support.h" +#include "cfe_msg_api.h" +#include "test_msg_not.h" +#include "test_msg_utils.h" +#include "test_cfe_msg_msgid_v2.h" +#include "cfe_error.h" +#include + +void Test_MSG_MsgId(void) +{ + CFE_MSG_Message_t msg; + CFE_SB_MsgId_t msgid = CFE_SB_ValueToMsgId(1); + CFE_MSG_Type_t type; + CFE_MSG_ApId_t apid; + CFE_MSG_Subsystem_t subsystem; + int local_subsys_flag = 0; + + /* Check if subsystem accessor functions are implemented */ + if (CFE_MSG_GetSubsystem(&msg, &subsystem) != CFE_MSG_NOT_IMPLEMENTED) + { + local_subsys_flag = MSG_SUBSYS_FLAG; + } + + UT_Text("Bad parameter tests, Null pointers and invalid (max valid + 1)"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetMsgId(NULL, &msgid), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_SB_MsgIdToValue(msgid), 1); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetMsgId(NULL, msgid), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, CFE_SB_INVALID_MSG_ID), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID + 1), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, 0xFFFFFFFF), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + + UT_Text("Set msg to all F's, set msgid to 0 and verify"); + memset(&msg, 0xFF, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + ASSERT_EQ(CFE_SB_MsgIdToValue(msgid), 0xFFFF); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, 0), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + ASSERT_EQ(CFE_SB_MsgIdToValue(msgid), 0); + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_APID_FLAG | MSG_TYPE_FLAG | local_subsys_flag); + + UT_Text("Set msg to all 0, set msgid to max and verify"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + ASSERT_EQ(CFE_SB_MsgIdToValue(msgid), 0); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + ASSERT_EQ(CFE_SB_MsgIdToValue(msgid), CFE_PLATFORM_SB_HIGHEST_VALID_MSGID); + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_APID_FLAG | MSG_TYPE_FLAG | local_subsys_flag); + ASSERT_EQ(CFE_MSG_GetApId(&msg, &apid), CFE_SUCCESS); + ASSERT_EQ(apid, 0x7F); + ASSERT_EQ(CFE_MSG_GetType(&msg, &type), CFE_SUCCESS); + ASSERT_EQ(type, CFE_MSG_Type_Cmd); + if (CFE_MSG_GetSubsystem(&msg, &subsystem) != CFE_MSG_NOT_IMPLEMENTED) + { + ASSERT_EQ(subsystem, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID >> 8); + } + + UT_Text("Set ApId msgid bits only and verify"); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0x007F)), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_APID_FLAG); + ASSERT_EQ(CFE_MSG_GetApId(&msg, &apid), CFE_SUCCESS); + ASSERT_EQ(apid, 0x007F); + + UT_Text("Set type msgid bit only and verify"); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0x0080)), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_TYPE_FLAG); + ASSERT_EQ(CFE_MSG_GetType(&msg, &type), CFE_SUCCESS); + ASSERT_EQ(type, CFE_MSG_Type_Cmd); + + UT_Text("Set subsystem msgid bits only and verify"); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0xFF00 & CFE_PLATFORM_SB_HIGHEST_VALID_MSGID)), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + ASSERT_EQ(Test_MSG_NotZero(&msg), local_subsys_flag); + if (CFE_MSG_GetSubsystem(&msg, &subsystem) != CFE_MSG_NOT_IMPLEMENTED) + { + ASSERT_EQ(subsystem, CFE_PLATFORM_SB_HIGHEST_VALID_MSGID >> 8); + } +} + +/* + * Test MSG MsgId Shared + */ +void Test_MSG_MsgId_V2(void) +{ + MSG_UT_ADD_SUBTEST(Test_MSG_MsgId); +} diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_msgid_v2.h b/modules/msg/unit-test-coverage/test_cfe_msg_msgid_v2.h new file mode 100644 index 000000000..9e8af062a --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_msgid_v2.h @@ -0,0 +1,33 @@ +/* +** 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. +*/ + +/* + * Message ID V2 accessor function test header + */ +#ifndef test_cfe_msg_msgid_v2_ +#define test_cfe_msg_msgid_v2_ + +/* + * Functions + */ +/* Test msgid v2 accessor functions */ +void Test_MSG_MsgId_V2(void); + +#endif /* test_cfe_msg_msgid_v2_ */ diff --git a/modules/msg/unit-test-coverage/test_msg_not.c b/modules/msg/unit-test-coverage/test_msg_not.c new file mode 100644 index 000000000..733a4e30e --- /dev/null +++ b/modules/msg/unit-test-coverage/test_msg_not.c @@ -0,0 +1,178 @@ +/* +** 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. +*/ + +/* + * Message header field not Zero or F + */ + +/* + * Includes + */ +#include "test_cfe_msg_ccsdspri.h" +#include "test_msg_utils.h" +#include "cfe_msg_api.h" + +/* TODO update for cfe msg module, not gateway checks */ + +unsigned int Test_MSG_NotZero(const CFE_MSG_Message_t *MsgPtr) +{ + unsigned int bits = 0; + CFE_MSG_HeaderVersion_t hdrver; + bool hassec; + CFE_MSG_Type_t type; + CFE_MSG_ApId_t apid; + CFE_MSG_SegmentationFlag_t segflag; + CFE_MSG_SequenceCount_t seqcnt; + CFE_MSG_Size_t size; + CFE_MSG_SecHdrVersion_t secver; + CFE_MSG_PlaybackFlag_t pback; + CFE_MSG_Route_t route; + bool dtn; + CFE_MSG_QOS_t qos; + CFE_MSG_FcnCode_t fcncode; + CFE_MSG_Source_t source; + CFE_TIME_SysTime_t time; + + /* Primary */ + CFE_MSG_GetHeaderVersion(MsgPtr, &hdrver); + if (hdrver != 0) + bits |= MSG_HDRVER_FLAG; + CFE_MSG_GetType(MsgPtr, &type); + if (type != CFE_MSG_Type_Tlm) + bits |= MSG_TYPE_FLAG; + CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassec); + if (hassec) + bits |= MSG_HASSEC_FLAG; + CFE_MSG_GetApId(MsgPtr, &apid); + if (apid != 0) + bits |= MSG_APID_FLAG; + CFE_MSG_GetSegmentationFlag(MsgPtr, &segflag); + if (segflag != CFE_MSG_SegFlag_Continue) + bits |= MSG_SEGMENT_FLAG; + CFE_MSG_GetSequenceCount(MsgPtr, &seqcnt); + if (seqcnt != 0) + bits |= MSG_SEQUENCE_FLAG; + CFE_MSG_GetSize(MsgPtr, &size); + if (size != TEST_MSG_SIZE_OFFSET) + bits |= MSG_LENGTH_FLAG; + + /* Extended */ + CFE_MSG_GetSecHdrVersion(MsgPtr, &secver); + if (secver != 0) + bits |= MSG_SECHDRVER_FLAG; + CFE_MSG_GetPlaybackFlag(MsgPtr, &pback); + if (pback != CFE_MSG_PlayFlag_Original) + bits |= MSG_PBACK_FLAG; + CFE_MSG_GetRoute(MsgPtr, &route); + if (route != 0) + bits |= MSG_ROUTE_FLAG; + CFE_MSG_GetDTN(MsgPtr, &dtn); + if (dtn) + bits |= MSG_DTN_FLAG; + CFE_MSG_GetQOS(MsgPtr, &qos); + if (qos != 0) + bits |= MSG_QOS_FLAG; + + /* Secondary */ + CFE_MSG_GetFcnCode(MsgPtr, &fcncode); // TODO check status + if (fcncode != 0) + bits |= MSG_FCNCODE_FLAG; + CFE_MSG_GetSource(MsgPtr, &source); + if (source != 0) + bits |= MSG_SOURCE_FLAG; + CFE_MSG_GetMsgTime(MsgPtr, &time); + if (time.Seconds != 0 || time.Subseconds != 0) + bits |= MSG_TIME_FLAG; + + return bits; +} + +unsigned int Test_MSG_NotF(const CFE_MSG_Message_t *MsgPtr) +{ + unsigned int bits = 0; + CFE_MSG_HeaderVersion_t hdrver; + bool hassec; + CFE_MSG_Type_t type; + CFE_MSG_ApId_t apid; + CFE_MSG_SegmentationFlag_t segflag; + CFE_MSG_SequenceCount_t seqcnt; + CFE_MSG_Size_t size; + CFE_MSG_SecHdrVersion_t secver; + CFE_MSG_PlaybackFlag_t pback; + CFE_MSG_Route_t route; + bool dtn; + CFE_MSG_QOS_t qos; + CFE_MSG_FcnCode_t fcncode; + CFE_MSG_Source_t source; + CFE_TIME_SysTime_t time; + + /* Primary */ + CFE_MSG_GetHeaderVersion(MsgPtr, &hdrver); + if (hdrver != 0x7) + bits |= MSG_HDRVER_FLAG; + CFE_MSG_GetType(MsgPtr, &type); + if (type != CFE_MSG_Type_Cmd) + bits |= MSG_TYPE_FLAG; + CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassec); + if (!hassec) + bits |= MSG_HASSEC_FLAG; + CFE_MSG_GetApId(MsgPtr, &apid); + if (apid != 0x7FF) + bits |= MSG_APID_FLAG; + CFE_MSG_GetSegmentationFlag(MsgPtr, &segflag); + if (segflag != CFE_MSG_SegFlag_Unsegmented) + bits |= MSG_SEGMENT_FLAG; + CFE_MSG_GetSequenceCount(MsgPtr, &seqcnt); + if (seqcnt != 0x3FFF) + bits |= MSG_SEQUENCE_FLAG; + CFE_MSG_GetSize(MsgPtr, &size); + if (size != 0xFFFF + TEST_MSG_SIZE_OFFSET) + bits |= MSG_LENGTH_FLAG; + + /* Extended */ + CFE_MSG_GetSecHdrVersion(MsgPtr, &secver); + if (secver != 0xF) + bits |= MSG_SECHDRVER_FLAG; + CFE_MSG_GetPlaybackFlag(MsgPtr, &pback); + if (pback != CFE_MSG_PlayFlag_Playback) + bits |= MSG_PBACK_FLAG; + CFE_MSG_GetRoute(MsgPtr, &route); + if (route != 0x3F) + bits |= MSG_ROUTE_FLAG; + CFE_MSG_GetDTN(MsgPtr, &dtn); + if (!dtn) + bits |= MSG_DTN_FLAG; + CFE_MSG_GetQOS(MsgPtr, &qos); + if (qos != 0xF) + bits |= MSG_QOS_FLAG; + + /* Secondary */ + CFE_MSG_GetFcnCode(MsgPtr, &fcncode); // TODO check status + if (fcncode != 0xFF) + bits |= MSG_FCNCODE_FLAG; + CFE_MSG_GetSource(MsgPtr, &source); + if (source != 0xFF) + bits |= MSG_SOURCE_FLAG; + CFE_MSG_GetMsgTime(MsgPtr, &time); + if (time.Seconds != 0xFFFFFFFF || time.Subseconds != 0xFFFF0000) + bits |= MSG_TIME_FLAG; + + return bits; +} diff --git a/modules/msg/unit-test-coverage/test_msg_not.h b/modules/msg/unit-test-coverage/test_msg_not.h new file mode 100644 index 000000000..64a10843d --- /dev/null +++ b/modules/msg/unit-test-coverage/test_msg_not.h @@ -0,0 +1,63 @@ +/* +** 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. +*/ + +/* + * Message header fields not (Zero or F's) + */ +#ifndef test_msg_not_ +#define test_msg_not_ + +/* + * Defines + */ + +/* Field flags */ +/* CCSDS Primary */ +#define MSG_HDRVER_FLAG 0x00001 +#define MSG_TYPE_FLAG 0x00002 +#define MSG_HASSEC_FLAG 0x00004 +#define MSG_APID_FLAG 0x00008 +#define MSG_SEGMENT_FLAG 0x00010 +#define MSG_SEQUENCE_FLAG 0x00020 +#define MSG_LENGTH_FLAG 0x00040 + +/* Extended */ +#define MSG_EDSVER_FLAG 0x00080 +#define MSG_ENDIAN_FLAG 0x00100 +#define MSG_PBACK_FLAG 0x00200 +#define MSG_SUBSYS_FLAG 0x00400 +#define MSG_SYSTEM_FLAG 0x00800 + +/* Secondary */ +#define MSG_CKSUM_FLAG 0x01000 +#define MSG_FCNCODE_FLAG 0x02000 +#define MSG_TIME_FLAG 0x04000 + +/* + * Prototypes + */ + +/* Returns flags for fields that are 0 */ +unsigned int Test_MSG_NotZero(const CFE_MSG_Message_t *MsgPtr); + +/* Returns flags for fields that are fully set (aka all F's */ +unsigned int Test_MSG_NotF(const CFE_MSG_Message_t *MsgPtr); + +#endif /* test_msg_not_ */ diff --git a/modules/msg/unit-test-coverage/test_msg_utils.c b/modules/msg/unit-test-coverage/test_msg_utils.c new file mode 100644 index 000000000..afa78fae4 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_msg_utils.c @@ -0,0 +1,66 @@ +/* +** 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. +*/ + +/* + * Message header test utilities + */ + +/* + * Includes + */ +#include "cfe_msg_api.h" +#include "test_msg_utils.h" + +void Test_MSG_PrintMsg(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Size_t Size) +{ + + int i; + + if (Size == 0) + { + CFE_MSG_GetSize(MsgPtr, &Size); + } + + printf("Message - "); + for (i = 0; i < Size; i++) + { + printf("%02X", MsgPtr->Byte[i]); + if (i % 2 == 1) + printf(" "); + } + printf("\n"); +} + +unsigned long long int Test_MSG_Sum(const CFE_MSG_Message_t *MsgPtr) +{ + + CFE_MSG_Size_t length; + unsigned long long int sum = 0; + int i; + + CFE_MSG_GetSize(MsgPtr, &length); + + for (i = 0; i < length; i++) + { + sum += MsgPtr->Byte[i]; + } + + return sum; +} diff --git a/modules/msg/unit-test-coverage/test_msg_utils.h b/modules/msg/unit-test-coverage/test_msg_utils.h new file mode 100644 index 000000000..8ff2c6ef8 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_msg_utils.h @@ -0,0 +1,45 @@ +/* +** 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. +*/ + +/* + * Message header test utilities + */ +#ifndef test_msg_utils_ +#define test_msg_utils_ + +/* + * Includes + */ +#include "cfe_msg_typedefs.h" + +/* + * Defines + */ + +/* Subtest macro */ +#define MSG_UT_ADD_SUBTEST(Func) UT_AddSubTest(Func, NULL, NULL, __func__, #Func) + +/* Prints the message, 0 length uses length from message */ +void Test_MSG_PrintMsg(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Size_t Size); + +/* Sums the message for checking, generically check the entire message */ +unsigned long long int Test_MSG_Sum(const CFE_MSG_Message_t *MsgPtr); + +#endif /* test_msg_utils_ */