From d3a073e90cbb6f8529f468c751b144138973bb26 Mon Sep 17 00:00:00 2001 From: Jacob Hageman Date: Fri, 14 Aug 2020 10:31:40 -0400 Subject: [PATCH 1/9] Fix #711, Add message header module Implements message header module such that users can customize or extend as needed. - Separates code for easier selection - Implements consistent getter/setter APIs - Fix #736/#781: MsgId logic no longer overrides bits in init - Fix #529: Get size supports max size - Adds single big endian time implementation, but not selected - Adds msg module to module list - Adds msg module to cppcheck --- .travis.yml | 4 +- cmake/mission_defaults.cmake | 1 + fsw/cfe-core/src/inc/cfe_msg_api.h | 665 ++++++++++++++++++ fsw/cfe-core/src/inc/cfe_msg_typedefs.h | 90 +++ modules/msg/CMakeLists.txt | 62 ++ modules/msg/mission_build.cmake | 27 + .../msg/mission_inc/default_cfe_msg_hdr_pri.h | 89 +++ .../mission_inc/default_cfe_msg_hdr_priext.h | 90 +++ .../msg/mission_inc/default_cfe_msg_sechdr.h | 93 +++ modules/msg/private_inc/cfe_msg_defaults.h | 84 +++ modules/msg/private_inc/cfe_msg_priv.h | 81 +++ modules/msg/src/cfe_msg_ccsdsext.c | 250 +++++++ modules/msg/src/cfe_msg_ccsdspri.c | 352 +++++++++ modules/msg/src/cfe_msg_init.c | 57 ++ modules/msg/src/cfe_msg_initdefaulthdr_pri.c | 34 + .../msg/src/cfe_msg_initdefaulthdr_priext.c | 35 + modules/msg/src/cfe_msg_msgid_shared.c | 46 ++ modules/msg/src/cfe_msg_msgid_v1.c | 71 ++ modules/msg/src/cfe_msg_msgid_v2.c | 111 +++ modules/msg/src/cfe_msg_sechdr_checksum.c | 116 +++ modules/msg/src/cfe_msg_sechdr_fc.c | 88 +++ modules/msg/src/cfe_msg_sechdr_time.c | 97 +++ modules/msg/src/cfe_msg_sechdr_time_old.c | 137 ++++ 23 files changed, 2678 insertions(+), 2 deletions(-) create mode 100644 fsw/cfe-core/src/inc/cfe_msg_api.h create mode 100644 fsw/cfe-core/src/inc/cfe_msg_typedefs.h create mode 100644 modules/msg/CMakeLists.txt create mode 100644 modules/msg/mission_build.cmake create mode 100644 modules/msg/mission_inc/default_cfe_msg_hdr_pri.h create mode 100644 modules/msg/mission_inc/default_cfe_msg_hdr_priext.h create mode 100644 modules/msg/mission_inc/default_cfe_msg_sechdr.h create mode 100644 modules/msg/private_inc/cfe_msg_defaults.h create mode 100644 modules/msg/private_inc/cfe_msg_priv.h create mode 100644 modules/msg/src/cfe_msg_ccsdsext.c create mode 100644 modules/msg/src/cfe_msg_ccsdspri.c create mode 100644 modules/msg/src/cfe_msg_init.c create mode 100644 modules/msg/src/cfe_msg_initdefaulthdr_pri.c create mode 100644 modules/msg/src/cfe_msg_initdefaulthdr_priext.c create mode 100644 modules/msg/src/cfe_msg_msgid_shared.c create mode 100644 modules/msg/src/cfe_msg_msgid_v1.c create mode 100644 modules/msg/src/cfe_msg_msgid_v2.c create mode 100644 modules/msg/src/cfe_msg_sechdr_checksum.c create mode 100644 modules/msg/src/cfe_msg_sechdr_fc.c create mode 100644 modules/msg/src/cfe_msg_sechdr_time.c create mode 100644 modules/msg/src/cfe_msg_sechdr_time_old.c diff --git a/.travis.yml b/.travis.yml index 0616343b8..8b098f179 100644 --- a/.travis.yml +++ b/.travis.yml @@ -17,8 +17,8 @@ script: # Check versions - cppcheck --version - #cppcheck flight software cfe/fsw/cfe-core/src - - cppcheck --force --inline-suppr --std=c99 --language=c --error-exitcode=1 --enable=warning,performance,portability,style --suppress=variableScope --inconclusive fsw/cfe-core/src 2>cppcheck_flight_cfe.txt + #cppcheck flight software fsw/cfe-core/src and modules + - cppcheck --force --inline-suppr --std=c99 --language=c --error-exitcode=1 --enable=warning,performance,portability,style --suppress=variableScope --inconclusive fsw/cfe-core/src modules 2>cppcheck_flight_cfe.txt - | if [[ -s cppcheck_flight_cfe.txt ]]; then echo "You must fix cppcheck errors before submitting a pull request" diff --git a/cmake/mission_defaults.cmake b/cmake/mission_defaults.cmake index 8f49d54d5..79d1fb1bd 100644 --- a/cmake/mission_defaults.cmake +++ b/cmake/mission_defaults.cmake @@ -14,6 +14,7 @@ set(MISSION_CORE_MODULES "cfe-core" "osal" "psp" + "msg" ) # The "MISSION_GLOBAL_APPLIST" is a set of apps/libs that will be built diff --git a/fsw/cfe-core/src/inc/cfe_msg_api.h b/fsw/cfe-core/src/inc/cfe_msg_api.h new file mode 100644 index 000000000..7584b1f76 --- /dev/null +++ b/fsw/cfe-core/src/inc/cfe_msg_api.h @@ -0,0 +1,665 @@ +/* +** 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 access APIs + */ + +#ifndef _cfe_msg_api_ +#define _cfe_msg_api_ + +/* + * Includes + */ +#include "common_types.h" +#include "cfe_msg_hdr.h" +#include "cfe_msg_typedefs.h" +#include "cfe_time.h" +#include "cfe_sb.h" + +/** \defgroup CFEAPIMSGHeader cFE Message header APIs + * \{ + */ + +/*****************************************************************************/ +/** + * \brief Initialize a message + * + * \par Description + * This routine initialize a message. If Clear is true the + * message is cleard and constant header defaults are set. + * The bits from MsgId and message size are always set. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] MsgId MsgId that corresponds to message + * \param[in] Size Total size of the mesage (used to set length field) + * \param[in] Clear Boolean to clear and set defaults + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_Init(CFE_MSG_Message_t *MsgPtr, CFE_SB_MsgId_t MsgId, CFE_MSG_Size_t Size, bool Clear); + +/*****************************************************************************/ +/** + * \brief Gets the total size of a message. + * + * \par Description + * This routine gets the total size of the message. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] Size Total message size + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetSize(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Size_t *Size); + +/*****************************************************************************/ +/** + * \brief Sets the total size of a message. + * + * \par Description + * This routine sets the total size of the message. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] Size Total message size + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetSize(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Size_t Size); + +/*****************************************************************************/ +/** + * \brief Gets the message type. + * + * \par Description + * This routine gets the message type. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] Type Message type + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetType(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Type_t *Type); + +/*****************************************************************************/ +/** + * \brief Sets the message type. + * + * \par Description + * This routine sets the message type. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] Type Message type + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetType(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Type_t Type); + +/*****************************************************************************/ +/** + * \brief Gets the message header version. + * + * \par Description + * This routine gets the message header version. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] Version Header version + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetHeaderVersion(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_HeaderVersion_t *Version); + +/*****************************************************************************/ +/** + * \brief Sets the message header version. + * + * \par Description + * This routine sets the message header version. Typically only + * set within message initialization and not used by APPs. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] Version Header version + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetHeaderVersion(CFE_MSG_Message_t *MsgPtr, CFE_MSG_HeaderVersion_t Version); + +/*****************************************************************************/ +/** + * \brief Gets the message secondary header boolean + * + * \par Description + * This routine gets the message secondary header boolean. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] HasSecondary Has secondary header flag + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetHasSecondaryHeader(const CFE_MSG_Message_t *MsgPtr, bool *HasSecondary); + +/*****************************************************************************/ +/** + * \brief Sets the message secondary header boolean + * + * \par Description + * This routine sets the message has secondary header boolean. Typically only + * set within message initialization and not used by APPs. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] HasSecondary Has secondary header flag + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetHasSecondaryHeader(CFE_MSG_Message_t *MsgPtr, bool HasSecondary); + +/*****************************************************************************/ +/** + * \brief Gets the message application ID + * + * \par Description + * This routine gets the message application ID. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] ApId Application ID + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetApId(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_ApId_t *ApId); + +/*****************************************************************************/ +/** + * \brief Sets the message application ID + * + * \par Description + * This routine sets the message application ID. Typically set + * at initialization using the MsgId, but API available to set + * bits that may not be included in MsgId. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] ApId Application ID + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetApId(CFE_MSG_Message_t *MsgPtr, CFE_MSG_ApId_t ApId); + +/*****************************************************************************/ +/** + * \brief Gets the message segmentation flag + * + * \par Description + * This routine gets the message segmentation flag + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] SegFlag Segmentation flag + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetSegmentationFlag(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_SegmentationFlag_t *SegFlag); + +/*****************************************************************************/ +/** + * \brief Sets the message segmentation flag + * + * \par Description + * This routine sets the message segmentation flag. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] SegFlag Segmentation flag + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetSegmentationFlag(CFE_MSG_Message_t *MsgPtr, CFE_MSG_SegmentationFlag_t SegFlag); + +/*****************************************************************************/ +/** + * \brief Gets the message sequence count + * + * \par Description + * This routine gets the message sequence count. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] SeqCnt Sequence count + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetSequenceCount(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_SequenceCount_t *SeqCnt); + +/*****************************************************************************/ +/** + * \brief Sets the message sequence count + * + * \par Description + * This routine sets the message sequence count. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] SeqCnt Sequence count + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetSequenceCount(CFE_MSG_Message_t *MsgPtr, CFE_MSG_SequenceCount_t SeqCnt); + +/*****************************************************************************/ +/** + * \brief Gets the message EDS version + * + * \par Description + * This routine gets the message EDS version. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] Version EDS Version + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetEDSVersion(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_EDSVersion_t *Version); + +/*****************************************************************************/ +/** + * \brief Sets the message EDS version + * + * \par Description + * This routine sets the message EDS version. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] Version EDS Version + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetEDSVersion(CFE_MSG_Message_t *MsgPtr, CFE_MSG_EDSVersion_t Version); + +/*****************************************************************************/ +/** + * \brief Gets the message endian + * + * \par Description + * This routine gets the message endian. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] Endian Endian + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetEndian(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Endian_t *Endian); + +/*****************************************************************************/ +/** + * \brief Sets the message endian + * + * \par Description + * This routine sets the message endian. Invalid endian selection + * will set big endian. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] Endian Endian + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetEndian(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Endian_t Endian); + +/*****************************************************************************/ +/** + * \brief Gets the message playback flag + * + * \par Description + * This routine gets the message playback flag. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] PlayFlag Playback Flag + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetPlaybackFlag(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_PlaybackFlag_t *PlayFlag); + +/*****************************************************************************/ +/** + * \brief Sets the message playback flag + * + * \par Description + * This routine sets the message playback flag. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] PlayFlag Playback Flag + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetPlaybackFlag(CFE_MSG_Message_t *MsgPtr, CFE_MSG_PlaybackFlag_t PlayFlag); + +/*****************************************************************************/ +/** + * \brief Gets the message subsystem + * + * \par Description + * This routine gets the message subsystem + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] Subsystem Subsystem + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetSubsystem(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Subsystem_t *Subsystem); + +/*****************************************************************************/ +/** + * \brief Sets the message subsystem + * + * \par Description + * This routine sets the message subsystem. Some bits may + * be set at initialization using the MsgId, but API available to set + * bits that may not be included in MsgId. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] Subsystem Subsystem + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetSubsystem(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Subsystem_t Subsystem); + +/*****************************************************************************/ +/** + * \brief Gets the message system + * + * \par Description + * This routine gets the message system id + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] System System + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetSystem(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_System_t *System); + +/*****************************************************************************/ +/** + * \brief Sets the message system + * + * \par Description + * This routine sets the message system id. Some bits may + * be set at initialization using the MsgId, but API available to set + * bits that may not be included in MsgId. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] System System + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetSystem(CFE_MSG_Message_t *MsgPtr, CFE_MSG_System_t System); + +/*****************************************************************************/ +/** + * \brief Calculates and sets the checksum of a message + * + * \par Description + * This routine calculates the checksum of a message according + * to an implementation-defined algorithm. Then, it sets the checksum field + * in the message with the calculated value. The contents and location of + * this field will depend on the underlying implementation of + * messages. It may be a checksum, a CRC, or some other algorithm. + * + * \par Assumptions, External Events, and Notes: + * - If the underlying implementation of messages does not + * include a checksum field, then this routine will return + * #CFE_MSG_WRONG_MSG_TYPE + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + * \retval #CFE_MSG_WRONG_MSG_TYPE \copybrief CFE_MSG_WRONG_MSG_TYPE + */ +int32 CFE_MSG_GenerateChecksum(CFE_MSG_Message_t *MsgPtr); + +/*****************************************************************************/ +/** + * \brief Validates the checksum of a message. + * + * \par Description + * This routine validates the checksum of a message + * according to an implementation-defined algorithm. + * + * \par Assumptions, External Events, and Notes: + * - If the underlying implementation of messages does not + * include a checksum field, then this routine will return + * #CFE_MSG_WRONG_MSG_TYPE and set the IsValid parameter false. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * This must point to the first byte of the message header. + * \param[out] IsValid Checksum validation result + * \arg true - valid + * \arg false - invalid or not supported/implemented + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + * \retval #CFE_MSG_WRONG_MSG_TYPE \copybrief CFE_MSG_WRONG_MSG_TYPE + */ +int32 CFE_MSG_ValidateChecksum(const CFE_MSG_Message_t *MsgPtr, bool *IsValid); + +/*****************************************************************************/ +/** + * \brief Sets the function code field in a message. + * + * \par Description + * This routine sets the function code of a message. + * + * \par Assumptions, External Events, and Notes: + * - If the underlying implementation of messages does not + * include a function code field, then this routine will do nothing to + * the message contents and will return #CFE_MSG_WRONG_MSG_TYPE. + * + * \param[in, out] MsgPtr A pointer to the buffer that contains the message. + * \param[in] FcnCode The function code to include in the message. + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + * \retval #CFE_MSG_WRONG_MSG_TYPE \copybrief CFE_MSG_WRONG_MSG_TYPE + * + */ +int32 CFE_MSG_SetFcnCode(CFE_MSG_Message_t *MsgPtr, CFE_MSG_FcnCode_t FcnCode); + +/*****************************************************************************/ +/** + * \brief Gets the function code field from a message. + * + * \par Description + * This routine gets the function code from a message. + * + * \par Assumptions, External Events, and Notes: + * - If the underlying implementation of messages does not + * include a function code field, then this routine will + * set FcnCode to zero and return #CFE_MSG_WRONG_MSG_TYPE + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] FcnCode The function code from the message + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + * \retval #CFE_MSG_WRONG_MSG_TYPE \copybrief CFE_MSG_WRONG_MSG_TYPE + */ +int32 CFE_MSG_GetFcnCode(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_FcnCode_t *FcnCode); + +/*****************************************************************************/ +/** + * \brief Gets the time field from a message. + * + * \par Description + * This routine gets the time from a message. + * + * \par Assumptions, External Events, and Notes: + * - If the underlying implementation of messages does not + * include a time field, then this routine will set Time + * to zero and return #CFE_MSG_WRONG_MSG_TYPE + * - Note default implementation of command messages do not have a time field. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] Time Time from the message + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + * \retval #CFE_MSG_WRONG_MSG_TYPE \copybrief CFE_MSG_WRONG_MSG_TYPE + */ +int32 CFE_MSG_GetMsgTime(const CFE_MSG_Message_t *MsgPtr, CFE_TIME_SysTime_t *Time); + +/*****************************************************************************/ +/** + * \brief Sets the time field in a message. + * + * \par Description + * This routine sets the time of a message. Most applications + * will want to use #CFE_SB_TimeStampMsg instead of this function. But, + * when needed, this API can be used to set multiple messages + * with identical time stamps. + * + * \par Assumptions, External Events, and Notes: + * - If the underlying implementation of messages does not include + * a time field, then this routine will do nothing to the message contents + * and will return #CFE_MSG_WRONG_MSG_TYPE. + * - Note default implementation of command messages do not have a time field. + * + * \param[in, out] MsgPtr A pointer to the message. + * \param[in] Time The time to include in the message. This will usually be a time + * from #CFE_TIME_GetTime. + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + * \retval #CFE_MSG_WRONG_MSG_TYPE \copybrief CFE_MSG_WRONG_MSG_TYPE + */ +int32 CFE_MSG_SetMsgTime(CFE_MSG_Message_t *MsgPtr, CFE_TIME_SysTime_t Time); + +/**\}*/ + +/** \defgroup CFEAPIMSGMsgId cFE Message Id APIs + * \{ + */ + +/*****************************************************************************/ +/** + * \brief Gets the message id from a message. + * + * \par Description + * This routine gets the message id from a message. The message id + * is a hash of bits in the message header, used by the software bus for + * routing. Message id needs to be unique for each endpoint + * in the system. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] MsgId Message id + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetMsgId(const CFE_MSG_Message_t *MsgPtr, CFE_SB_MsgId_t *MsgId); + +/*****************************************************************************/ +/** + * \brief Sets the message id bits in a message. + * + * \par Description + * This routine sets the message id bits in a message. The message id + * is a hash of bits in the message header, used by the software bus for + * routing. Message id needs to be unique for each endpoint + * in the system. + * \par Note + * This API only sets the bits in the header that make up the message ID. + * No other values in the header are modified. + * + * \param[in] MsgPtr A pointer to the buffer that contains the message. + * \param[out] MsgId Message id + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_SetMsgId(CFE_MSG_Message_t *MsgPtr, CFE_SB_MsgId_t MsgId); + +/*****************************************************************************/ +/** + * \brief Gets message type using message ID + * + * \par Description + * This routine gets the message type using the message ID + * + * \param[in] MsgId Message id + * \param[out] Type Message type + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval #CFE_MSG_BAD_ARGUMENT \copybrief CFE_MSG_BAD_ARGUMENT + */ +int32 CFE_MSG_GetTypeFromMsgId(CFE_SB_MsgId_t MsgId, CFE_MSG_Type_t *Type); + +/**\}*/ + +#endif /* _cfe_msg_api_ */ diff --git a/fsw/cfe-core/src/inc/cfe_msg_typedefs.h b/fsw/cfe-core/src/inc/cfe_msg_typedefs.h new file mode 100644 index 000000000..0397d0fd7 --- /dev/null +++ b/fsw/cfe-core/src/inc/cfe_msg_typedefs.h @@ -0,0 +1,90 @@ +/* +** 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 type defines + * - Separate from API so these can be adjusted for custom implementations + */ + +#ifndef _cfe_msg_typedefs_ +#define _cfe_msg_typedefs_ + +/* + * Includes + */ +#include "common_types.h" +#include "cfe_error.h" + +/* + * Defines + */ +/* Error bits won't fit a new module so reuse SB error codes */ +#define CFE_MSG_BAD_ARGUMENT CFE_SB_BAD_ARGUMENT /**< \brief Error - bad argument */ +#define CFE_MSG_NOT_IMPLEMENTED CFE_SB_NOT_IMPLEMENTED /**< \brief Error - not implemented */ +#define CFE_MSG_WRONG_MSG_TYPE CFE_SB_WRONG_MSG_TYPE /**< \brief Error - wrong type */ + +/* + * Types + */ +typedef uint32 CFE_MSG_Size_t; /**< \brief Message size (CCSDS needs uint32 for max size) */ +typedef uint32 CFE_MSG_Checksum_t; /**< \brief Message checksum (Oversized to avoid redefine) */ +typedef uint16 CFE_MSG_FcnCode_t; /**< \brief Message function code */ +typedef uint16 CFE_MSG_HeaderVersion_t; /**< \brief Message header version */ +typedef uint16 CFE_MSG_ApId_t; /**< \brief Message application ID */ +typedef uint16 CFE_MSG_SequenceCount_t; /**< \brief Message sequence count */ +typedef uint16 CFE_MSG_EDSVersion_t; /**< \brief Message EDS version */ +typedef uint16 CFE_MSG_Subsystem_t; /**< \brief Message subsystem */ +typedef uint16 CFE_MSG_System_t; /**< \brief Message system */ + +/** \brief Message type */ +typedef enum +{ + CFE_MSG_Type_Invalid, /**< \brief Message type invalid, undefined, not implemented */ + CFE_MSG_Type_Cmd, /**< \brief Command message type */ + CFE_MSG_Type_Tlm /**< \brief Telemetry message type */ +} CFE_MSG_Type_t; + +/** \brief Segmentation flags */ +typedef enum +{ + CFE_MSG_SegFlag_Invalid, /**< \brief Invalid segmentation flag */ + CFE_MSG_SegFlag_Continue, /**< \brief Continuation segment of User Data */ + CFE_MSG_SegFlag_First, /**< \brief First segment of User Data */ + CFE_MSG_SegFlag_Last, /**< \brief Last segment of User Data */ + CFE_MSG_SegFlag_Unsegmented /**< \brief Unsegemented data */ +} CFE_MSG_SegmentationFlag_t; + +/** \brief Endian flag */ +typedef enum +{ + CFE_MSG_Endian_Invalid, /**< \brief Invalid endian setting */ + CFE_MSG_Endian_Big, /**< \brief Big endian */ + CFE_MSG_Endian_Little /**< \brief Little endian */ +} CFE_MSG_Endian_t; + +/** \brief Playback flag */ +typedef enum +{ + CFE_MSG_PlayFlag_Invalid, /**< \brief Invalid playback setting */ + CFE_MSG_PlayFlag_Original, /**< \brief Original */ + CFE_MSG_PlayFlag_Playback /**< \brief Playback */ +} CFE_MSG_PlaybackFlag_t; + +#endif /* _cfe_msg_typedefs_ */ diff --git a/modules/msg/CMakeLists.txt b/modules/msg/CMakeLists.txt new file mode 100644 index 000000000..1d6f2e04c --- /dev/null +++ b/modules/msg/CMakeLists.txt @@ -0,0 +1,62 @@ +################################################################## +# +# cFE message module CMake build recipe +# +# This CMakeLists.txt adds source files for +# message module included in the cFE distribution. Selected +# files are built into a static library that in turn +# is linked into the final executable. +# +# Note this is different than applications which are dynamically +# linked to support runtime loading. The core applications all +# use static linkage. +# +################################################################## + +# Add the basic set of files which are always built +# Defined as absolute so this list can also be used to build unit tests +set(${DEP}_SRC + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_ccsdspri.c + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_init.c + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_msgid_shared.c + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_sechdr_checksum.c + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_sechdr_fc.c + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_sechdr_time_old.c +) + +# Source selection for if CCSDS extended header is included, and MsgId version use +if (MISSION_INCLUDE_CCSDSEXT_HEADER) + message(STATUS "CCSDS primary and extended header included in message header") + list(APPEND ${DEP}_SRC + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_ccsdsext.c + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_initdefaulthdr_priext.c) + if (MISSION_MSGID_V2) # MsgId v2 or v1 can be used with extended headers + message(STATUS "Message Id version 2 in use (MsgId V2)") + list(APPEND ${DEP}_SRC + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_msgid_v2.c) + else (MISSION_MSGID_V2) + message(STATUS "Message Id version 1 in use (MsgId V1)") + list(APPEND ${DEP}_SRC + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_msgid_v1.c) + endif (MISSION_MSGID_V2) +else (MISSION_INCLUDE_CCSDSEXT_HEADER) + message(STATUS "CCSDS primary header included in message header (not including CCSDS extended header)") + message(STATUS "Message Id version 1 in use (MsgId V1)") + list(APPEND ${DEP}_SRC + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_initdefaulthdr_pri.c + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_msgid_v1.c) + if (MISSION_MSGID_V2) + message(FATAL_ERROR "Message Id (MsgId) version 2 can only be used if MISSION_INCLUDE_CCSDSEXT_HEADER is set") + endif (MISSION_MSGID_V2) +endif (MISSION_INCLUDE_CCSDSEXT_HEADER) + +# Module library +add_library(${DEP} STATIC ${${DEP}_SRC}) + +# Add private include +target_include_directories(${DEP} PRIVATE private_inc) + +# Add unit test coverage subdirectory +if(ENABLE_UNIT_TESTS) + add_subdirectory(unit-test-coverage) +endif(ENABLE_UNIT_TESTS) diff --git a/modules/msg/mission_build.cmake b/modules/msg/mission_build.cmake new file mode 100644 index 000000000..b34a3f6e5 --- /dev/null +++ b/modules/msg/mission_build.cmake @@ -0,0 +1,27 @@ +########################################################### +# +# MSG mission build setup +# +# This file is evaluated as part of the "prepare" stage +# and can be used to set up prerequisites for the build, +# such as generating header files +# +########################################################### + +# Extended header inclusion selection +if (MISSION_INCLUDE_CCSDSEXT_HEADER) + set(MSG_HDR_FILE "default_cfe_msg_hdr_priext.h") +else (MISSION_INCLUDE_CCSDSEXT_HEADER) + set(MSG_HDR_FILE "default_cfe_msg_hdr_pri.h") +endif (MISSION_INCLUDE_CCSDSEXT_HEADER) + +# Generate the header definition files, use local default for this module) +generate_config_includefile( + FILE_NAME "cfe_msg_hdr.h" + FALLBACK_FILE "${CMAKE_CURRENT_LIST_DIR}/mission_inc/${MSG_HDR_FILE}" +) + +generate_config_includefile( + FILE_NAME "cfe_msg_sechdr.h" + FALLBACK_FILE "${CMAKE_CURRENT_LIST_DIR}/mission_inc/default_cfe_msg_sechdr.h" +) diff --git a/modules/msg/mission_inc/default_cfe_msg_hdr_pri.h b/modules/msg/mission_inc/default_cfe_msg_hdr_pri.h new file mode 100644 index 000000000..d422106db --- /dev/null +++ b/modules/msg/mission_inc/default_cfe_msg_hdr_pri.h @@ -0,0 +1,89 @@ +/* +** 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. +*/ + +/****************************************************************************** + * Define cFS standard full header + * - Avoid direct access for portability, use APIs + * - Used to construct message structures + */ + +#ifndef _cfe_msg_hdr_ +#define _cfe_msg_hdr_ + +/* + * Include Files + */ + +#include "common_types.h" +#include "ccsds_hdr.h" +#include "cfe_msg_sechdr.h" + +/* + * Type Definitions + */ + +/********************************************************************** + * Structure definitions for full header + * + * These are based on historically supported definitions and not + * an open source standard. + */ + +/** + * \brief Full CCSDS header + */ +typedef struct +{ + CCSDS_PrimaryHeader_t Pri; /**< \brief CCSDS Primary Header */ +} CCSDS_SpacePacket_t; + +/** + * \brief cFS command header + */ +typedef struct +{ + + CCSDS_SpacePacket_t CCSDS; /**< \brief CCSDS header */ + CFE_MSG_CommandSecondaryHeader_t Sec; /**< \brief Secondary header */ + +} CFE_MSG_CommandHeader_t; + +/** + * \brief cFS telemetry header + */ +typedef struct +{ + + CCSDS_SpacePacket_t CCSDS; /**< \brief CCSDS header */ + CFE_MSG_TelemetrySecondaryHeader_t Sec; /**< \brief Secondary header */ + +} CFE_MSG_TelemetryHeader_t; + +/** + * \brief cFS Generic packet header + */ +typedef union +{ + CCSDS_SpacePacket_t CCSDS; /**< \brief CCSDS Header (Pri or Pri + Ext) */ + uint32 Align; /**< \brief Force 32-bit alignment */ + uint8 Byte[sizeof(CCSDS_SpacePacket_t)]; /**< \brief Byte level access */ +} CFE_MSG_Message_t; + +#endif /* _cfe_msg_hdr_ */ diff --git a/modules/msg/mission_inc/default_cfe_msg_hdr_priext.h b/modules/msg/mission_inc/default_cfe_msg_hdr_priext.h new file mode 100644 index 000000000..652925269 --- /dev/null +++ b/modules/msg/mission_inc/default_cfe_msg_hdr_priext.h @@ -0,0 +1,90 @@ +/* +** 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. +*/ + +/****************************************************************************** + * Define cFS standard full header + * - Avoid direct access for portability, use APIs + * - Used to construct message structures + */ + +#ifndef _cfe_msg_hdr_ +#define _cfe_msg_hdr_ + +/* + * Include Files + */ + +#include "common_types.h" +#include "ccsds_hdr.h" +#include "cfe_msg_sechdr.h" + +/* + * Type Definitions + */ + +/********************************************************************** + * Structure definitions for full header + * + * These are based on historically supported definitions and not + * an open source standard. + */ + +/** + * \brief Full CCSDS header + */ +typedef struct +{ + CCSDS_PrimaryHeader_t Pri; /**< \brief CCSDS Primary Header */ + CCSDS_ExtendedHeader_t Ext; /**< \brief CCSDS Extended Header */ +} CCSDS_SpacePacket_t; + +/** + * \brief cFS command header + */ +typedef struct +{ + + CCSDS_SpacePacket_t CCSDS; /**< \brief CCSDS header */ + CFE_MSG_CommandSecondaryHeader_t Sec; /**< \brief Secondary header */ + +} CFE_MSG_CommandHeader_t; + +/** + * \brief cFS telemetry header + */ +typedef struct +{ + + CCSDS_SpacePacket_t CCSDS; /**< \brief CCSDS header */ + CFE_MSG_TelemetrySecondaryHeader_t Sec; /**< \brief Secondary header */ + +} CFE_MSG_TelemetryHeader_t; + +/** + * \brief cFS Generic packet header + */ +typedef union +{ + CCSDS_SpacePacket_t CCSDS; /**< \brief CCSDS Header (Pri or Pri + Ext) */ + uint32 Align; /**< \brief Force 32-bit alignment */ + uint8 Byte[sizeof(CCSDS_SpacePacket_t)]; /**< \brief Byte level access */ +} CFE_MSG_Message_t; + +#endif /* _cfe_msg_hdr_ */ diff --git a/modules/msg/mission_inc/default_cfe_msg_sechdr.h b/modules/msg/mission_inc/default_cfe_msg_sechdr.h new file mode 100644 index 000000000..d4d7a678a --- /dev/null +++ b/modules/msg/mission_inc/default_cfe_msg_sechdr.h @@ -0,0 +1,93 @@ +/* +** 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. +*/ + +/****************************************************************************** + * Define cFS standard secondary header + * - Avoid direct access for portability, use APIs + * - Used to construct message structures + */ + +#ifndef _cfe_msg_sechdr_ +#define _cfe_msg_sechdr_ + +/* + * Include Files + */ + +#include "common_types.h" +#include "cfe_mission_cfg.h" + +/* + * Defines + */ + +/* These go away w/ single framework implementation */ +/* CCSDS_TIME_SIZE is specific to the selected CFE_SB time format */ +#if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) +/* 32 bits seconds + 16 bits subseconds */ +#define CCSDS_TIME_SIZE 6 +#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_SUBS) +/* 32 bits seconds + 32 bits subseconds */ +#define CCSDS_TIME_SIZE 8 +#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20) +/* 32 bits seconds + 20 bits microsecs + 12 bits reserved */ +#define CCSDS_TIME_SIZE 8 +#else +/* unknown format */ +#error unable to define CCSDS_TIME_SIZE! +#endif + +/* + * Type Definitions + */ + +/********************************************************************** + * Structure definitions for secondary headers + * + * These are based on historically supported definitions and not + * an open source standard. + */ + +/** + * \brief cFS command secondary header + */ +typedef struct +{ + + uint8 FunctionCode; /**< \brief Command Function Code */ + /* bits shift ---------description-------- */ + /* 0x7F 0 Command function code */ + /* 0x80 7 Reserved */ + + uint8 Checksum; /**< \brief Command checksum (all bits, 0xFF) */ + +} CFE_MSG_CommandSecondaryHeader_t; + +/** + * \brief cFS telemetry secondary header + */ +typedef struct +{ + + uint8 Time[CCSDS_TIME_SIZE]; /**< \brief Time sized for selected format */ + +} CFE_MSG_TelemetrySecondaryHeader_t; + +#endif /* _cfe_msg_sechdr_ */ diff --git a/modules/msg/private_inc/cfe_msg_defaults.h b/modules/msg/private_inc/cfe_msg_defaults.h new file mode 100644 index 000000000..ab1541672 --- /dev/null +++ b/modules/msg/private_inc/cfe_msg_defaults.h @@ -0,0 +1,84 @@ +/* +** 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 defaults, used to initialize messages + * - Avoid including outside this module + */ + +#ifndef _cfe_msg_defaults_ +#define _cfe_msg_defaults_ + +/* + * Includes + */ +#include "cfe_platform_cfg.h" +#include "cfe_mission_cfg.h" + +/* + * Defines + */ + +/* Backwards compatibility */ +#ifndef CFE_PLATFORM_DEFAULT_APID +#define CFE_PLATFORM_DEFAULT_APID 0 /**< \brief Default APID, for bits not in MsgId */ +#endif + +#ifndef CFE_MISSION_CCSDSVER +#ifdef MESSAGE_FORMAT_IS_CCSDS_VER_2 +#define CFE_MISSION_CCSDSVER 1 /**< \brief Default CCSDS Version, cFS Ver 2 historically = 1 */ +#else +#define CFE_MISSION_CCSDSVER 0 /**< \brief Default CCSDS Version, cFS Ver 1 historically = 0 */ +#endif +#endif + +#ifndef CFE_PLATFORM_DEFAULT_SUBSYS +#define CFE_PLATFORM_DEFAULT_SUBSYS 0 /**< \brief Default SubSystem, for bits not in MsgId */ +#endif + +#ifndef CFE_PLATFORM_EDSVER +#define CFE_PLATFORM_EDSVER 1 /**< \brief Default EDS version, cFS historically = 1 */ +#endif + +/*****************************************************************************/ +/** + * \brief Set CCSDS Primary header defaults + * + * \par DESCRIPTION + * Only sets the constant defaults. Internal function assumes + * pointer is valid. + * + * \param[out] MsgPtr Message to set + */ +void CFE_MSG_SetDefaultCCSDSPri(CFE_MSG_Message_t *MsgPtr); + +/*****************************************************************************/ +/** + * \brief Set CCSDS Extended header defaults + * + * \par DESCRIPTION + * Only sets the constant defaults. Internal function assumes + * pointer is valid. + * + * \param[out] MsgPtr Message to set + */ +void CFE_MSG_SetDefaultCCSDSExt(CFE_MSG_Message_t *MsgPtr); + +#endif /* _cfe_msg_default_ */ diff --git a/modules/msg/private_inc/cfe_msg_priv.h b/modules/msg/private_inc/cfe_msg_priv.h new file mode 100644 index 000000000..32d785715 --- /dev/null +++ b/modules/msg/private_inc/cfe_msg_priv.h @@ -0,0 +1,81 @@ +/* +** 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 private header + * - Avoid including outside this module + */ + +#ifndef _cfe_msg_priv_ +#define _cfe_msg_priv_ + +/* + * Includes + */ +#include "common_types.h" + +/*****************************************************************************/ +/** + * \brief get generic header field (uint8 array[2]) + * + * \par DESCRIPTION + * Big endian get of header field given mask. Only sets bits + * in value that are part of mask. + * + * \param[in] Word Header value to set + * \param[out] Val Value to set + * \param[in] Mask Mask used for set + */ +static inline void CFE_MSG_GetHeaderField(const uint8 *Word, uint16 *Val, uint16 Mask) +{ + *Val = (Word[0] << 8 | Word[1]) & Mask; +} + +/*****************************************************************************/ +/** + * \brief Set generic header field (uint8 array[2]) + * + * \par DESCRIPTION + * Big endian set of header field given value and mask. Only sets bits + * from value that are part of mask. + * + * \param[in, out] Word Header value to set + * \param[in] Val Value to set + * \param[in] Mask Mask used for set + */ +static inline void CFE_MSG_SetHeaderField(uint8 *Word, uint16 Val, uint16 Mask) +{ + Word[0] = (Word[0] & ~(Mask >> 8)) | ((Val & Mask) >> 8); + Word[1] = ((Word[1] & ~Mask) | (Val & Mask)) & 0xFF; +} + +/*****************************************************************************/ +/** + * \brief Initialize default header - implemented based on selected header format + * + * \par DESCRIPTION + * Sets the constant defaults for the entire header. Internal function + * assumes pointer is valid. + * + * \param[out] MsgPtr Message to set + */ +void CFE_MSG_InitDefaultHdr(CFE_MSG_Message_t *MsgPtr); + +#endif /* _cfe_msg_priv_ */ diff --git a/modules/msg/src/cfe_msg_ccsdsext.c b/modules/msg/src/cfe_msg_ccsdsext.c new file mode 100644 index 000000000..6c7587c3b --- /dev/null +++ b/modules/msg/src/cfe_msg_ccsdsext.c @@ -0,0 +1,250 @@ +/* +** 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 CCSDS extended header implementations + */ +#include "cfe_msg_api.h" +#include "cfe_msg_priv.h" +#include "cfe_msg_defaults.h" +#include "cfe_error.h" + +/* CCSDS Extended definitions */ +#define CFE_MSG_EDSVER_SHIFT 11 /**< \brief CCSDS EDS version shift */ +#define CFE_MSG_EDSVER_MASK 0xF800 /**< \brief CCSDS EDS version mask */ +#define CFE_MSG_ENDIAN_MASK 0x0400 /**< \brief CCSDS endiam mask, little endian when set */ +#define CFE_MSG_PLAYBACK_MASK 0x0200 /**< \brief CCSDS playback flag, playback when set */ +#define CFE_MSG_SUBSYS_MASK 0x01FF /**< \brief CCSDS Subsystem mask */ + +/****************************************************************************** + * CCSDS extended header initialization - See header file for details + */ +void CFE_MSG_SetDefaultCCSDSExt(CFE_MSG_Message_t *MsgPtr) +{ + + CFE_MSG_SetEDSVersion(MsgPtr, (CFE_MSG_EDSVersion_t)CFE_PLATFORM_EDSVER); + +#if (CFE_PLATFORM_ENDIAN == CCSDS_LITTLE_ENDIAN) + CFE_MSG_SetEndian(MsgPtr, CFE_MSG_Endian_Little); +#else + CFE_MSG_SetEndian(MsgPtr, CFE_MSG_Endian_Big); +#endif + + /* Default bits of the subsystem, for whatever isn't set by MsgId */ + CFE_MSG_SetSubsystem(MsgPtr, (CFE_MSG_Subsystem_t)CFE_PLATFORM_DEFAULT_SUBSYS); + CFE_MSG_SetSystem(MsgPtr, (CFE_MSG_System_t)CFE_MISSION_SPACECRAFT_ID); +} + +/****************************************************************************** + * Get message EDS version - See API and header file for details + */ +int32 CFE_MSG_GetEDSVersion(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_EDSVersion_t *Version) +{ + + if (MsgPtr == NULL || Version == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + CFE_MSG_GetHeaderField(MsgPtr->CCSDS.Ext.Subsystem, Version, CFE_MSG_EDSVER_MASK); + *Version >>= CFE_MSG_EDSVER_SHIFT; + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message EDS version - See API and header file for details + */ +int32 CFE_MSG_SetEDSVersion(CFE_MSG_Message_t *MsgPtr, CFE_MSG_EDSVersion_t Version) +{ + 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_SHIFT, CFE_MSG_EDSVER_MASK); + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Get message endian - See API and header file for details + */ +int32 CFE_MSG_GetEndian(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Endian_t *Endian) +{ + + if (MsgPtr == NULL || Endian == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + if ((MsgPtr->CCSDS.Ext.Subsystem[0] & (CFE_MSG_ENDIAN_MASK >> 8)) != 0) + { + *Endian = CFE_MSG_Endian_Little; + } + else + { + *Endian = CFE_MSG_Endian_Big; + } + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message endian - See API and header file for details + */ +int32 CFE_MSG_SetEndian(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Endian_t Endian) +{ + int32 status = CFE_SUCCESS; + + if (MsgPtr == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + if (Endian == CFE_MSG_Endian_Little) + { + MsgPtr->CCSDS.Ext.Subsystem[0] |= CFE_MSG_ENDIAN_MASK >> 8; + } + else if (Endian == CFE_MSG_Endian_Big) + { + MsgPtr->CCSDS.Ext.Subsystem[0] &= ~(CFE_MSG_ENDIAN_MASK >> 8); + } + else + { + status = CFE_MSG_BAD_ARGUMENT; + } + + return status; +} + +/****************************************************************************** + * Get message playback flag - See API and header file for details + */ +int32 CFE_MSG_GetPlaybackFlag(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_PlaybackFlag_t *PlayFlag) +{ + + if (MsgPtr == NULL || PlayFlag == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + if ((MsgPtr->CCSDS.Ext.Subsystem[0] & (CFE_MSG_PLAYBACK_MASK >> 8)) != 0) + { + *PlayFlag = CFE_MSG_PlayFlag_Playback; + } + else + { + *PlayFlag = CFE_MSG_PlayFlag_Original; + } + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message playback flag - See API and header file for details + */ +int32 CFE_MSG_SetPlaybackFlag(CFE_MSG_Message_t *MsgPtr, CFE_MSG_PlaybackFlag_t PlayFlag) +{ + int32 status = CFE_SUCCESS; + + if (MsgPtr == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + if (PlayFlag == CFE_MSG_PlayFlag_Playback) + { + MsgPtr->CCSDS.Ext.Subsystem[0] |= CFE_MSG_PLAYBACK_MASK >> 8; + } + else if (PlayFlag == CFE_MSG_PlayFlag_Original) + { + MsgPtr->CCSDS.Ext.Subsystem[0] &= ~(CFE_MSG_PLAYBACK_MASK >> 8); + } + else + { + status = CFE_MSG_BAD_ARGUMENT; + } + + return status; +} + +/****************************************************************************** + * Get message subsystem - See API and header file for details + */ +int32 CFE_MSG_GetSubsystem(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Subsystem_t *Subsystem) +{ + + if (MsgPtr == NULL || Subsystem == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + CFE_MSG_GetHeaderField(MsgPtr->CCSDS.Ext.Subsystem, Subsystem, CFE_MSG_SUBSYS_MASK); + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message subsystem - See API and header file for details + */ +int32 CFE_MSG_SetSubsystem(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Subsystem_t Subsystem) +{ + if (MsgPtr == NULL || ((Subsystem & ~CFE_MSG_SUBSYS_MASK) != 0)) + { + return CFE_MSG_BAD_ARGUMENT; + } + + CFE_MSG_SetHeaderField(MsgPtr->CCSDS.Ext.Subsystem, Subsystem, CFE_MSG_SUBSYS_MASK); + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Get message system - See API and header file for details + */ +int32 CFE_MSG_GetSystem(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_System_t *System) +{ + + if (MsgPtr == NULL || System == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + *System = (MsgPtr->CCSDS.Ext.SystemId[0] << 8) + MsgPtr->CCSDS.Ext.SystemId[1]; + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message system - See API and header file for details + */ +int32 CFE_MSG_SetSystem(CFE_MSG_Message_t *MsgPtr, CFE_MSG_System_t System) +{ + if (MsgPtr == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + MsgPtr->CCSDS.Ext.SystemId[0] = (System >> 8) & 0xFF; + MsgPtr->CCSDS.Ext.SystemId[1] = System & 0xFF; + + return CFE_SUCCESS; +} diff --git a/modules/msg/src/cfe_msg_ccsdspri.c b/modules/msg/src/cfe_msg_ccsdspri.c new file mode 100644 index 000000000..b7d73679d --- /dev/null +++ b/modules/msg/src/cfe_msg_ccsdspri.c @@ -0,0 +1,352 @@ +/* +** 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 CCSDS Primary header implementations + */ +#include "cfe_msg_api.h" +#include "cfe_msg_priv.h" +#include "cfe_msg_defaults.h" +#include "cfe_error.h" + +/* CCSDS Primary Standard definitions */ +#define CFE_MSG_SIZE_OFFSET 7 /**< \brief CCSDS size offset */ +#define CFE_MSG_CCSDSVER_MASK 0xE000 /**< \brief CCSDS version mask */ +#define CFE_MSG_CCSDSVER_SHIFT 13 /**< \brief CCSDS version shift */ +#define CFE_MSG_TYPE_MASK 0x1000 /**< \brief CCSDS type mask, command when set */ +#define CFE_MSG_SHDR_MASK 0x0800 /**< \brief CCSDS secondary header mask, exists when set*/ +#define CFE_MSG_APID_MASK 0x07FF /**< \brief CCSDS ApID mask */ +#define CFE_MSG_SEGFLG_MASK 0xC000 /**< \brief CCSDS segmentation flag mask, all set = complete packet */ +#define CFE_MSG_SEGFLG_CNT 0x0000 /**< \brief CCSDS Segment continuation flag */ +#define CFE_MSG_SEGFLG_FIRST 0x4000 /**< \brief CCSDS Segment first flag */ +#define CFE_MSG_SEGFLG_LAST 0x8000 /**< \brief CCSDS Segment last flag */ +#define CFE_MSG_SEGFLG_UNSEG 0xC000 /**< \brief CCSDS Unsegmented flag */ +#define CFE_MSG_SEQCNT_MASK 0x3FFF /**< \brief CCSDS Sequence count mask */ + +/****************************************************************************** + * CCSDS Primary header initialization - See header file for details + */ +void CFE_MSG_SetDefaultCCSDSPri(CFE_MSG_Message_t *MsgPtr) +{ + + /* cFS standard is for secondary header to be present */ + CFE_MSG_SetHasSecondaryHeader(MsgPtr, true); + + /* cFS standard for CCSDS Version is Ver 1 = 0, Ver 2 = 1, but mission may redefine */ + CFE_MSG_SetHeaderVersion(MsgPtr, CFE_MISSION_CCSDSVER); + + /* Default bits of the APID, for whatever isn't set by MsgId */ + CFE_MSG_SetApId(MsgPtr, CFE_PLATFORM_DEFAULT_APID); + + /* Default to complete packets */ + CFE_MSG_SetSegmentationFlag(MsgPtr, CFE_MSG_SegFlag_Unsegmented); +} + +/****************************************************************************** + * Get message header version - See API and header file for details + */ +int32 CFE_MSG_GetHeaderVersion(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_HeaderVersion_t *Version) +{ + + if (MsgPtr == NULL || Version == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + CFE_MSG_GetHeaderField(MsgPtr->CCSDS.Pri.StreamId, Version, CFE_MSG_CCSDSVER_MASK); + *Version >>= CFE_MSG_CCSDSVER_SHIFT; + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message header version - See API and header file for details + */ +int32 CFE_MSG_SetHeaderVersion(CFE_MSG_Message_t *MsgPtr, CFE_MSG_HeaderVersion_t Version) +{ + 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_SHIFT, CFE_MSG_CCSDSVER_MASK); + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Get message type - See API and header file for details + */ +int32 CFE_MSG_GetType(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Type_t *Type) +{ + + if (MsgPtr == NULL || Type == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + if ((MsgPtr->CCSDS.Pri.StreamId[0] & (CFE_MSG_TYPE_MASK >> 8)) != 0) + { + *Type = CFE_MSG_Type_Cmd; + } + else + { + *Type = CFE_MSG_Type_Tlm; + } + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message type - See API and header file for details + */ +int32 CFE_MSG_SetType(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Type_t Type) +{ + int32 status = CFE_SUCCESS; + + if (MsgPtr == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + if (Type == CFE_MSG_Type_Cmd) + { + MsgPtr->CCSDS.Pri.StreamId[0] |= CFE_MSG_TYPE_MASK >> 8; + } + else if (Type == CFE_MSG_Type_Tlm) + { + MsgPtr->CCSDS.Pri.StreamId[0] &= ~(CFE_MSG_TYPE_MASK >> 8); + } + else + { + status = CFE_MSG_BAD_ARGUMENT; + } + + return status; +} + +/****************************************************************************** + * Get message has secondary header flag - See API and header file for details + */ +int32 CFE_MSG_GetHasSecondaryHeader(const CFE_MSG_Message_t *MsgPtr, bool *HasSecondary) +{ + + if (MsgPtr == NULL || HasSecondary == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + *HasSecondary = (MsgPtr->CCSDS.Pri.StreamId[0] & (CFE_MSG_SHDR_MASK >> 8)) != 0; + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message has secondary header flag - See API and header file for details + */ +int32 CFE_MSG_SetHasSecondaryHeader(CFE_MSG_Message_t *MsgPtr, bool HasSecondary) +{ + if (MsgPtr == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + if (HasSecondary) + { + MsgPtr->CCSDS.Pri.StreamId[0] |= CFE_MSG_SHDR_MASK >> 8; + } + else + { + MsgPtr->CCSDS.Pri.StreamId[0] &= ~(CFE_MSG_SHDR_MASK >> 8); + } + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Get message application ID - See API and header file for details + */ +int32 CFE_MSG_GetApId(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_ApId_t *ApId) +{ + + if (MsgPtr == NULL || ApId == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + CFE_MSG_GetHeaderField(MsgPtr->CCSDS.Pri.StreamId, ApId, CFE_MSG_APID_MASK); + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message application ID - See API and header file for details + */ +int32 CFE_MSG_SetApId(CFE_MSG_Message_t *MsgPtr, CFE_MSG_ApId_t ApId) +{ + if (MsgPtr == NULL || ((ApId & ~CFE_MSG_APID_MASK) != 0)) + { + return CFE_MSG_BAD_ARGUMENT; + } + + CFE_MSG_SetHeaderField(MsgPtr->CCSDS.Pri.StreamId, ApId, CFE_MSG_APID_MASK); + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Get message segmentation flag - See API and header file for details + */ +int32 CFE_MSG_GetSegmentationFlag(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_SegmentationFlag_t *SegFlag) +{ + + uint16 rawval; + + if (MsgPtr == NULL || SegFlag == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + CFE_MSG_GetHeaderField(MsgPtr->CCSDS.Pri.Sequence, &rawval, CFE_MSG_SEGFLG_MASK); + + switch (rawval) + { + case CFE_MSG_SEGFLG_CNT: + *SegFlag = CFE_MSG_SegFlag_Continue; + break; + case CFE_MSG_SEGFLG_FIRST: + *SegFlag = CFE_MSG_SegFlag_First; + break; + case CFE_MSG_SEGFLG_LAST: + *SegFlag = CFE_MSG_SegFlag_Last; + break; + case CFE_MSG_SEGFLG_UNSEG: + default: + *SegFlag = CFE_MSG_SegFlag_Unsegmented; + } + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message segmentation flag - See API and header file for details + */ +int32 CFE_MSG_SetSegmentationFlag(CFE_MSG_Message_t *MsgPtr, CFE_MSG_SegmentationFlag_t SegFlag) +{ + uint16 rawval = 0; + int32 status = CFE_SUCCESS; + + if (MsgPtr == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + switch (SegFlag) + { + case CFE_MSG_SegFlag_Continue: + rawval = CFE_MSG_SEGFLG_CNT; + break; + case CFE_MSG_SegFlag_First: + rawval = CFE_MSG_SEGFLG_FIRST; + break; + case CFE_MSG_SegFlag_Last: + rawval = CFE_MSG_SEGFLG_LAST; + break; + case CFE_MSG_SegFlag_Unsegmented: + rawval = CFE_MSG_SEGFLG_UNSEG; + break; + case CFE_MSG_SegFlag_Invalid: + default: + status = CFE_MSG_BAD_ARGUMENT; + } + + if (status == CFE_SUCCESS) + { + CFE_MSG_SetHeaderField(MsgPtr->CCSDS.Pri.Sequence, rawval, CFE_MSG_SEGFLG_MASK); + } + + return status; +} + +/****************************************************************************** + * Get message sequence count - See API and header file for details + */ +int32 CFE_MSG_GetSequenceCount(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_SequenceCount_t *SeqCnt) +{ + + if (MsgPtr == NULL || SeqCnt == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + CFE_MSG_GetHeaderField(MsgPtr->CCSDS.Pri.Sequence, SeqCnt, CFE_MSG_SEQCNT_MASK); + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message sequence count - See API and header file for details + */ +int32 CFE_MSG_SetSequenceCount(CFE_MSG_Message_t *MsgPtr, CFE_MSG_SequenceCount_t SeqCnt) +{ + if (MsgPtr == NULL || ((SeqCnt & ~CFE_MSG_SEQCNT_MASK) != 0)) + { + return CFE_MSG_BAD_ARGUMENT; + } + + CFE_MSG_SetHeaderField(MsgPtr->CCSDS.Pri.Sequence, SeqCnt, CFE_MSG_SEQCNT_MASK); + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Get message size - See API and header file for details + */ +int32 CFE_MSG_GetSize(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Size_t *Size) +{ + + if (MsgPtr == NULL || Size == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + *Size = (MsgPtr->CCSDS.Pri.Length[0] << 8) + MsgPtr->CCSDS.Pri.Length[1] + CFE_MSG_SIZE_OFFSET; + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message size - See API and header file for details + */ +int32 CFE_MSG_SetSize(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Size_t Size) +{ + if (MsgPtr == NULL || Size < CFE_MSG_SIZE_OFFSET || Size > (0xFFFF + CFE_MSG_SIZE_OFFSET)) + { + return CFE_MSG_BAD_ARGUMENT; + } + + /* Size is CCSDS header is total packet size - CFE_MSG_SIZE_OFFSET (7) */ + Size -= CFE_MSG_SIZE_OFFSET; + + MsgPtr->CCSDS.Pri.Length[0] = (Size >> 8) & 0xFF; + MsgPtr->CCSDS.Pri.Length[1] = Size & 0xFF; + + return CFE_SUCCESS; +} diff --git a/modules/msg/src/cfe_msg_init.c b/modules/msg/src/cfe_msg_init.c new file mode 100644 index 000000000..b64e2d0f6 --- /dev/null +++ b/modules/msg/src/cfe_msg_init.c @@ -0,0 +1,57 @@ +/* +** 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 initialization + */ +#include "cfe_msg_api.h" +#include "cfe_msg_priv.h" +#include "cfe_msg_defaults.h" +#include "string.h" + +/****************************************************************************** + * Top level message initialization - See API and header file for details + */ +int32 CFE_MSG_Init(CFE_MSG_Message_t *MsgPtr, CFE_SB_MsgId_t MsgId, CFE_MSG_Size_t Size, bool Clear) +{ + + int32 status; + + if (MsgPtr == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + /* Clear and set defaults if request */ + if (Clear) + { + memset(MsgPtr, 0, Size); + CFE_MSG_InitDefaultHdr(MsgPtr); + } + + /* Set values input */ + status = CFE_MSG_SetMsgId(MsgPtr, MsgId); + if (status == CFE_SUCCESS) + { + status = CFE_MSG_SetSize(MsgPtr, Size); + } + + return status; +} diff --git a/modules/msg/src/cfe_msg_initdefaulthdr_pri.c b/modules/msg/src/cfe_msg_initdefaulthdr_pri.c new file mode 100644 index 000000000..2904ab1ef --- /dev/null +++ b/modules/msg/src/cfe_msg_initdefaulthdr_pri.c @@ -0,0 +1,34 @@ +/* +** 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 default header initialization - implementation without CCSDS + * extended header + */ +#include "cfe_msg_hdr.h" +#include "cfe_msg_defaults.h" + +/****************************************************************************** + * Top level message initialization - See header file for details + */ +void CFE_MSG_InitDefaultHdr(CFE_MSG_Message_t *MsgPtr) +{ + CFE_MSG_SetDefaultCCSDSPri(MsgPtr); +} diff --git a/modules/msg/src/cfe_msg_initdefaulthdr_priext.c b/modules/msg/src/cfe_msg_initdefaulthdr_priext.c new file mode 100644 index 000000000..c11f15347 --- /dev/null +++ b/modules/msg/src/cfe_msg_initdefaulthdr_priext.c @@ -0,0 +1,35 @@ +/* +** 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 default header initialization - implementation without CCSDS + * extended header + */ +#include "cfe_msg_hdr.h" +#include "cfe_msg_defaults.h" + +/****************************************************************************** + * Top level message initialization - See header file for details + */ +void CFE_MSG_InitDefaultHdr(CFE_MSG_Message_t *MsgPtr) +{ + CFE_MSG_SetDefaultCCSDSPri(MsgPtr); + CFE_MSG_SetDefaultCCSDSExt(MsgPtr); +} diff --git a/modules/msg/src/cfe_msg_msgid_shared.c b/modules/msg/src/cfe_msg_msgid_shared.c new file mode 100644 index 000000000..79caaac7f --- /dev/null +++ b/modules/msg/src/cfe_msg_msgid_shared.c @@ -0,0 +1,46 @@ +/* +** 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 access functions, shared cFS implementation + */ +#include "cfe_msg_api.h" +#include "cfe_msg_priv.h" +#include "cfe_error.h" + +/****************************************************************************** + * Get type from message id - See API and header file for details + * cFS default implementation + */ +int32 CFE_MSG_GetTypeFromMsgId(CFE_SB_MsgId_t MsgId, CFE_MSG_Type_t *Type) +{ + + CFE_MSG_Message_t msg; + + if (Type == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + CFE_MSG_SetMsgId(&msg, MsgId); + CFE_MSG_GetType(&msg, Type); + + return CFE_SUCCESS; +} diff --git a/modules/msg/src/cfe_msg_msgid_v1.c b/modules/msg/src/cfe_msg_msgid_v1.c new file mode 100644 index 000000000..8b79ec3d3 --- /dev/null +++ b/modules/msg/src/cfe_msg_msgid_v1.c @@ -0,0 +1,71 @@ +/* +** 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 access functions, cFS version 1 implementation + */ +#include "cfe_msg_api.h" +#include "cfe_msg_priv.h" +#include "cfe_error.h" +#include "cfe_platform_cfg.h" + +/****************************************************************************** + * Get message id - See API and header file for details + * cFS default version 1 implementation using CCSDS headers + * + * Message Id = CCSDS Stream ID (in local endian) + */ +int32 CFE_MSG_GetMsgId(const CFE_MSG_Message_t *MsgPtr, CFE_SB_MsgId_t *MsgId) +{ + + CFE_SB_MsgId_Atom_t msgidval; + + if (MsgPtr == NULL || MsgId == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + msgidval = (MsgPtr->CCSDS.Pri.StreamId[0] << 8) + MsgPtr->CCSDS.Pri.StreamId[1]; + *MsgId = CFE_SB_ValueToMsgId(msgidval); + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message id - See API and header file for details + * cFS default version 1 implementations using CCSDS headers + * + * CCSDS Stream ID = Message Id converted to big endian + */ +int32 CFE_MSG_SetMsgId(CFE_MSG_Message_t *MsgPtr, CFE_SB_MsgId_t MsgId) +{ + + CFE_SB_MsgId_Atom_t msgidval = CFE_SB_MsgIdToValue(MsgId); + + if (MsgPtr == NULL || msgidval > CFE_PLATFORM_SB_HIGHEST_VALID_MSGID) + { + return CFE_MSG_BAD_ARGUMENT; + } + + MsgPtr->CCSDS.Pri.StreamId[0] = (uint8)(msgidval >> 8); + MsgPtr->CCSDS.Pri.StreamId[1] = (uint8)(msgidval); + + return CFE_SUCCESS; +} diff --git a/modules/msg/src/cfe_msg_msgid_v2.c b/modules/msg/src/cfe_msg_msgid_v2.c new file mode 100644 index 000000000..6845f9755 --- /dev/null +++ b/modules/msg/src/cfe_msg_msgid_v2.c @@ -0,0 +1,111 @@ +/* +** 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 access functions + * + * cFS default version 2 implementation using CCSDS headers + * + * Message Id: + * 7 bits from the primary header APID (0x7F of 0x7FF) + * 1 bit for the command/telemetry flag + * 0 bits from the Playback flag + * 8 bits from the secondary header APID qualifier (Subsystem) (0xFF of 0x01FF) + * 0 bits from the secondary header APID qualifier as the System + * = 16 bits total + * + * Byte 1 Byte 0 + * 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 + * +-+-+-+-+-+-+-+-+|--------|+-+-+-+-+-+-+-+ + * | APID Qualifier |C/T flg | Pri Hdr APID | + * +-+-+-+-+-+-+-+-+|--------|+-+-+-+-+-+-+-+ + */ +#include "cfe_msg_api.h" +#include "cfe_msg_priv.h" +#include "cfe_error.h" +#include "cfe_platform_cfg.h" + +/* cFS MsgId definitions */ +#define CFE_MSG_MSGID_APID_MASK 0x007F /**< \brief CCSDS ApId mask for MsgId */ +#define CFE_MSG_MSGID_TYPE_MASK 0x0080 /**< \brief Message type mask for MsgId, set = cmd */ +#define CFE_MSG_MSGID_SUBSYS_MASK 0xFF00 /**< \brief Subsystem mask for MsgId */ + +/****************************************************************************** + * Get message id - See API and header file for details + */ +int32 CFE_MSG_GetMsgId(const CFE_MSG_Message_t *MsgPtr, CFE_SB_MsgId_t *MsgId) +{ + + CFE_SB_MsgId_Atom_t msgidval; + CFE_MSG_Type_t type; + + if (MsgPtr == NULL || MsgId == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + /* Ignore return, assumes tlm if invalid */ + CFE_MSG_GetType(MsgPtr, &type); + + /* Set message ID bits from CCSDS header fields */ + msgidval = MsgPtr->CCSDS.Pri.StreamId[1] & CFE_MSG_MSGID_APID_MASK; + if (type == CFE_MSG_Type_Cmd) + { + msgidval |= CFE_MSG_MSGID_TYPE_MASK; + } + msgidval |= (MsgPtr->CCSDS.Ext.Subsystem[1] << 8) & CFE_MSG_MSGID_SUBSYS_MASK; + + *MsgId = CFE_SB_ValueToMsgId(msgidval); + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set message id - See API and header file for details + */ +int32 CFE_MSG_SetMsgId(CFE_MSG_Message_t *MsgPtr, CFE_SB_MsgId_t MsgId) +{ + + CFE_SB_MsgId_Atom_t msgidval = CFE_SB_MsgIdToValue(MsgId); + + if (MsgPtr == NULL || msgidval > CFE_PLATFORM_SB_HIGHEST_VALID_MSGID) + { + return CFE_MSG_BAD_ARGUMENT; + } + + /* Clear and set PID_MSGID_MASK bits */ + MsgPtr->CCSDS.Pri.StreamId[1] = + (MsgPtr->CCSDS.Pri.StreamId[1] & ~CFE_MSG_MSGID_APID_MASK) | (msgidval & CFE_MSG_MSGID_APID_MASK); + + /* Set APIDQ Subsystem bits */ + MsgPtr->CCSDS.Ext.Subsystem[1] = ((msgidval & CFE_MSG_MSGID_SUBSYS_MASK) >> 8); + + /* Set type, ignores return since no failure action */ + if ((msgidval & CFE_MSG_MSGID_TYPE_MASK) != 0) + { + CFE_MSG_SetType(MsgPtr, CFE_MSG_Type_Cmd); + } + else + { + CFE_MSG_SetType(MsgPtr, CFE_MSG_Type_Tlm); + } + + return CFE_SUCCESS; +} diff --git a/modules/msg/src/cfe_msg_sechdr_checksum.c b/modules/msg/src/cfe_msg_sechdr_checksum.c new file mode 100644 index 000000000..aa645c864 --- /dev/null +++ b/modules/msg/src/cfe_msg_sechdr_checksum.c @@ -0,0 +1,116 @@ +/* +** 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. +*/ + +/****************************************************************************** + * Checksum field access functions + */ +#include "cfe_msg_api.h" +#include "cfe_msg_priv.h" + +/******************************************************************************/ +/** + * \brief Compute checksum - internal utility + * + * \param[in] MsgPtr Message pointer to checksum + * + * \return Calculated checksum + */ +CFE_MSG_Checksum_t CFE_MSG_ComputeCheckSum(const CFE_MSG_Message_t *MsgPtr) +{ + + uint32 PktLen = 0; + const uint8 * BytePtr = MsgPtr->Byte; + CFE_MSG_Checksum_t chksum = 0xFF; + + /* Message already checked, no error case reachable */ + CFE_MSG_GetSize(MsgPtr, &PktLen); + + while (PktLen--) + { + chksum ^= *(BytePtr++); + } + + return chksum; +} + +/****************************************************************************** + * Calculate and set checksum field - See API and header file for details + * Implementation supports cFS secondary definition or no secodary header + */ +int32 CFE_MSG_GenerateChecksum(CFE_MSG_Message_t *MsgPtr) +{ + uint32 status; + CFE_MSG_Type_t type; + bool hassechdr = false; + CFE_MSG_CommandHeader_t *cmd = (CFE_MSG_CommandHeader_t *)MsgPtr; + + if (MsgPtr == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + /* Ignore return, pointer already checked */ + CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassechdr); + + status = CFE_MSG_GetType(MsgPtr, &type); + if (status != CFE_SUCCESS || type != CFE_MSG_Type_Cmd || !hassechdr) + { + return CFE_MSG_WRONG_MSG_TYPE; + } + + /* Zero checksum so new checksum will be correct */ + cmd->Sec.Checksum = 0; + + /* Compute and set */ + cmd->Sec.Checksum = CFE_MSG_ComputeCheckSum((CFE_MSG_Message_t *)cmd); + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Validate checksum - See API and header file for details + * Implementation supports cFS secondary definition or no secondary header + */ +int32 CFE_MSG_ValidateChecksum(const CFE_MSG_Message_t *MsgPtr, bool *IsValid) +{ + + uint32 status; + CFE_MSG_Type_t type; + bool hassechdr = false; + + if (MsgPtr == NULL || IsValid == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + /* Ignore return, pointer already checked */ + CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassechdr); + + status = CFE_MSG_GetType(MsgPtr, &type); + if (status != CFE_SUCCESS || type != CFE_MSG_Type_Cmd || !hassechdr) + { + return CFE_MSG_WRONG_MSG_TYPE; + } + + /* Compute, valid if == 0 */ + *IsValid = (CFE_MSG_ComputeCheckSum(MsgPtr) == 0); + + return CFE_SUCCESS; +} diff --git a/modules/msg/src/cfe_msg_sechdr_fc.c b/modules/msg/src/cfe_msg_sechdr_fc.c new file mode 100644 index 000000000..aa1c5abc9 --- /dev/null +++ b/modules/msg/src/cfe_msg_sechdr_fc.c @@ -0,0 +1,88 @@ +/* +** 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. +*/ + +/****************************************************************************** + * Function code field access functions + */ +#include "cfe_msg_api.h" +#include "cfe_msg_priv.h" + +#define CFE_MSG_FC_MASK 0x7F /**< \brief Function code mask */ + +/****************************************************************************** + * Get function code - See API and header file for details + * cFS default secondary header implementation + */ +int32 CFE_MSG_GetFcnCode(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_FcnCode_t *FcnCode) +{ + uint32 status; + CFE_MSG_Type_t type; + bool hassechdr = false; + CFE_MSG_CommandHeader_t *cmd = (CFE_MSG_CommandHeader_t *)MsgPtr; + + if (MsgPtr == NULL || FcnCode == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + /* Ignore return, pointer already checked */ + CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassechdr); + + status = CFE_MSG_GetType(MsgPtr, &type); + if (status != CFE_SUCCESS || type != CFE_MSG_Type_Cmd || !hassechdr) + { + *FcnCode = 0; + return CFE_MSG_WRONG_MSG_TYPE; + } + + *FcnCode = cmd->Sec.FunctionCode & CFE_MSG_FC_MASK; + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Set function code - See API and header file for details + * cFS default secondary header implementation + */ +int32 CFE_MSG_SetFcnCode(CFE_MSG_Message_t *MsgPtr, CFE_MSG_FcnCode_t FcnCode) +{ + uint32 status; + CFE_MSG_Type_t type; + bool hassechdr = false; + CFE_MSG_CommandHeader_t *cmd = (CFE_MSG_CommandHeader_t *)MsgPtr; + + if (MsgPtr == NULL || (FcnCode > CFE_MSG_FC_MASK)) + { + return CFE_MSG_BAD_ARGUMENT; + } + + /* Ignore return, pointer already checked */ + CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassechdr); + + status = CFE_MSG_GetType(MsgPtr, &type); + if (status != CFE_SUCCESS || type != CFE_MSG_Type_Cmd || !hassechdr) + { + return CFE_MSG_WRONG_MSG_TYPE; + } + + cmd->Sec.FunctionCode = FcnCode; + + return CFE_SUCCESS; +} diff --git a/modules/msg/src/cfe_msg_sechdr_time.c b/modules/msg/src/cfe_msg_sechdr_time.c new file mode 100644 index 000000000..71d8d7a84 --- /dev/null +++ b/modules/msg/src/cfe_msg_sechdr_time.c @@ -0,0 +1,97 @@ +/* +** 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. +*/ + +/****************************************************************************** + * Time field access functions - cFS default 32 bit seconds, 16 bit subseconds + * in big endian format + */ +#include "cfe_msg_api.h" +#include "cfe_msg_priv.h" +#include "cfe_error.h" +#include + +/****************************************************************************** + * Set message time - See API and header file for details + */ +int32 CFE_MSG_SetMsgTime(CFE_MSG_Message_t *MsgPtr, CFE_TIME_SysTime_t NewTime) +{ + + uint32 status; + CFE_MSG_Type_t type; + bool hassechdr = false; + CFE_MSG_TelemetryHeader_t *tlm = (CFE_MSG_TelemetryHeader_t *)MsgPtr; + + if (MsgPtr == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + /* Ignore return, pointer already checked */ + CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassechdr); + + status = CFE_MSG_GetType(MsgPtr, &type); + if (status != CFE_SUCCESS || type != CFE_MSG_Type_Tlm || !hassechdr) + { + return CFE_MSG_WRONG_MSG_TYPE; + } + + /* Set big endian time field with default 32/16 layout */ + tlm->Sec.Time[0] = (NewTime.Seconds >> 24) & 0xFF; + tlm->Sec.Time[1] = (NewTime.Seconds >> 16) & 0xFF; + tlm->Sec.Time[2] = (NewTime.Seconds >> 8) & 0xFF; + tlm->Sec.Time[3] = NewTime.Seconds & 0xFF; + tlm->Sec.Time[4] = (NewTime.Subseconds >> 24) & 0xFF; + tlm->Sec.Time[5] = (NewTime.Subseconds >> 16) & 0xFF; + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Get message time - See API and header file for details + */ +int32 CFE_MSG_GetMsgTime(const CFE_MSG_Message_t *MsgPtr, CFE_TIME_SysTime_t *Time) +{ + + uint32 status; + CFE_MSG_Type_t type; + bool hassechdr = false; + CFE_MSG_TelemetryHeader_t *tlm = (CFE_MSG_TelemetryHeader_t *)MsgPtr; + + if (MsgPtr == NULL || Time == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + /* Ignore return, pointer already checked */ + CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassechdr); + + status = CFE_MSG_GetType(MsgPtr, &type); + if (status != CFE_SUCCESS || type != CFE_MSG_Type_Tlm || !hassechdr) + { + memset(Time, 0, sizeof(*Time)); + return CFE_MSG_WRONG_MSG_TYPE; + } + + /* Get big endian time fields with default 32/16 layout */ + Time->Subseconds = (tlm->Sec.Time[4] << 24) + (tlm->Sec.Time[5] << 16); + Time->Seconds = (tlm->Sec.Time[0] << 24) + (tlm->Sec.Time[1] << 16) + (tlm->Sec.Time[2] << 8) + tlm->Sec.Time[3]; + + return CFE_SUCCESS; +} diff --git a/modules/msg/src/cfe_msg_sechdr_time_old.c b/modules/msg/src/cfe_msg_sechdr_time_old.c new file mode 100644 index 000000000..7b1a5b16b --- /dev/null +++ b/modules/msg/src/cfe_msg_sechdr_time_old.c @@ -0,0 +1,137 @@ +/* +** 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. +*/ + +/****************************************************************************** + * Time field access functions + */ +#include "cfe_msg_api.h" +#include "cfe_msg_priv.h" +#include "cfe_error.h" +#include + +/****************************************************************************** + * Set message time - See API and header file for details + */ +int32 CFE_MSG_SetMsgTime(CFE_MSG_Message_t *MsgPtr, CFE_TIME_SysTime_t NewTime) +{ + + uint32 status; + CFE_MSG_Type_t type; + bool hassechdr = false; + CFE_MSG_TelemetryHeader_t *tlm = (CFE_MSG_TelemetryHeader_t *)MsgPtr; + +/* declare format specific vars */ +#if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) + uint16 LocalSubs16; +#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20) + uint32 LocalSubs32; +#endif + + if (MsgPtr == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + /* Ignore return, pointer already checked */ + CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassechdr); + + status = CFE_MSG_GetType(MsgPtr, &type); + if (status != CFE_SUCCESS || type != CFE_MSG_Type_Tlm || !hassechdr) + { + return CFE_MSG_WRONG_MSG_TYPE; + } + + memcpy(&tlm->Sec.Time[0], &NewTime.Seconds, 4); + +#if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) + + /* convert time from CFE_TIME_SysTime_t format to packet format */ + LocalSubs16 = (uint16)(NewTime.Subseconds >> 16); + memcpy(&tlm->Sec.Time[4], &LocalSubs16, 2); + +#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_SUBS) + + /* no conversion necessary -- packet format = CFE_TIME_SysTime_t format */ + memcpy(&tlm->Sec.Time[4], &NewTime.Subseconds, 4); + +#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20) + + /* convert time from CFE_TIME_SysTime_t format to packet format */ + LocalSubs32 = CFE_TIME_Sub2MicroSecs(NewTime.Subseconds) << 12; + memcpy(&tlm->Sec.Time[4], &LocalSubs32, 4); + +#endif + + return CFE_SUCCESS; +} + +/****************************************************************************** + * Get message time - See API and header file for details + */ +int32 CFE_MSG_GetMsgTime(const CFE_MSG_Message_t *MsgPtr, CFE_TIME_SysTime_t *Time) +{ + + uint32 status; + CFE_MSG_Type_t type; + bool hassechdr = false; + CFE_MSG_TelemetryHeader_t *tlm = (CFE_MSG_TelemetryHeader_t *)MsgPtr; + +#if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) + uint16 LocalSubs16; +#endif + + if (MsgPtr == NULL || Time == NULL) + { + return CFE_MSG_BAD_ARGUMENT; + } + + /* Ignore return, pointer already checked */ + CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassechdr); + + status = CFE_MSG_GetType(MsgPtr, &type); + if (status != CFE_SUCCESS || type != CFE_MSG_Type_Tlm || !hassechdr) + { + memset(Time, 0, sizeof(*Time)); + return CFE_MSG_WRONG_MSG_TYPE; + } + + memcpy(&Time->Seconds, &tlm->Sec.Time[0], 4); + +#if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) + + memcpy(&LocalSubs16, &tlm->Sec.Time[4], 2); + /* convert packet data into CFE_TIME_SysTime_t format */ + Time->Subseconds = ((uint32)LocalSubs16) << 16; + +#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_SUBS) + + memcpy(&Time->Subseconds, &tlm->Sec.Time[4], 4); + /* no conversion necessary -- packet format = CFE_TIME_SysTime_t format */ + +#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20) + + memcpy(&LocalSubs32, &tlm->Sec.Time[4], 4); + /* convert packet data into CFE_TIME_SysTime_t format */ + Time->Subseconds = CFE_TIME_Micro2SubSecs((LocalSubs32 >> 12)); + +#endif + + return CFE_SUCCESS; +} From 856367951848fdf00a3985144765edb6b13b0e61 Mon Sep 17 00:00:00 2001 From: Jacob Hageman Date: Fri, 14 Aug 2020 10:48:52 -0400 Subject: [PATCH 2/9] Fix #711, Update SB/CCSDS FSW for msg module - Fix #733: Validate checksum description update - Fix #597: Remove local endian SID macros - Updates SB to use msg module - General cleanup --- fsw/cfe-core/src/inc/ccsds.h | 505 ++--------------------- fsw/cfe-core/src/inc/ccsds_hdr.h | 89 ++++ fsw/cfe-core/src/inc/cfe.h | 2 + fsw/cfe-core/src/inc/cfe_sb.h | 24 +- fsw/cfe-core/src/sb/ccsds.c | 122 ------ fsw/cfe-core/src/sb/cfe_sb_msg_id_util.c | 93 +---- fsw/cfe-core/src/sb/cfe_sb_msg_id_util.h | 78 ---- fsw/cfe-core/src/sb/cfe_sb_priv.c | 5 +- fsw/cfe-core/src/sb/cfe_sb_task.c | 1 - fsw/cfe-core/src/sb/cfe_sb_util.c | 235 +++-------- 10 files changed, 193 insertions(+), 961 deletions(-) create mode 100644 fsw/cfe-core/src/inc/ccsds_hdr.h delete mode 100644 fsw/cfe-core/src/sb/ccsds.c delete mode 100644 fsw/cfe-core/src/sb/cfe_sb_msg_id_util.h diff --git a/fsw/cfe-core/src/inc/ccsds.h b/fsw/cfe-core/src/inc/ccsds.h index f86e550c1..04575866f 100644 --- a/fsw/cfe-core/src/inc/ccsds.h +++ b/fsw/cfe-core/src/inc/ccsds.h @@ -32,503 +32,44 @@ /* ** Include Files */ - #include "common_types.h" #include "cfe_mission_cfg.h" - - -/* Macro to convert 16/32 bit types from platform "endianness" to Big Endian */ -#ifdef SOFTWARE_BIG_BIT_ORDER - #define CFE_MAKE_BIG16(n) (n) - #define CFE_MAKE_BIG32(n) (n) -#else - #define CFE_MAKE_BIG16(n) ( (((n) << 8) & 0xFF00) | (((n) >> 8) & 0x00FF) ) - #define CFE_MAKE_BIG32(n) ( (((n) << 24) & 0xFF000000) | (((n) << 8) & 0x00FF0000) | (((n) >> 8) & 0x0000FF00) | (((n) >> 24) & 0x000000FF) ) -#endif - - -/* CCSDS_TIME_SIZE is specific to the selected CFE_SB time format */ -#if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) - /* 32 bits seconds + 16 bits subseconds */ - #define CCSDS_TIME_SIZE 6 -#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_SUBS) - /* 32 bits seconds + 32 bits subseconds */ - #define CCSDS_TIME_SIZE 8 -#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20) - /* 32 bits seconds + 20 bits microsecs + 12 bits reserved */ - #define CCSDS_TIME_SIZE 8 -#else - /* unknown format */ - #error unable to define CCSDS_TIME_SIZE! -#endif - - -/* -** Type Definitions -*/ - -/********************************************************************** -** Structure definitions for CCSDS headers. All items in the structure -** must be aligned on 16-bit words. Bitfields must be avoided since -** some compilers (such as gcc) force them into 32-bit alignment. -** -** CCSDS headers must always be in network byte order per the standard. -** MSB at the lowest address which is commonly refered to as "BIG Endian" -** -** CCSDS Space Packets can be version 1 or version 2. Version 2 has -** an additional 32 bits for APID Qualifier fields in the secondary -** header. The primary header is unchanged. -** -**********************************************************************/ - -/*----- CCSDS packet primary header. -----*/ - -typedef struct { - - uint8 StreamId[2]; /* packet identifier word (stream ID) */ - /* bits shift ------------ description ---------------- */ - /* 0x07FF 0 : application ID */ - /* 0x0800 11 : secondary header: 0 = absent, 1 = present */ - /* 0x1000 12 : packet type: 0 = TLM, 1 = CMD */ - /* 0xE000 13 : CCSDS version: 0 = ver 1, 1 = ver 2 */ - - uint8 Sequence[2]; /* packet sequence word */ - /* bits shift ------------ description ---------------- */ - /* 0x3FFF 0 : sequence count */ - /* 0xC000 14 : segmentation flags: 3 = complete packet */ - - uint8 Length[2]; /* packet length word */ - /* bits shift ------------ description ---------------- */ - /* 0xFFFF 0 : (total packet length) - 7 */ - -} CCSDS_PriHdr_t; - -/*----- CCSDS command secondary header. -----*/ - -typedef struct { - - uint8 FunctionCode; /* Command Function Code */ - /* bits shift ---------description-------- */ - /* 0x7F 0 Command function code */ - /* 0x80 7 Reserved */ - - uint8 Checksum; /* Command checksum (all bits, 0xFF) */ - -} CCSDS_CmdSecHdr_t; - -/*----- CCSDS telemetry secondary header. -----*/ - -typedef struct { - - uint8 Time[CCSDS_TIME_SIZE]; - -} CCSDS_TlmSecHdr_t; - -/*----- CCSDS Endian Flag in the APID Qualifier Field. -----*/ -#define CCSDS_BIG_ENDIAN 0 -#define CCSDS_LITTLE_ENDIAN 1 -#define CCSDS_ENDIAN_MASK 0x0400 - -/*------ CCSDS packet playback Flag in the APID Qualifier Field. -------*/ -/* This field denotes that this packet is a playback of a stored packet */ -#define CCSDS_NON_PLAYBACK_PKT 0 -#define CCSDS_PLAYBACK_PKT 1 -#define CCSDS_PLAYBACK_PKT_MASK 0x0200 - -/*------ CCSDS packet Electronic Data Sheet version in the APID Qualifier Field. -------*/ -/* This is the verion of the data sheet that defines the packet payload format and other */ -/* metadata like unit conversions */ -#define CCSDS_EDS_MASK 0xF800 - -/*----- CCSDS Secondary Header APID Qualifers ----*/ -typedef struct { - - uint8 APIDQSubsystem[2]; - - /* bits shift ------------ description ---------------- */ - /* 0x01FF 0 : Subsystem Id mission defined */ - /* 0x0200 9 : Playback flag 0 = original, 1 = playback */ - /* 0x0400 10 : Endian: Big = 0, Little (Intel) = 1 */ - /* 0xF800 11 : EDS Version for packet definition used */ - - uint8 APIDQSystemId[2]; - /* 0xFFFF 0 : System Id mission defined */ - -} CCSDS_APIDqualifiers_t; - -/** - * \brief CCSDS Primary with APID Qualifier Header Type Definition - */ -typedef struct{ - CCSDS_PriHdr_t Pri;/**< \brief CCSDS Primary Header #CCSDS_PriHdr_t */ - CCSDS_APIDqualifiers_t ApidQ;/**< \brief CCSDS APID Qualifier Secondary Header #CCSDS_APIDqualifiers_t */ -}CCSDS_APIDQHdr_t; - -typedef struct -{ - /* - * In Version 1 mode, the standard / non-APID qualified header is used for all packets - */ - CCSDS_PriHdr_t Hdr; /**< Complete "version 1" (standard) header */ - -#ifdef MESSAGE_FORMAT_IS_CCSDS_VER_2 - - /* - * In Version 2 mode, the extended / APID qualified header is used for all packets - */ - CCSDS_APIDqualifiers_t ApidQ;/**< \brief CCSDS APID Qualifier Secondary Header #CCSDS_APIDqualifiers_t */ -#endif /* MESSAGE_FORMAT_IS_CCSDS_VER_2 */ - -} CCSDS_SpacePacket_t; - - - - -/*----- Generic combined command header. -----*/ - -typedef struct -{ - CCSDS_SpacePacket_t SpacePacket; /**< \brief Standard Header on all packets */ - CCSDS_CmdSecHdr_t Sec; -} CCSDS_CommandPacket_t; - -/*----- Generic combined telemetry header. -----*/ - -typedef struct -{ - CCSDS_SpacePacket_t SpacePacket; /**< \brief Standard Header on all packets */ - CCSDS_TlmSecHdr_t Sec; -} CCSDS_TelemetryPacket_t; +#include "cfe_msg_hdr.h" /* * COMPATIBILITY TYPEDEFS: - * These types were defined by CFE 6.5 and below and applications may still use them. * These typdefs provide compatibility for existing code. These should be * removed in the next CFE release. */ #ifndef CFE_OMIT_DEPRECATED_6_6 -typedef CCSDS_CommandPacket_t CCSDS_CmdPkt_t; -typedef CCSDS_TelemetryPacket_t CCSDS_TlmPkt_t; +typedef CFE_MSG_CommandHeader_t CCSDS_CmdPkt_t; +typedef CFE_MSG_TelemetryHeader_t CCSDS_TlmPkt_t; #endif /* CFE_OMIT_DEPRECATED_6_6 */ -/* -** Macro Definitions -*/ - -/********************************************************************** -** Constant values. -**********************************************************************/ - -/* Value of packet type for a telemetry packet. */ -#define CCSDS_TLM 0 -/* Value of packet type for a command packet. */ -#define CCSDS_CMD 1 - -/* Value of secondary header flag if secondary header not present. */ -#define CCSDS_NO_SEC_HDR 0 -/* Value of secondary header flag if secondary header exists. */ -#define CCSDS_HAS_SEC_HDR 1 - -#define NUM_CCSDS_APIDS 2048 -#define NUM_CCSDS_PKT_TYPES 2 - - -/********************************************************************** -** Initial values for CCSDS header fields. -**********************************************************************/ +#ifndef CFE_OMIT_DEPRECATED_6_8 -/* Initial value of the sequence count. */ -#define CCSDS_INIT_SEQ 0 -/* Initial value of the sequence flags. */ -#define CCSDS_INIT_SEQFLG 3 -/* Initial value of the command function code. */ -#define CCSDS_INIT_FC 0 -/* Initial value of the command checksum. */ -#define CCSDS_INIT_CHECKSUM 0 - -/* Note: the stream ID and length are always explicitly set for a packet, -** so default values are not required. */ - - -/********************************************************************** -** Macros for reading and writing bit fields in a 16-bit integer. -** These are used to implement the read and write macros below. -**********************************************************************/ - -/* Read bits specified by 'mask' from 'word' and shift down by 'shift'. */ -#define CCSDS_RD_BITS(word,mask,shift) \ - (((word) & mask) >> shift) - -/* Shift 'value' up by 'shift' and write to those bits in 'word' that -** are specified by 'mask'. Other bits in 'word' are unchanged. */ -#define CCSDS_WR_BITS(word,mask,shift,value) \ - ((word) = (uint16)(((word) & ~mask) | (((value) & (mask >> shift)) << shift))) - - -/********************************************************************** -** Macros for reading and writing the fields in a CCSDS header. All -** of the macros are used in a similar way: -** -** CCSDS_RD_xxx(header) -- Read field xxx from header. -** CCSDS_WR_xxx(header,value) -- Write value to field xxx of header. -** -** Note that 'header' is a reference to the actual header structure, -** not to a pointer to the structure. If using a pointer, one must -** refer to the structure as *pointer. -** -** The CCSDS_WR_xxx macros may refer to 'header' more than once; thus -** the expression for 'header' must NOT contain any side effects. -**********************************************************************/ - -/* Read entire stream ID from primary header. */ -#define CCSDS_RD_SID(phdr) (((phdr).StreamId[0] << 8) + ((phdr).StreamId[1])) -/* Write entire stream ID to primary header. */ -#define CCSDS_WR_SID(phdr,value) ( ((phdr).StreamId[0] = (value >> 8) ) ,\ - ((phdr).StreamId[1] = (value & 0xff) ) ) - -/* Read application ID from primary header. */ -#define CCSDS_RD_APID(phdr) (CCSDS_RD_SID(phdr) & 0x07FF) -/* Write application ID to primary header. */ -#define CCSDS_WR_APID(phdr,value) ((((phdr).StreamId[0] = ((phdr).StreamId[0] & 0xF8) | ((value >> 8) & 0x07))) ,\ - (((phdr).StreamId[1] = ((value)) & 0xff)) ) - -/* Read secondary header flag from primary header. */ -#define CCSDS_RD_SHDR(phdr) (((phdr).StreamId[0] & 0x08) >> 3) -/* Write secondary header flag to primary header. */ -#define CCSDS_WR_SHDR(phdr,value) ((phdr).StreamId[0] = ((phdr).StreamId[0] & 0xf7) | ((value << 3) & 0x08)) - -/* Read packet type (0=TLM,1=CMD) from primary header. */ -#define CCSDS_RD_TYPE(phdr) (((phdr).StreamId[0] & 0x10) >> 4) -/* Write packet type (0=TLM,1=CMD) to primary header. */ -#define CCSDS_WR_TYPE(phdr,value) ((phdr).StreamId[0] = ((phdr).StreamId[0] & 0xEF) | ((value << 4) & 0x10)) - -/* Read CCSDS version from primary header. */ -#define CCSDS_RD_VERS(phdr) (((phdr).StreamId[0] & 0xE0) >> 5) -/* Write CCSDS version to primary header. */ -#define CCSDS_WR_VERS(phdr,value) ((phdr).StreamId[0] = ((phdr).StreamId[0] & 0x1F) | ((value << 5) & 0xE0)) - -/* Read sequence count from primary header. */ -#define CCSDS_RD_SEQ(phdr) ((((phdr).Sequence[0] & 0x3F) << 8) + ((phdr).Sequence[1])) -/* Write sequence count to primary header. */ -#define CCSDS_WR_SEQ(phdr,value) ((((phdr).Sequence[0] = ((phdr).Sequence[0] & 0xC0) | ((value >> 8) & 0x3f))) ,\ - (((phdr).Sequence[1] = ((value)) & 0xff)) ) - -/* Read sequence flags from primary header. */ -#define CCSDS_RD_SEQFLG(phdr) (((phdr).Sequence[0] & 0xC0) >> 6) -/* Write sequence flags to primary header. */ -#define CCSDS_WR_SEQFLG(phdr,value) ((phdr).Sequence[0] = ((phdr).Sequence[0] & 0x3F) | ((value << 6) & 0xC0) ) - -/* Read total packet length from primary header. */ -#define CCSDS_RD_LEN(phdr) ( ( (phdr).Length[0] << 8) + (phdr).Length[1] + 7) -/* Write total packet length to primary header. */ -#define CCSDS_WR_LEN(phdr,value) ((((phdr).Length[0] = ((value) - 7) >> 8)) ,\ - (((phdr).Length[1] = ((value) - 7) & 0xff)) ) - -/* Read function code from command secondary header. */ -#define CCSDS_RD_FC(shdr) CCSDS_RD_BITS((shdr).FunctionCode, 0x7F, 0) -/* Write function code to command secondary header. */ -#define CCSDS_WR_FC(shdr,value) CCSDS_WR_BITS((shdr).FunctionCode, 0x7F, 0, value) - -/* Read checksum from command secondary header. */ -#define CCSDS_RD_CHECKSUM(shdr) ((shdr).Checksum) -/* Write checksum to command secondary header. */ -#define CCSDS_WR_CHECKSUM(shdr,val) ((shdr).Checksum = (val)) - -/* Define additional APID Qualifier macros. */ - -/* These macros will convert between local endianness and network endianness */ -/* The packet headers are always in network byte order */ -#define CCSDS_RD_EDS_VER(shdr) ( ((shdr).APIDQSubsystem[0] & 0xF8) >> 3) -#define CCSDS_RD_ENDIAN(shdr) ( ((shdr).APIDQSubsystem[0] & 0x04) >> 2) -#define CCSDS_RD_PLAYBACK(shdr) ( ((shdr).APIDQSubsystem[0] & 0x02) >> 1) -#define CCSDS_RD_SUBSYSTEM_ID(shdr) ( (((shdr).APIDQSubsystem[0] & 0x01) << 8) + ((shdr).APIDQSubsystem[1])) -#define CCSDS_RD_SYSTEM_ID(shdr) ( ((shdr).APIDQSystemId[0] << 8) + ((shdr).APIDQSystemId[1])) - -#define CCSDS_WR_EDS_VER(shdr,val) ( (shdr).APIDQSubsystem[0] = ((shdr).APIDQSubsystem[0] & 0x07) | (((val) & 0x1f) << 3) ) -#define CCSDS_WR_ENDIAN(shdr,val) ( (shdr).APIDQSubsystem[0] = ((shdr).APIDQSubsystem[0] & 0xFB) | (((val) & 0x01) << 2) ) -#define CCSDS_WR_PLAYBACK(shdr,val) ( (shdr).APIDQSubsystem[0] = ((shdr).APIDQSubsystem[0] & 0xFD) | (((val) & 0x01) << 1) ) - -#define CCSDS_WR_SUBSYSTEM_ID(shdr,val) (((shdr).APIDQSubsystem[0] = ((shdr).APIDQSubsystem[0] & 0xFE) | ((val & 0x0100) >> 8)) ,\ - ( (shdr).APIDQSubsystem[1] = (val & 0x00ff)) ) - -#define CCSDS_WR_SYSTEM_ID(shdr,val) (((shdr).APIDQSystemId[0] = ((val & 0xff00) >> 8)),\ - ( (shdr).APIDQSystemId[1] = (val & 0x00ff)) ) - -/********************************************************************** -** Macros for clearing a CCSDS header to a standard initial state. All -** of the macros are used in a similar way: -** CCSDS_CLR_xxx_HDR(header) -- Clear header of type xxx. -**********************************************************************/ - -/* Clear primary header. */ -#define CCSDS_CLR_PRI_HDR(phdr) \ - ( (phdr).StreamId[0] = 0,\ - (phdr).StreamId[1] = 0,\ - (phdr).Sequence[0] = (CCSDS_INIT_SEQFLG << 6),\ - (phdr).Sequence[1] = 0,\ - (phdr).Length[0] = 0, \ - (phdr).Length[1] = 0 ) - -#define CCSDS_CLR_SEC_APIDQ(shdr) \ - ( (shdr).APIDQSubsystem[0] = 0,\ - (shdr).APIDQSubsystem[1] = 0,\ - (shdr).APIDQSystemId[0] = 0,\ - (shdr).APIDQSystemId[1] = 0 ) - -/* Clear command secondary header. */ -#define CCSDS_CLR_CMDSEC_HDR(shdr) \ - ( (shdr).FunctionCode = CCSDS_INIT_FC,\ - (shdr).Checksum = CCSDS_INIT_CHECKSUM ) - - -#define CCSDS_WR_SEC_HDR_SEC(shdr, value) shdr.Time[0] = ((value>>24) & 0xFF), \ - shdr.Time[1] = ((value>>16) & 0xFF), \ - shdr.Time[2] = ((value>>8) & 0xFF), \ - shdr.Time[3] = ((value) & 0xFF) - -#define CCSDS_RD_SEC_HDR_SEC(shdr) (((uint32)shdr.Time[0]) << 24) | \ - (((uint32)shdr.Time[1]) << 16) | \ - (((uint32)shdr.Time[2]) << 8) | \ - ((uint32)shdr.Time[3]) - -/* Clear telemetry secondary header. */ -#if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) - /* 32 bits seconds + 16 bits subseconds */ - #define CCSDS_CLR_TLMSEC_HDR(shdr) \ - ( (shdr).Time[0] = 0,\ - (shdr).Time[1] = 0,\ - (shdr).Time[2] = 0,\ - (shdr).Time[3] = 0,\ - (shdr).Time[4] = 0,\ - (shdr).Time[5] = 0 ) - - -#define CCSDS_WR_SEC_HDR_SUBSEC(shdr, value) shdr.Time[4] = ((value>>8) & 0xFF), \ - shdr.Time[5] = ((value) & 0xFF) - -#define CCSDS_RD_SEC_HDR_SUBSEC(shdr) (((uint32)shdr.Time[4]) << 8) | \ - ((uint32)shdr.Time[5]) -#elif ((CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_SUBS) ||\ - (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20)) - /* 32 bits seconds + 32 bits subseconds */ - #define CCSDS_CLR_TLMSEC_HDR(shdr) \ - ( (shdr).Time[0] = 0,\ - (shdr).Time[1] = 0,\ - (shdr).Time[2] = 0,\ - (shdr).Time[3] = 0,\ - (shdr).Time[4] = 0,\ - (shdr).Time[5] = 0,\ - (shdr).Time[6] = 0,\ - (shdr).Time[7] = 0 ) - -#define CCSDS_WR_SEC_HDR_SUBSEC(shdr, value) shdr.Time[4] = ((value>>24) & 0xFF), \ - shdr.Time[5] = ((value>>16) & 0xFF), \ - shdr.Time[6] = ((value>>8) & 0xFF), \ - shdr.Time[7] = ((value) & 0xFF) +typedef struct{ + CCSDS_PrimaryHeader_t Pri; + CCSDS_ExtendedHeader_t ApidQ; +} CCSDS_APIDQHdr_t; +typedef CCSDS_ExtendedHeader_t CCSDS_APIDqualifiers_t; +typedef CCSDS_PrimaryHeader_t CCSDS_PriHdr_t; +typedef CFE_MSG_CommandSecondaryHeader_t CCSDS_CmdSecHdr_t; +typedef CFE_MSG_TelemetrySecondaryHeader_t CCSDS_TlmSecHdr_t; +typedef CFE_MSG_CommandHeader_t CCSDS_CommandPacket_t; /* Element names changed, direct access will break */ +typedef CFE_MSG_TelemetryHeader_t CCSDS_TelemetryPacket_t; /* Element names changed, direct access will break */ + +#endif /* CFE_OMIT_DEPRECATED_6_8 */ -#define CCSDS_RD_SEC_HDR_SUBSEC(shdr) (((uint32)shdr.Time[4]) << 24) | \ - (((uint32)shdr.Time[5]) << 16) | \ - (((uint32)shdr.Time[6]) << 8) | \ - ((uint32)shdr.Time[7]) +/* Macro to convert 16/32 bit types from platform "endianness" to Big Endian */ +#ifdef SOFTWARE_BIG_BIT_ORDER + #define CFE_MAKE_BIG16(n) (n) + #define CFE_MAKE_BIG32(n) (n) +#else + #define CFE_MAKE_BIG16(n) ( (((n) << 8) & 0xFF00) | (((n) >> 8) & 0x00FF) ) + #define CFE_MAKE_BIG32(n) ( (((n) << 24) & 0xFF000000) | (((n) << 8) & 0x00FF0000) | (((n) >> 8) & 0x0000FF00) | (((n) >> 24) & 0x000000FF) ) #endif - - -/********************************************************************** -** Macros for extracting fields from a stream ID. All of the macros -** are used in a similar way: -** -** CCSDS_SID_xxx(sid) -- Extract field xxx from sid. -**********************************************************************/ - -/* Extract application ID from stream ID. */ -#define CCSDS_SID_APID(sid) CCSDS_RD_BITS(sid, 0x07FF, 0) - -/* Extract secondary header flag from stream ID. */ -#define CCSDS_SID_SHDR(sid) CCSDS_RD_BITS(sid, 0x0800, 11) - -/* Extract packet type (0=TLM,1=CMD) from stream ID. */ -#define CCSDS_SID_TYPE(sid) CCSDS_RD_BITS(sid, 0x1000, 12) - -/* Extract CCSDS version from stream ID. */ -#define CCSDS_SID_VERS(sid) CCSDS_RD_BITS(sid, 0xE000, 13) - - -/********************************************************************** -** Macros for frequently used combinations of operations. -** -** CCSDS_INC_SEQ(phdr) -- Increment sequence count. -**********************************************************************/ - -/* Increment sequence count in primary header by 1. */ -#define CCSDS_INC_SEQ(phdr) \ - CCSDS_WR_SEQ(phdr, (CCSDS_RD_SEQ(phdr)+1)) - - -/*********************************************************************/ - -/* -** Exported Functions -*/ - - -/****************************************************************************** -** Function: CCSDS_LoadCheckSum() -** -** Purpose: -** Compute and load a checksum for a CCSDS command packet that has a -** secondary header. -** -** Arguments: -** PktPtr : Pointer to header of command packet. The packet must -** have a secondary header and the length in the primary -** header must be correct. The checksum field in the packet -** will be modified. -** -** Return: -** (none) -*/ - -void CCSDS_LoadCheckSum (CCSDS_CommandPacket_t *PktPtr); - -/****************************************************************************** -** Function: CCSDS_ValidCheckSum() -** -** Purpose: -** Determine whether a checksum in a command packet is valid. -** -** Arguments: -** PktPtr : Pointer to header of command packet. The packet must -** have a secondary header and the length in the primary -** header must be correct. -** -** Return: -** true if checksum of packet is valid; false if not. -** A valid checksum is 0. -*/ - -bool CCSDS_ValidCheckSum (CCSDS_CommandPacket_t *PktPtr); - -/****************************************************************************** -** Function: CCSDS_ComputeCheckSum() -** -** Purpose: -** Compute the checksum for a command packet. The checksum is the XOR of -** all bytes in the packet; a valid checksum is zero. -** -** Arguments: -** PktPtr : Pointer to header of command packet. The packet must -** have a secondary header and the length in the primary -** header must be correct. -** -** Return: -** true if checksum of packet is valid; false if not. -*/ - -uint8 CCSDS_ComputeCheckSum (CCSDS_CommandPacket_t *PktPtr); - - #endif /* _ccsds_ */ -/*****************************************************************************/ diff --git a/fsw/cfe-core/src/inc/ccsds_hdr.h b/fsw/cfe-core/src/inc/ccsds_hdr.h new file mode 100644 index 000000000..c4d509d42 --- /dev/null +++ b/fsw/cfe-core/src/inc/ccsds_hdr.h @@ -0,0 +1,89 @@ +/* +** 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. +*/ + +/****************************************************************************** + * Define CCSDS packet header types + * - Avoid direct access for portability, use APIs + * - Used to construct message structures + */ + +#ifndef _ccsds_hdr_ +#define _ccsds_hdr_ + +/* + * Include Files + */ + +#include "common_types.h" +#include "cfe_mission_cfg.h" + +/* + * Type Definitions + */ + +/********************************************************************** + * Structure definitions for CCSDS headers. + * + * CCSDS headers must always be in network byte order per the standard. + * MSB at the lowest address which is commonly refered to as "BIG Endian" + * + */ + +/** + * \brief CCSDS packet primary header + */ +typedef struct { + + uint8 StreamId[2]; /**< \brief packet identifier word (stream ID) */ + /* bits shift ------------ description ---------------- */ + /* 0x07FF 0 : application ID */ + /* 0x0800 11 : secondary header: 0 = absent, 1 = present */ + /* 0x1000 12 : packet type: 0 = TLM, 1 = CMD */ + /* 0xE000 13 : CCSDS version: 0 = ver 1, 1 = ver 2 */ + + uint8 Sequence[2]; /**< \brief packet sequence word */ + /* bits shift ------------ description ---------------- */ + /* 0x3FFF 0 : sequence count */ + /* 0xC000 14 : segmentation flags: 3 = complete packet */ + + uint8 Length[2]; /**< \brief packet length word */ + /* bits shift ------------ description ---------------- */ + /* 0xFFFF 0 : (total packet length) - 7 */ + +} CCSDS_PrimaryHeader_t; + +/** + * \brief CCSDS packet extended header + */ +typedef struct { + + uint8 Subsystem[2]; /**< \brief subsystem qualifier */ + /* bits shift ------------ description ---------------- */ + /* 0x01FF 0 : Subsystem Id mission defined */ + /* 0x0200 9 : Playback flag 0 = original, 1 = playback */ + /* 0x0400 10 : Endian: Big = 0, Little (Intel) = 1 */ + /* 0xF800 11 : EDS Version for packet definition used */ + + uint8 SystemId[2]; /**< \brief system qualifier */ + /* 0xFFFF 0 : System Id mission defined */ + +} CCSDS_ExtendedHeader_t; + +#endif /* _ccsds_hdr_ */ diff --git a/fsw/cfe-core/src/inc/cfe.h b/fsw/cfe-core/src/inc/cfe.h index 530e7e52b..b58931d00 100644 --- a/fsw/cfe-core/src/inc/cfe.h +++ b/fsw/cfe-core/src/inc/cfe.h @@ -54,6 +54,8 @@ #include "cfe_time.h" /* Define Time Service API */ #include "cfe_tbl.h" /* Define Table Service API */ +#include "cfe_msg_api.h" /* Define Message API */ + #include "cfe_psp.h" /* Define Platform Support Package API */ #endif /* _cfe_ */ diff --git a/fsw/cfe-core/src/inc/cfe_sb.h b/fsw/cfe-core/src/inc/cfe_sb.h index 7f92c3794..54ccd2dab 100644 --- a/fsw/cfe-core/src/inc/cfe_sb.h +++ b/fsw/cfe-core/src/inc/cfe_sb.h @@ -146,24 +146,19 @@ ** Type Definitions */ -/** \brief Generic Software Bus Message Type Definition */ -typedef union { - CCSDS_PriHdr_t Hdr; /**< \brief CCSDS Primary Header #CCSDS_PriHdr_t */ - CCSDS_SpacePacket_t SpacePacket; - uint32 Dword; /**< \brief Forces minimum of 32-bit alignment for this object */ - uint8 Byte[sizeof(CCSDS_PriHdr_t)]; /**< \brief Allows byte-level access */ -}CFE_SB_Msg_t; +/** \brief Software Bus generic message */ +typedef CFE_MSG_Message_t CFE_SB_Msg_t; -/** \brief Generic Software Bus Command Header Type Definition */ +/** \brief Aligned Software Bus command header */ typedef union { - CCSDS_CommandPacket_t Cmd; - CFE_SB_Msg_t BaseMsg; /**< Base type (primary header) */ + CFE_MSG_CommandHeader_t Cmd; + CFE_SB_Msg_t BaseMsg; } CFE_SB_CmdHdr_t; -/** \brief Generic Software Bus Telemetry Header Type Definition */ +/** \brief Aligned Software Bus telemetry header */ typedef union { - CCSDS_TelemetryPacket_t Tlm; - CFE_SB_Msg_t BaseMsg; /**< Base type (primary header) */ + CFE_MSG_TelemetryHeader_t Tlm; + CFE_SB_Msg_t BaseMsg; } CFE_SB_TlmHdr_t; #define CFE_SB_CMD_HDR_SIZE (sizeof(CFE_SB_CmdHdr_t))/**< \brief Size of #CFE_SB_CmdHdr_t in bytes */ @@ -1313,7 +1308,7 @@ void CFE_SB_GenerateChecksum(CFE_SB_MsgPtr_t MsgPtr); ** ** \par Assumptions, External Events, and Notes: ** - If the underlying implementation of software bus messages does not -** include a checksum field, then this routine will always return \c true. +** include a checksum field this routine will always return false. ** ** \param[in] MsgPtr A pointer to the buffer that contains the software bus message. ** This must point to the first byte of the message header. @@ -1432,6 +1427,7 @@ static inline CFE_SB_MsgId_t CFE_SB_ValueToMsgId(CFE_SB_MsgId_Atom_t MsgIdValue) /*****************************************************************************/ /** * \brief Identifies packet type given message ID + * * Provides the packet type associated with the given message ID * diff --git a/fsw/cfe-core/src/sb/ccsds.c b/fsw/cfe-core/src/sb/ccsds.c deleted file mode 100644 index 02317f71d..000000000 --- a/fsw/cfe-core/src/sb/ccsds.c +++ /dev/null @@ -1,122 +0,0 @@ -/* -** 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: ccsds.c -** -** Purpose: -** Functions for working with CCSDS headers. -** -******************************************************************************/ - -/* -** Include Files -*/ - -#include "common_types.h" -#include "ccsds.h" -#include "osapi.h" -#include "cfe_psp.h" - -/****************************************************************************** -** Function: CCSDS_LoadCheckSum() -** -** Purpose: -** Compute and load a checksum for a CCSDS command packet that has a -** secondary header. -** -** Arguments: -** PktPtr : Pointer to header of command packet. The packet must -** have a secondary header and the length in the primary -** header must be correct. The checksum field in the packet -** will be modified. -** -** Return: -** (none) -*/ - -void CCSDS_LoadCheckSum (CCSDS_CommandPacket_t *PktPtr) -{ - uint8 CheckSum; - - /* Clear the checksum field so the new checksum is correct. */ - CCSDS_WR_CHECKSUM(PktPtr->Sec, 0); - - /* Compute and load new checksum. */ - CheckSum = CCSDS_ComputeCheckSum(PktPtr); - CCSDS_WR_CHECKSUM(PktPtr->Sec, CheckSum); - -} /* END CCSDS_LoadCheckSum() */ - - -/****************************************************************************** -** Function: CCSDS_ValidCheckSum() -** -** Purpose: -** Determine whether a checksum in a command packet is valid. -** -** Arguments: -** PktPtr : Pointer to header of command packet. The packet must -** have a secondary header and the length in the primary -** header must be correct. -** -** Return: -** true if checksum of packet is valid; false if not. -** A valid checksum is 0. -*/ - -bool CCSDS_ValidCheckSum (CCSDS_CommandPacket_t *PktPtr) -{ - - return (CCSDS_ComputeCheckSum(PktPtr) == 0); - -} /* END CCSDS_ValidCheckSum() */ - - -/****************************************************************************** -** Function: CCSDS_ComputeCheckSum() -** -** Purpose: -** Compute the checksum for a command packet. The checksum is the XOR of -** all bytes in the packet; a valid checksum is zero. -** -** Arguments: -** PktPtr : Pointer to header of command packet. The packet must -** have a secondary header and the length in the primary -** header must be correct. -** -** Return: -** true if checksum of packet is valid; false if not. -*/ - -uint8 CCSDS_ComputeCheckSum (CCSDS_CommandPacket_t *PktPtr) -{ - uint16 PktLen = CCSDS_RD_LEN(PktPtr->SpacePacket.Hdr); - uint8 *BytePtr = (uint8 *)PktPtr; - uint8 CheckSum; - - CheckSum = 0xFF; - while (PktLen--) CheckSum ^= *(BytePtr++); - - return CheckSum; - -} /* END CCSDS_ComputeCheckSum() */ - -/*****************************************************************************/ diff --git a/fsw/cfe-core/src/sb/cfe_sb_msg_id_util.c b/fsw/cfe-core/src/sb/cfe_sb_msg_id_util.c index 59fdb72f1..25595d7ea 100644 --- a/fsw/cfe-core/src/sb/cfe_sb_msg_id_util.c +++ b/fsw/cfe-core/src/sb/cfe_sb_msg_id_util.c @@ -90,7 +90,7 @@ #include "osapi.h" #include "cfe_error.h" #include "cfe_sb_priv.h" -#include "cfe_sb_msg_id_util.h" +#include "cfe_msg_api.h" /****************************************************************************** @@ -120,34 +120,12 @@ CFE_SB_MsgKey_t CFE_SB_ConvertMsgIdtoMsgKey( CFE_SB_MsgId_t MsgId) */ CFE_SB_MsgId_t CFE_SB_GetMsgId(const CFE_SB_Msg_t *MsgPtr) { - CFE_SB_MsgId_Atom_t MsgIdVal = 0; + CFE_SB_MsgId_t MsgId; -#ifndef MESSAGE_FORMAT_IS_CCSDS_VER_2 - MsgIdVal = CCSDS_RD_SID(MsgPtr->Hdr); -#else + /* Ignore return since no alternative action */ + CFE_MSG_GetMsgId(MsgPtr, &MsgId); - uint32 SubSystemId; - - MsgIdVal = CCSDS_RD_APID(MsgPtr->Hdr); /* Primary header APID */ - - if ( CCSDS_RD_TYPE(MsgPtr->Hdr) == CCSDS_CMD) - MsgIdVal = MsgIdVal | CFE_SB_CMD_MESSAGE_TYPE; - - /* Add in the SubSystem ID as needed */ - SubSystemId = CCSDS_RD_SUBSYSTEM_ID(MsgPtr->SpacePacket.ApidQ); - MsgIdVal = (MsgIdVal | (SubSystemId << 8)); - -/* Example code to add in the System ID as needed. */ -/* The default is to init this field to the Spacecraft ID but ignore for routing. */ -/* To fully implement this field would require significant SB optimization to avoid */ -/* prohibitively large routing and index tables. */ -/* uint16 SystemId; */ -/* SystemId = CCSDS_RD_SYSTEM_ID(HdrPtr->ApidQ); */ -/* MsgIdVal = (MsgIdVal | (SystemId << 16)); */ - -#endif - -return CFE_SB_ValueToMsgId(MsgIdVal); + return MsgId; }/* end CFE_SB_GetMsgId */ @@ -158,32 +136,10 @@ return CFE_SB_ValueToMsgId(MsgIdVal); void CFE_SB_SetMsgId(CFE_SB_MsgPtr_t MsgPtr, CFE_SB_MsgId_t MsgId) { - CFE_SB_MsgId_Atom_t MsgIdVal = CFE_SB_MsgIdToValue(MsgId); - -#ifndef MESSAGE_FORMAT_IS_CCSDS_VER_2 - CCSDS_WR_SID(MsgPtr->Hdr, MsgIdVal); -#else - CCSDS_WR_VERS(MsgPtr->SpacePacket.Hdr, 1); - - /* Set the stream ID APID in the primary header. */ - CCSDS_WR_APID(MsgPtr->SpacePacket.Hdr, CFE_SB_RD_APID_FROM_MSGID(MsgIdVal) ); - - CCSDS_WR_TYPE(MsgPtr->SpacePacket.Hdr, CFE_SB_RD_TYPE_FROM_MSGID(MsgIdVal) ); - - - CCSDS_CLR_SEC_APIDQ(MsgPtr->SpacePacket.ApidQ); - - CCSDS_WR_EDS_VER(MsgPtr->SpacePacket.ApidQ, 1); - - CCSDS_WR_ENDIAN(MsgPtr->SpacePacket.ApidQ, CFE_PLATFORM_ENDIAN); - - CCSDS_WR_PLAYBACK(MsgPtr->SpacePacket.ApidQ, false); - - CCSDS_WR_SUBSYSTEM_ID(MsgPtr->SpacePacket.ApidQ, CFE_SB_RD_SUBSYS_ID_FROM_MSGID(MsgIdVal)); - - CCSDS_WR_SYSTEM_ID(MsgPtr->SpacePacket.ApidQ, CFE_MISSION_SPACECRAFT_ID); - -#endif + + /* Ignore return, no alternate action */ + CFE_MSG_SetMsgId(MsgPtr, MsgId); + }/* end CFE_SB_SetMsgId */ /* @@ -192,31 +148,12 @@ void CFE_SB_SetMsgId(CFE_SB_MsgPtr_t MsgPtr, uint32 CFE_SB_GetPktType(CFE_SB_MsgId_t MsgId) { - CFE_SB_MsgId_Atom_t Val = CFE_SB_MsgIdToValue(MsgId); - uint8 PktType; - - if (CFE_SB_IsValidMsgId(MsgId)) - { -#ifndef MESSAGE_FORMAT_IS_CCSDS_VER_2 - if (CFE_TST(Val,12)) - { - PktType = CFE_SB_PKTTYPE_CMD; - } else { - PktType = CFE_SB_PKTTYPE_TLM; - } -#else - if (CFE_SB_RD_TYPE_FROM_MSGID(Val) == 1) - { - PktType = CFE_SB_PKTTYPE_CMD; - } else { - PktType = CFE_SB_PKTTYPE_TLM; - } -#endif /* MESSAGE_FORMAT_IS_CCSDS_VER_2 */ - } else { - PktType = CFE_SB_PKTTYPE_INVALID; - } - - return PktType; + CFE_MSG_Type_t type; + + /* Ignores return, no alternate action */ + CFE_MSG_GetTypeFromMsgId(MsgId, &type); + + return type; }/* end CFE_SB_GetPktType */ diff --git a/fsw/cfe-core/src/sb/cfe_sb_msg_id_util.h b/fsw/cfe-core/src/sb/cfe_sb_msg_id_util.h deleted file mode 100644 index 29b94ba9e..000000000 --- a/fsw/cfe-core/src/sb/cfe_sb_msg_id_util.h +++ /dev/null @@ -1,78 +0,0 @@ -/* -** 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: cfe_sb_msg_id_util.h -** -** Purpose: -** This header file contains prototypes for private functions and type -** definitions for SB internal use. -** -** Author: J. Wilmot/NASA -** -******************************************************************************/ - -#ifndef _cfe_sb_msg_id_util_ -#define _cfe_sb_msg_id_util_ - -/* -** Includes -*/ -#include "common_types.h" - -/** -** For MESSAGE_FORMAT_IS_CCSDS_VER_2 the default layout of the message id is: -** 7 bits from the primary header APID -** 1 bit for the command/telemetry flag -** 0 bits from the Playback flag -** 8 bits from the secondary header APID qualifier (Subsystem) -** 0 bits from the secondary header APID qualifier as the System -** = 16 bits total -** -** Byte 1 Byte 0 -** 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 -** +-+-+-+-+-+-+-+-+|--------|+-+-+-+-+-+-+-+ -** | APID Qualifier |C/T flg | Pri Hdr APID | -** +-+-+-+-+-+-+-+-+|--------|+-+-+-+-+-+-+-+ -** This layout may be modified via the 4 macros -** CFE_SB_CMD_MESSAGE_TYPE, CFE_SB_RD_APID_FROM_MSGID -** CFE_SB_RD_SUBSYS_ID_FROM_MSGID and CFE_SB_RD_TYPE_FROM_MSGID -** -*/ - -/* -** Macro Definitions -*/ - -/* - * Mission defined bit used to indicate message is a command type. A 0 in this bit position indicates - * a telemetry message type. This bit is included in the message id. - */ -#define CFE_SB_CMD_MESSAGE_TYPE 0x00000080 /* 1 bit (position 7) for Cmd/Tlm */ - -/* - * Mission defined macros to extract message id fields from the primary and secondary headers -*/ -#define CFE_SB_RD_APID_FROM_MSGID(MsgId) (MsgId & 0x0000007F) /* 0-6(7) bits for Pri Hdr APID */ -#define CFE_SB_RD_SUBSYS_ID_FROM_MSGID(MsgId) ( (MsgId & 0x0000FF00) >> 8) /* bits 8-15(8) bits for APID Subsystem ID */ -#define CFE_SB_RD_TYPE_FROM_MSGID(MsgId) ( (MsgId & CFE_SB_CMD_MESSAGE_TYPE) >> 7) /* 1 Cmd/Tlm Bit (bit #7) */ - -#endif /* _cfe_sb_msg_id_util_ */ -/*****************************************************************************/ diff --git a/fsw/cfe-core/src/sb/cfe_sb_priv.c b/fsw/cfe-core/src/sb/cfe_sb_priv.c index f1b4a3724..1ae509dce 100644 --- a/fsw/cfe-core/src/sb/cfe_sb_priv.c +++ b/fsw/cfe-core/src/sb/cfe_sb_priv.c @@ -80,12 +80,11 @@ #include "osapi.h" #include "private/cfe_private.h" #include "cfe_sb_priv.h" -#include "cfe_sb_msg_id_util.h" #include "cfe_sb.h" #include "ccsds.h" #include "cfe_error.h" #include "cfe_es.h" -#include "cfe_sb_msg_id_util.h" +#include "cfe_msg_api.h" #include /****************************************************************************** @@ -551,7 +550,7 @@ int32 CFE_SB_DuplicateSubscribeCheck(CFE_SB_MsgKey_t MsgKey, */ void CFE_SB_SetMsgSeqCnt(CFE_SB_MsgPtr_t MsgPtr,uint32 Count){ - CCSDS_WR_SEQ(MsgPtr->Hdr,Count); + CFE_MSG_SetSequenceCount(MsgPtr, Count); }/* end CFE_SB_SetMsgSeqCnt */ diff --git a/fsw/cfe-core/src/sb/cfe_sb_task.c b/fsw/cfe-core/src/sb/cfe_sb_task.c index b36d2f173..b9a85cccd 100644 --- a/fsw/cfe-core/src/sb/cfe_sb_task.c +++ b/fsw/cfe-core/src/sb/cfe_sb_task.c @@ -42,7 +42,6 @@ #include "cfe_psp.h" #include "cfe_es_msg.h" #include "cfe_sb_verify.h" -#include "cfe_sb_msg_id_util.h" #include /* Task Globals */ diff --git a/fsw/cfe-core/src/sb/cfe_sb_util.c b/fsw/cfe-core/src/sb/cfe_sb_util.c index abef9d505..1cc61fbc5 100644 --- a/fsw/cfe-core/src/sb/cfe_sb_util.c +++ b/fsw/cfe-core/src/sb/cfe_sb_util.c @@ -38,6 +38,7 @@ #include "ccsds.h" #include "osapi.h" #include "cfe_error.h" +#include "cfe_msg_api.h" #include @@ -49,38 +50,10 @@ void CFE_SB_InitMsg(void *MsgPtr, uint16 Length, bool Clear ) { - uint16 SeqCount; - CCSDS_PriHdr_t *PktPtr; - - PktPtr = (CCSDS_PriHdr_t *) MsgPtr; - - /* Save the sequence count in case it must be preserved. */ - SeqCount = CCSDS_RD_SEQ(*PktPtr); - - /* Zero the entire packet if needed. */ - if (Clear) - { memset(MsgPtr, 0, Length); } - else /* Clear only the primary header. */ - { - CCSDS_CLR_PRI_HDR(*PktPtr); - } - - /* Set the length fields in the primary header. */ - CCSDS_WR_LEN(*PktPtr, Length); - - /* Always set the secondary header flag as CFS applications are required use it */ - CCSDS_WR_SHDR(*PktPtr, 1); - - CFE_SB_SetMsgId(MsgPtr, MsgId); - - /* Restore the sequence count if needed. */ - if (!Clear) - CCSDS_WR_SEQ(*PktPtr, SeqCount); - else - CCSDS_WR_SEQFLG(*PktPtr, CCSDS_INIT_SEQFLG); -} /* end CFE_SB_InitMsg */ + CFE_MSG_Init((CFE_MSG_Message_t *)MsgPtr, MsgId, Length, Clear); +} /* end CFE_SB_InitMsg */ /****************************************************************************** ** Function: CFE_SB_MsgHdrSize() @@ -97,27 +70,29 @@ void CFE_SB_InitMsg(void *MsgPtr, uint16 CFE_SB_MsgHdrSize(const CFE_SB_Msg_t *MsgPtr) { - uint16 size; - const CCSDS_PriHdr_t *HdrPtr; + uint16 size = 0; + bool hassechdr = false; + CFE_MSG_Type_t type = CFE_MSG_Type_Invalid; - HdrPtr = (const CCSDS_PriHdr_t *) MsgPtr; + CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassechdr); + CFE_MSG_GetType(MsgPtr, &type); /* if secondary hdr is not present... */ /* Since all cFE messages must have a secondary hdr this check is not needed */ - if(CCSDS_RD_SHDR(*HdrPtr) == 0){ - size = sizeof(CCSDS_PriHdr_t); - - }else if(CCSDS_RD_TYPE(*HdrPtr) == CCSDS_CMD){ - - size = CFE_SB_CMD_HDR_SIZE; - - }else{ - - size = CFE_SB_TLM_HDR_SIZE; - + if(!hassechdr) + { + size = sizeof(CCSDS_SpacePacket_t); + } + else if(type == CFE_MSG_Type_Cmd) + { + size = sizeof(CFE_SB_CmdHdr_t); + } + else if(type == CFE_MSG_Type_Tlm) + { + size = sizeof(CFE_SB_TlmHdr_t); } - return size; + return size; }/* end CFE_SB_MsgHdrSize */ @@ -142,10 +117,10 @@ void *CFE_SB_GetUserData(CFE_SB_MsgPtr_t MsgPtr) */ uint16 CFE_SB_GetUserDataLength(const CFE_SB_Msg_t *MsgPtr) { - uint16 TotalMsgSize; + uint32 TotalMsgSize; uint16 HdrSize; - TotalMsgSize = CFE_SB_GetTotalMsgLength(MsgPtr); + CFE_MSG_GetSize(MsgPtr, &TotalMsgSize); HdrSize = CFE_SB_MsgHdrSize(MsgPtr); return (TotalMsgSize - HdrSize); @@ -161,18 +136,23 @@ void CFE_SB_SetUserDataLength(CFE_SB_MsgPtr_t MsgPtr, uint16 DataLength) HdrSize = CFE_SB_MsgHdrSize(MsgPtr); TotalMsgSize = HdrSize + DataLength; - CCSDS_WR_LEN(MsgPtr->Hdr,TotalMsgSize); + + CFE_MSG_SetSize(MsgPtr, TotalMsgSize); }/* end CFE_SB_SetUserDataLength */ - /* * Function: CFE_SB_GetTotalMsgLength - See API and header file for details */ uint16 CFE_SB_GetTotalMsgLength(const CFE_SB_Msg_t *MsgPtr) { - return CCSDS_RD_LEN(MsgPtr->Hdr); + CFE_MSG_Size_t size; + + CFE_MSG_GetSize(MsgPtr, &size); + + /* Known bug that this API can't return maximum ccsds size */ + return (uint16)size; }/* end CFE_SB_GetTotalMsgLength */ @@ -183,7 +163,7 @@ uint16 CFE_SB_GetTotalMsgLength(const CFE_SB_Msg_t *MsgPtr) void CFE_SB_SetTotalMsgLength(CFE_SB_MsgPtr_t MsgPtr,uint16 TotalLength) { - CCSDS_WR_LEN(MsgPtr->Hdr,TotalLength); + CFE_MSG_SetSize(MsgPtr, TotalLength); }/* end CFE_SB_SetTotalMsgLength */ @@ -193,48 +173,9 @@ void CFE_SB_SetTotalMsgLength(CFE_SB_MsgPtr_t MsgPtr,uint16 TotalLength) */ CFE_TIME_SysTime_t CFE_SB_GetMsgTime(CFE_SB_MsgPtr_t MsgPtr) { - CFE_TIME_SysTime_t TimeFromMsg; - uint32 LocalSecs32 = 0; - uint32 LocalSubs32 = 0; - - #if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) - uint16 LocalSubs16; - #endif - - CFE_SB_TlmHdr_t *TlmHdrPtr; + CFE_TIME_SysTime_t TimeFromMsg = {0}; - /* if msg type is a command or msg has no secondary hdr, time = 0 */ - if ((CCSDS_RD_TYPE(MsgPtr->Hdr) != CCSDS_CMD) && (CCSDS_RD_SHDR(MsgPtr->Hdr) != 0)) { - - /* copy time data to/from packets to eliminate alignment issues */ - TlmHdrPtr = (CFE_SB_TlmHdr_t *)MsgPtr; - - #if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) - - memcpy(&LocalSecs32, &TlmHdrPtr->Tlm.Sec.Time[0], 4); - memcpy(&LocalSubs16, &TlmHdrPtr->Tlm.Sec.Time[4], 2); - /* convert packet data into CFE_TIME_SysTime_t format */ - LocalSubs32 = ((uint32) LocalSubs16) << 16; - - #elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_SUBS) - - memcpy(&LocalSecs32, &TlmHdrPtr->Tlm.Sec.Time[0], 4); - memcpy(&LocalSubs32, &TlmHdrPtr->Tlm.Sec.Time[4], 4); - /* no conversion necessary -- packet format = CFE_TIME_SysTime_t format */ - - #elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20) - - memcpy(&LocalSecs32, &TlmHdrPtr->Tlm.Sec.Time[0], 4); - memcpy(&LocalSubs32, &TlmHdrPtr->Tlm.Sec.Time[4], 4); - /* convert packet data into CFE_TIME_SysTime_t format */ - LocalSubs32 = CFE_TIME_Micro2SubSecs((LocalSubs32 >> 12)); - - #endif - } - - /* return the packet time converted to CFE_TIME_SysTime_t format */ - TimeFromMsg.Seconds = LocalSecs32; - TimeFromMsg.Subseconds = LocalSubs32; + CFE_MSG_GetMsgTime(MsgPtr, &TimeFromMsg); return TimeFromMsg; @@ -246,50 +187,8 @@ CFE_TIME_SysTime_t CFE_SB_GetMsgTime(CFE_SB_MsgPtr_t MsgPtr) */ int32 CFE_SB_SetMsgTime(CFE_SB_MsgPtr_t MsgPtr, CFE_TIME_SysTime_t NewTime) { - int32 Result = CFE_SB_WRONG_MSG_TYPE; - - CFE_SB_TlmHdr_t *TlmHdrPtr; - - /* declare format specific vars */ - #if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) - uint16 LocalSubs16; - #elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20) - uint32 LocalSubs32; - #endif - - /* cannot set time if msg type is a command or msg has no secondary hdr */ - if ((CCSDS_RD_TYPE(MsgPtr->Hdr) != CCSDS_CMD) && (CCSDS_RD_SHDR(MsgPtr->Hdr) != 0)) { - - /* copy time data to/from packets to eliminate alignment issues */ - TlmHdrPtr = (CFE_SB_TlmHdr_t *) MsgPtr; - - #if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) - /* convert time from CFE_TIME_SysTime_t format to packet format */ - LocalSubs16 = (uint16) (NewTime.Subseconds >> 16); - memcpy(&TlmHdrPtr->Tlm.Sec.Time[0], &NewTime.Seconds, 4); - memcpy(&TlmHdrPtr->Tlm.Sec.Time[4], &LocalSubs16, 2); - Result = CFE_SUCCESS; - - #elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_SUBS) - - /* no conversion necessary -- packet format = CFE_TIME_SysTime_t format */ - memcpy(&TlmHdrPtr->Tlm.Sec.Time[0], &NewTime.Seconds, 4); - memcpy(&TlmHdrPtr->Tlm.Sec.Time[4], &NewTime.Subseconds, 4); - Result = CFE_SUCCESS; - - #elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20) - - /* convert time from CFE_TIME_SysTime_t format to packet format */ - LocalSubs32 = CFE_TIME_Sub2MicroSecs(NewTime.Subseconds) << 12; - memcpy(&TlmHdrPtr->Tlm.Sec.Time[0], &NewTime.Seconds, 4); - memcpy(&TlmHdrPtr->Tlm.Sec.Time[4], &LocalSubs32, 4); - Result = CFE_SUCCESS; - - #endif - } - - return Result; + return CFE_MSG_SetMsgTime(MsgPtr, NewTime); }/* end CFE_SB_SetMsgTime */ @@ -309,17 +208,13 @@ void CFE_SB_TimeStampMsg(CFE_SB_MsgPtr_t MsgPtr) */ uint16 CFE_SB_GetCmdCode(CFE_SB_MsgPtr_t MsgPtr) { - CFE_SB_CmdHdr_t *CmdHdrPtr; - /* if msg type is telemetry or there is no secondary hdr, return 0 */ - if((CCSDS_RD_TYPE(MsgPtr->Hdr) == CCSDS_TLM)||(CCSDS_RD_SHDR(MsgPtr->Hdr) == 0)){ - return 0; - }/* end if */ + CFE_MSG_FcnCode_t fc; - /* Cast the input pointer to a Cmd Msg pointer */ - CmdHdrPtr = (CFE_SB_CmdHdr_t *)MsgPtr; + CFE_MSG_GetFcnCode(MsgPtr, &fc); + + return fc; - return CCSDS_RD_FC(CmdHdrPtr->Cmd.Sec); }/* end CFE_SB_GetCmdCode */ @@ -329,60 +224,41 @@ uint16 CFE_SB_GetCmdCode(CFE_SB_MsgPtr_t MsgPtr) int32 CFE_SB_SetCmdCode(CFE_SB_MsgPtr_t MsgPtr, uint16 CmdCode) { - CFE_SB_CmdHdr_t *CmdHdrPtr; - - /* if msg type is telemetry or there is no secondary hdr... */ - if((CCSDS_RD_TYPE(MsgPtr->Hdr) == CCSDS_TLM)||(CCSDS_RD_SHDR(MsgPtr->Hdr) == 0)){ - return CFE_SB_WRONG_MSG_TYPE; - }/* end if */ - - /* Cast the input pointer to a Cmd Msg pointer */ - CmdHdrPtr = (CFE_SB_CmdHdr_t *)MsgPtr; - - CCSDS_WR_FC(CmdHdrPtr->Cmd.Sec,CmdCode); - return CFE_SUCCESS; + return CFE_MSG_SetFcnCode(MsgPtr, CmdCode); }/* end CFE_SB_SetCmdCode */ - /* * Function: CFE_SB_GetChecksum - See API and header file for details */ uint16 CFE_SB_GetChecksum(CFE_SB_MsgPtr_t MsgPtr) { - CFE_SB_CmdHdr_t *CmdHdrPtr; + CFE_MSG_Type_t type = CFE_MSG_Type_Invalid; + bool hassechdr = false; + + CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassechdr); + CFE_MSG_GetType(MsgPtr, &type); /* if msg type is telemetry or there is no secondary hdr... */ - if((CCSDS_RD_TYPE(MsgPtr->Hdr) == CCSDS_TLM)||(CCSDS_RD_SHDR(MsgPtr->Hdr) == 0)){ + if((type == CFE_MSG_Type_Tlm)||(!hassechdr)) + { return 0; }/* end if */ - /* cast the input pointer to a Cmd Msg pointer */ - CmdHdrPtr = (CFE_SB_CmdHdr_t *)MsgPtr; - - return CCSDS_RD_CHECKSUM(CmdHdrPtr->Cmd.Sec); + /* Byte access for now to avoid error if secondary doesn't contain checksum */ + return MsgPtr->Byte[sizeof(CCSDS_SpacePacket_t) + 1]; }/* end CFE_SB_GetChecksum */ - /* * Function: CFE_SB_GenerateChecksum - See API and header file for details */ void CFE_SB_GenerateChecksum(CFE_SB_MsgPtr_t MsgPtr) { - CCSDS_CommandPacket_t *CmdPktPtr; - - /* if msg type is telemetry or there is no secondary hdr... */ - if((CCSDS_RD_TYPE(MsgPtr->Hdr) == CCSDS_TLM)||(CCSDS_RD_SHDR(MsgPtr->Hdr) == 0)){ - return; - }/* end if */ - - CmdPktPtr = (CCSDS_CommandPacket_t *)MsgPtr; - - CCSDS_LoadCheckSum(CmdPktPtr); + CFE_MSG_GenerateChecksum(MsgPtr); }/* end CFE_SB_GenerateChecksum */ @@ -392,21 +268,14 @@ void CFE_SB_GenerateChecksum(CFE_SB_MsgPtr_t MsgPtr) */ bool CFE_SB_ValidateChecksum(CFE_SB_MsgPtr_t MsgPtr) { + bool isvalid = false; - CCSDS_CommandPacket_t *CmdPktPtr; + CFE_MSG_ValidateChecksum(MsgPtr, &isvalid); - /* if msg type is telemetry or there is no secondary hdr... */ - if((CCSDS_RD_TYPE(MsgPtr->Hdr) == CCSDS_TLM)||(CCSDS_RD_SHDR(MsgPtr->Hdr) == 0)){ - return false; - }/* end if */ - - CmdPktPtr = (CCSDS_CommandPacket_t *)MsgPtr; - - return CCSDS_ValidCheckSum (CmdPktPtr); + return isvalid; }/* end CFE_SB_ValidateChecksum */ - /* * Function: CFE_SB_MessageStringGet - See API and header file for details */ From 97682b8d0a671b035402dd419f6927d2db26c53f Mon Sep 17 00:00:00 2001 From: Jacob Hageman Date: Fri, 14 Aug 2020 10:51:57 -0400 Subject: [PATCH 3/9] Fix #711, SB unit test updates for msg module - Removes dependencies on old macros - Simplifies unit tests - Treats msg module as internal code for now (temporary) --- fsw/cfe-core/unit-test/CMakeLists.txt | 9 + fsw/cfe-core/unit-test/sb_UT.c | 534 ++++++++------------------ fsw/cfe-core/unit-test/ut_support.c | 2 +- fsw/cfe-core/ut-stubs/ut_sb_stubs.c | 2 +- 4 files changed, 176 insertions(+), 371 deletions(-) diff --git a/fsw/cfe-core/unit-test/CMakeLists.txt b/fsw/cfe-core/unit-test/CMakeLists.txt index 3c90521c4..ee10db8c4 100644 --- a/fsw/cfe-core/unit-test/CMakeLists.txt +++ b/fsw/cfe-core/unit-test/CMakeLists.txt @@ -26,6 +26,11 @@ add_library(ut_cfe-core_support STATIC ut_support.c ut_osprintf_stubs.c ) +target_include_directories(ut_cfe-core_support PUBLIC + ${cfe-core_MISSION_DIR}/src/es + ${cfe-core_MISSION_DIR}/src/evs + ${cfe-core_MISSION_DIR}/src/time + ${CMAKE_CURRENT_SOURCE_DIR}) # For each core module, generate the associated unit test # This is done by linking the stubs of every OTHER module with the @@ -67,6 +72,10 @@ foreach(MODULE ${CFE_CORE_MODULES}) ut_cfe-core_support ut_cfe-core_stubs ut_assert) + + # TODO short term hack for testing with new code + target_link_libraries(${UT_TARGET_NAME}_UT msg) + #target_link_libraries(${UT_TARGET_NAME}_UT mission_msg) add_test(${UT_TARGET_NAME}_UT ${UT_TARGET_NAME}_UT) install(TARGETS ${UT_TARGET_NAME}_UT DESTINATION ${TGTNAME}/${UT_INSTALL_SUBDIR}) diff --git a/fsw/cfe-core/unit-test/sb_UT.c b/fsw/cfe-core/unit-test/sb_UT.c index 2f2ffcf1a..c93b3e8d5 100644 --- a/fsw/cfe-core/unit-test/sb_UT.c +++ b/fsw/cfe-core/unit-test/sb_UT.c @@ -39,6 +39,7 @@ ** Includes */ #include "sb_UT.h" +#include "cfe_msg_api.h" /* * A method to add an SB "Subtest" @@ -136,122 +137,9 @@ void UtTest_Setup(void) UT_ADD_TEST(Test_SB_Utils); Test_SB_SpecialCases(); - Test_SB_Macros(); } /* end main */ -/* -** Function for calling SB and CCSDS Macros -** test functions -*/ -void Test_SB_Macros(void) -{ - SB_UT_ADD_SUBTEST(Test_SB_CCSDSPriHdr_Macros); - SB_UT_ADD_SUBTEST(Test_SB_CCSDSSecHdr_Macros); -} /* end Test_SB_Macros */ - -/* -**Test_SB_CCSDSSecHdr_Macros -*/ -void Test_SB_CCSDSSecHdr_Macros(void) -{ - CFE_SB_CmdHdr_t NoParamPkt; - - CCSDS_CLR_CMDSEC_HDR(NoParamPkt.Cmd.Sec); - CCSDS_WR_FC(NoParamPkt.Cmd.Sec, 1); - - ASSERT_TRUE(CCSDS_RD_FC(NoParamPkt.Cmd.Sec) == 0x01); - - CCSDS_CLR_CMDSEC_HDR(NoParamPkt.Cmd.Sec); - CCSDS_WR_CHECKSUM(NoParamPkt.Cmd.Sec, 0xFF); - - ASSERT_TRUE(CCSDS_RD_CHECKSUM(NoParamPkt.Cmd.Sec) == 0xFF); - - -#ifdef MESSAGE_FORMAT_IS_CCSDS_VER_2 - - CCSDS_CLR_SEC_APIDQ(NoParamPkt.Cmd.SpacePacket.ApidQ); - CCSDS_WR_EDS_VER(NoParamPkt.Cmd.SpacePacket.ApidQ, 0x01); - - ASSERT_TRUE(CCSDS_RD_EDS_VER(NoParamPkt.Cmd.SpacePacket.ApidQ) == 0x01); - - CCSDS_CLR_SEC_APIDQ(NoParamPkt.Cmd.SpacePacket.ApidQ); - CCSDS_WR_ENDIAN(NoParamPkt.Cmd.SpacePacket.ApidQ, 0x01); - - ASSERT_TRUE(CCSDS_RD_ENDIAN(NoParamPkt.Cmd.SpacePacket.ApidQ) == 0x01); - - CCSDS_CLR_SEC_APIDQ(NoParamPkt.Cmd.SpacePacket.ApidQ); - CCSDS_WR_PLAYBACK(NoParamPkt.Cmd.SpacePacket.ApidQ, 0x01); - - ASSERT_TRUE(CCSDS_RD_PLAYBACK(NoParamPkt.Cmd.SpacePacket.ApidQ) == 0x01); - - CCSDS_CLR_SEC_APIDQ(NoParamPkt.Cmd.SpacePacket.ApidQ); - CCSDS_WR_SUBSYSTEM_ID(NoParamPkt.Cmd.SpacePacket.ApidQ, 0xFF); - - ASSERT_TRUE(CCSDS_RD_SUBSYSTEM_ID(NoParamPkt.Cmd.SpacePacket.ApidQ) == 0xFF); - - CCSDS_CLR_SEC_APIDQ(NoParamPkt.Cmd.SpacePacket.ApidQ); - CCSDS_WR_SUBSYSTEM_ID(NoParamPkt.Cmd.SpacePacket.ApidQ, 0xFF); - - ASSERT_TRUE(CCSDS_RD_SUBSYSTEM_ID(NoParamPkt.Cmd.SpacePacket.ApidQ) == 0xFF); - - CCSDS_CLR_SEC_APIDQ(NoParamPkt.Cmd.SpacePacket.ApidQ); - CCSDS_WR_SYSTEM_ID(NoParamPkt.Cmd.SpacePacket.ApidQ, 0xFFFF); - - ASSERT_TRUE(CCSDS_RD_SYSTEM_ID(NoParamPkt.Cmd.SpacePacket.ApidQ) == 0xFFFF); - -#endif -} /* end Test_SB_CCSDSSecHdr_Macros */ - -/* -**Test_SB_CCSDSPriHdr_Macros -*/ -void Test_SB_CCSDSPriHdr_Macros(void) -{ - CFE_SB_Msg_t Msg; - - CCSDS_CLR_PRI_HDR(Msg.Hdr); - CCSDS_WR_SID(Msg.Hdr, 0x1899); - - ASSERT_TRUE(CCSDS_RD_SID(Msg.Hdr) == 0x1899); - - CCSDS_CLR_PRI_HDR(Msg.Hdr); - CCSDS_WR_APID(Msg.Hdr, 0x07FF); - - ASSERT_TRUE(CCSDS_RD_APID(Msg.Hdr) == 0x07FF); - - CCSDS_CLR_PRI_HDR(Msg.Hdr); - CCSDS_WR_SHDR(Msg.Hdr, 1); - - ASSERT_TRUE(CCSDS_RD_SHDR(Msg.Hdr) == 1); - - CCSDS_CLR_PRI_HDR(Msg.Hdr); - CCSDS_WR_TYPE(Msg.Hdr, 1); - - ASSERT_TRUE(CCSDS_RD_TYPE(Msg.Hdr) == 1); - - CCSDS_CLR_PRI_HDR(Msg.Hdr); - CCSDS_WR_VERS(Msg.Hdr, 1); - - ASSERT_TRUE(CCSDS_RD_VERS(Msg.Hdr) == 1); - - CCSDS_CLR_PRI_HDR(Msg.Hdr); - CCSDS_WR_SEQ(Msg.Hdr, 0x3FFF); - - ASSERT_TRUE(CCSDS_RD_SEQ(Msg.Hdr) == 0x3FFF); - - CCSDS_CLR_PRI_HDR(Msg.Hdr); - CCSDS_WR_SEQFLG(Msg.Hdr, 0x03); - - ASSERT_TRUE(CCSDS_RD_SEQFLG(Msg.Hdr) == 0x03); - - CCSDS_CLR_PRI_HDR(Msg.Hdr); - CCSDS_WR_LEN(Msg.Hdr, 0xFFFF); - - ASSERT_TRUE(CCSDS_RD_LEN(Msg.Hdr) == 0xFFFF); - -} /* end Test_SB_CCSDSPriHdr_Macros */ - /* ** Reset variable values and sockets prior to a test */ @@ -2658,7 +2546,6 @@ void Test_Unsubscribe_GetDestPtr(void) void Test_SendMsg_API(void) { SB_UT_ADD_SUBTEST(Test_SendMsg_NullPtr); - SB_UT_ADD_SUBTEST(Test_SendMsg_InvalidMsgId); SB_UT_ADD_SUBTEST(Test_SendMsg_NoSubscribers); SB_UT_ADD_SUBTEST(Test_SendMsg_MaxMsgSizePlusOne); SB_UT_ADD_SUBTEST(Test_SendMsg_BasicSend); @@ -2673,7 +2560,6 @@ void Test_SendMsg_API(void) SB_UT_ADD_SUBTEST(Test_SendMsg_ZeroCopyReleasePtr); SB_UT_ADD_SUBTEST(Test_SendMsg_DisabledDestination); SB_UT_ADD_SUBTEST(Test_SendMsg_SendWithMetadata); - SB_UT_ADD_SUBTEST(Test_SendMsg_InvalidMsgId_ZeroCopy); SB_UT_ADD_SUBTEST(Test_SendMsg_MaxMsgSizePlusOne_ZeroCopy); SB_UT_ADD_SUBTEST(Test_SendMsg_NoSubscribers_ZeroCopy); } /* end Test_SendMsg_API */ @@ -2691,34 +2577,6 @@ void Test_SendMsg_NullPtr(void) } /* end Test_SendMsg_NullPtr */ -/* -** Test response to sending a message with an invalid ID -*/ -void Test_SendMsg_InvalidMsgId(void) -{ - SB_UT_Test_Tlm_t TlmPkt; - CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; - - CFE_SB_InitMsg(&TlmPkt, SB_UT_ALTERNATE_INVALID_MID, - sizeof(TlmPkt), true); - CFE_SB_SetMsgId(TlmPktPtr, CFE_SB_INVALID_MSG_ID); - - CCSDS_WR_APID(TlmPktPtr->Hdr, 0x7FF ); - -#ifdef MESSAGE_FORMAT_IS_CCSDS_VER_2 - - CCSDS_WR_SUBSYSTEM_ID(TlmPktPtr->SpacePacket.ApidQ, 0x7E ); - -#endif - - ASSERT_EQ(CFE_SB_SendMsg(TlmPktPtr), CFE_SB_BAD_ARGUMENT); - - EVTCNT(1); - - EVTSENT(CFE_SB_SEND_INV_MSGID_EID); - -} /* end Test_SendMsg_InvalidMsgId */ - /* ** Test response to sending a message which has no subscribers */ @@ -2784,24 +2642,26 @@ void Test_SendMsg_BasicSend(void) */ void Test_SendMsg_SequenceCount(void) { - CFE_SB_PipeId_t PipeId; - CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; - CFE_SB_MsgPtr_t PtrToMsg; - SB_UT_Test_Tlm_t TlmPkt; - CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; - uint32 PipeDepth = 10; + CFE_SB_PipeId_t PipeId; + CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; + CFE_SB_MsgPtr_t PtrToMsg; + SB_UT_Test_Tlm_t TlmPkt; + CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; + uint32 PipeDepth = 10; + CFE_MSG_SequenceCount_t SeqCnt; SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "SeqCntTestPipe")); CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), true); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); - CCSDS_WR_SEQ(TlmPktPtr->Hdr, 22); + CFE_MSG_SetSequenceCount(TlmPktPtr, 22); SETUP(CFE_SB_SendMsg(TlmPktPtr)); ASSERT(CFE_SB_RcvMsg(&PtrToMsg, PipeId, CFE_SB_PEND_FOREVER)); ASSERT_TRUE(PtrToMsg != NULL); - ASSERT_TRUE(CCSDS_RD_SEQ(PtrToMsg->Hdr) == 1); + CFE_MSG_GetSequenceCount(PtrToMsg, &SeqCnt); + ASSERT_EQ(SeqCnt, 1); ASSERT(CFE_SB_PassMsg(TlmPktPtr)); @@ -2809,7 +2669,8 @@ void Test_SendMsg_SequenceCount(void) ASSERT_TRUE(PtrToMsg != NULL); - ASSERT_TRUE(CCSDS_RD_SEQ(PtrToMsg->Hdr) == 22); + CFE_MSG_GetSequenceCount(PtrToMsg, &SeqCnt); + ASSERT_EQ(SeqCnt, 22); ASSERT(CFE_SB_SendMsg(TlmPktPtr)); @@ -2817,7 +2678,8 @@ void Test_SendMsg_SequenceCount(void) ASSERT_TRUE(PtrToMsg != NULL); - ASSERT_TRUE(CCSDS_RD_SEQ(PtrToMsg->Hdr) == 2); + CFE_MSG_GetSequenceCount(PtrToMsg, &SeqCnt); + ASSERT_EQ(SeqCnt, 2); EVTCNT(3); @@ -2833,7 +2695,8 @@ void Test_SendMsg_SequenceCount(void) SETUP(CFE_SB_RcvMsg(&PtrToMsg, PipeId, CFE_SB_PEND_FOREVER)); - ASSERT_EQ(CCSDS_RD_SEQ(PtrToMsg->Hdr), 4); + CFE_MSG_GetSequenceCount(PtrToMsg, &SeqCnt); + ASSERT_EQ(SeqCnt, 4); TEARDOWN(CFE_SB_DeletePipe(PipeId)); @@ -3020,6 +2883,7 @@ void Test_SendMsg_ZeroCopySend(void) CFE_SB_MsgPtr_t ZeroCpyMsgPtr = NULL; uint32 PipeDepth = 10; CFE_SB_ZeroCopyHandle_t ZeroCpyBufHndl = 0; + CFE_MSG_SequenceCount_t SeqCnt; SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "ZeroCpyTestPipe")); @@ -3033,7 +2897,7 @@ void Test_SendMsg_ZeroCopySend(void) else { CFE_SB_InitMsg(ZeroCpyMsgPtr, MsgId, sizeof(SB_UT_Test_Tlm_t), true); - CCSDS_WR_SEQ(ZeroCpyMsgPtr->Hdr, 22); + CFE_MSG_SetSequenceCount(ZeroCpyMsgPtr, 22); } /* Test response to a get pool information error */ @@ -3047,7 +2911,8 @@ void Test_SendMsg_ZeroCopySend(void) ASSERT_TRUE(PtrToMsg != NULL); - ASSERT_EQ(CCSDS_RD_SEQ(PtrToMsg->Hdr), 1); + CFE_MSG_GetSequenceCount(PtrToMsg, &SeqCnt); + ASSERT_EQ(SeqCnt, 1); EVTCNT(3); @@ -3069,7 +2934,8 @@ void Test_SendMsg_ZeroCopyPass(void) CFE_SB_MsgPtr_t ZeroCpyMsgPtr = NULL; uint32 PipeDepth = 10; CFE_SB_ZeroCopyHandle_t ZeroCpyBufHndl = 0; - uint16 Seq = 22; + CFE_MSG_SequenceCount_t ExpectedSeqCnt = 22; + CFE_MSG_SequenceCount_t ActualSeqCnt; SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "ZeroCpyPassTestPipe")); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); @@ -3084,7 +2950,7 @@ void Test_SendMsg_ZeroCopyPass(void) else { CFE_SB_InitMsg(ZeroCpyMsgPtr, MsgId, sizeof(SB_UT_Test_Tlm_t), true); - CCSDS_WR_SEQ(ZeroCpyMsgPtr->Hdr, Seq); + CFE_MSG_SetSequenceCount(ZeroCpyMsgPtr, ExpectedSeqCnt); } /* Test response to a get pool information error */ @@ -3105,8 +2971,8 @@ void Test_SendMsg_ZeroCopyPass(void) } else { - UtAssert_True(CCSDS_RD_SEQ(PtrToMsg->Hdr) == Seq, "sequence count for send in sequence count test, exp=%d, act=%d", - Seq, CCSDS_RD_SEQ(PtrToMsg->Hdr)); + CFE_MSG_GetSequenceCount(PtrToMsg, &ActualSeqCnt); + ASSERT_EQ(ExpectedSeqCnt, ActualSeqCnt); } EVTCNT(3); @@ -3235,36 +3101,6 @@ void Test_SendMsg_SendWithMetadata(void) } /* end Test_SendMsg_SendWithMetadata */ -/* -** Test response to sending a message with an invalid ID and ZeroCopy is set -*/ -void Test_SendMsg_InvalidMsgId_ZeroCopy(void) -{ - SB_UT_Test_Tlm_t TlmPkt; - CFE_SB_MsgPtr_t TlmPktPtr; - - TlmPktPtr = CFE_SB_ZeroCopyGetPtr(sizeof(SB_UT_Test_Tlm_t), - (CFE_SB_ZeroCopyHandle_t *) &TlmPkt); - - if (TlmPktPtr == NULL) - { - UtAssert_Failed("Unexpected NULL pointer returned from ZeroCopyGetPtr"); - } - else - { - CFE_SB_InitMsg(TlmPktPtr, SB_UT_ALTERNATE_INVALID_MID, - sizeof(SB_UT_Test_Tlm_t), true); - ASSERT_EQ(CFE_SB_SendMsgFull(TlmPktPtr, CFE_SB_INCREMENT_TLM, - CFE_SB_SEND_ZEROCOPY), CFE_SB_BAD_ARGUMENT); - - } - - EVTCNT(1); - - EVTSENT(CFE_SB_SEND_INV_MSGID_EID); - -} /* end Test_SendMsg_InvalidMsgId_ZeroCopy */ - /* ** Test response to sending a message with the message size larger than allowed ** and ZeroCopy is set @@ -3741,66 +3577,31 @@ void Test_CFE_SB_InitMsg_False(void) */ void Test_CFE_SB_MsgHdrSize_Cmd(void) { - CCSDS_PriHdr_t * PktPtr; SB_UT_Test_Cmd_t testCmd; - CFE_SB_MsgPtr_t MsgPtr; - - MsgPtr = (CFE_SB_MsgPtr_t)&testCmd; - PktPtr = (CCSDS_PriHdr_t*)MsgPtr; + CFE_SB_MsgPtr_t MsgPtr = (CFE_SB_MsgPtr_t)&testCmd; /* Test for cmds w/sec hdr */ - - CFE_SB_InitMsg(MsgPtr, - SB_UT_CMD_MID, - sizeof(testCmd), - 0); - - - /* Set this to Command Type */ - CCSDS_WR_TYPE(*PktPtr, 1); - /* No sec hdr */ - CCSDS_WR_SHDR(*PktPtr, 1); - + CFE_SB_InitMsg(MsgPtr, SB_UT_CMD_MID, sizeof(testCmd), true); ASSERT_EQ(CFE_SB_MsgHdrSize(MsgPtr), sizeof(CFE_SB_CmdHdr_t)); /* Test for cmds wo/sec hdr */ - - /* Set this to Command Type */ - CCSDS_WR_TYPE(*PktPtr, 1); - /* No sec hdr */ - CCSDS_WR_SHDR(*PktPtr, 0); - - ASSERT_EQ(CFE_SB_MsgHdrSize(MsgPtr), sizeof(CCSDS_PriHdr_t)); + CFE_MSG_SetHasSecondaryHeader(MsgPtr, false); + ASSERT_EQ(CFE_SB_MsgHdrSize(MsgPtr), sizeof(CCSDS_SpacePacket_t)); } /* end Test_CFE_SB_MsgHdrSize */ void Test_CFE_SB_MsgHdrSize_Tlm(void) { - CCSDS_PriHdr_t * PktPtr; SB_UT_Test_Tlm_t testTlm; - CFE_SB_MsgPtr_t MsgPtr; + CFE_SB_MsgPtr_t MsgPtr = (CFE_SB_MsgPtr_t)&testTlm; /* Test for tlm w/sec hdr */ - MsgPtr = (CFE_SB_MsgPtr_t)&testTlm; - PktPtr = (CCSDS_PriHdr_t*)MsgPtr; - - CFE_SB_SetMsgId(MsgPtr, SB_UT_TLM_MID); - - /* Set this to Tlm Type */ - CCSDS_WR_TYPE(*PktPtr, 0); - CCSDS_WR_SHDR(*PktPtr, 1); - + CFE_SB_InitMsg(MsgPtr, SB_UT_TLM_MID, sizeof(testTlm), true); ASSERT_EQ(CFE_SB_MsgHdrSize(MsgPtr), sizeof(CFE_SB_TlmHdr_t)); - /* Test for tlm wo/sec hdr */ - CFE_SB_SetMsgId(MsgPtr, SB_UT_TLM_MID); - - /* Set this to Telemetry Type */ - CCSDS_WR_TYPE(*PktPtr, 0); - CCSDS_WR_SHDR(*PktPtr, 0); - - ASSERT_EQ(CFE_SB_MsgHdrSize(MsgPtr), sizeof(CCSDS_PriHdr_t)); + CFE_MSG_SetHasSecondaryHeader(MsgPtr, false); + ASSERT_EQ(CFE_SB_MsgHdrSize(MsgPtr), sizeof(CCSDS_SpacePacket_t)); } /* end Test_CFE_SB_MsgHdrSize_Tlm */ @@ -3831,19 +3632,20 @@ void Test_CFE_SB_GetUserData_Cmd(void) void Test_CFE_SB_GetUserData_CmdNoSecHdr(void) { SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt; - CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t) &SBNoSecHdrPkt; + CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t)&SBNoSecHdrPkt; uint8 *ActualAdrReturned; uint8 *ExpAdrReturned; /* Test address returned for cmd pkts wo/sec hdr */ - CFE_SB_SetMsgId(SBNoSecHdrPktPtr, SB_UT_CMD_MID); - CCSDS_WR_SHDR(*(CCSDS_PriHdr_t*)SBNoSecHdrPktPtr, 0); + CFE_SB_InitMsg(SBNoSecHdrPktPtr, SB_UT_CMD_MID, sizeof(SBNoSecHdrPkt), true); + CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); + ActualAdrReturned = CFE_SB_GetUserData(SBNoSecHdrPktPtr); - ExpAdrReturned = (uint8 *) SBNoSecHdrPktPtr + 6; + ExpAdrReturned = (uint8 *) SBNoSecHdrPktPtr + sizeof(CCSDS_SpacePacket_t); UtAssert_True(ActualAdrReturned == ExpAdrReturned, "Address of data for commands without secondary header is " - "packet address + 6\n PktAddr %p, Rtn %p, Exp %p", + "packet address + CCSDS header(s)\n PktAddr %p, Rtn %p, Exp %p", (void *) SBNoSecHdrPktPtr, ActualAdrReturned, ExpAdrReturned); } /* end Test_CFE_SB_GetUserData */ @@ -3876,10 +3678,11 @@ void Test_CFE_SB_GetUserData_TlmNoSecHdr(void) uint8 *ExpAdrReturned; /* Test address returned for tlm pkts wo/sec hdr */ - CFE_SB_SetMsgId(SBNoSecHdrPktPtr, SB_UT_TLM_MID); - CCSDS_WR_SHDR(*(CCSDS_PriHdr_t*)SBNoSecHdrPktPtr, 0); + CFE_SB_InitMsg(SBNoSecHdrPktPtr, SB_UT_TLM_MID, sizeof(SBNoSecHdrPkt), true); + CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); + ActualAdrReturned = CFE_SB_GetUserData(SBNoSecHdrPktPtr); - ExpAdrReturned = (uint8 *) SBNoSecHdrPktPtr + sizeof(CCSDS_PriHdr_t); + ExpAdrReturned = (uint8 *) SBNoSecHdrPktPtr + sizeof(CCSDS_SpacePacket_t); UtAssert_True(ActualAdrReturned == ExpAdrReturned, "Address of data for telemetry packets without secondary " @@ -3897,7 +3700,8 @@ void Test_CFE_SB_SetGetMsgId(void) CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; CFE_SB_MsgId_t MsgIdReturned; CFE_SB_MsgId_t MsgIdSet; - uint32 i; + uint16 Value[] = {0, 0x700, 0x7FF /* Max */, 0x800 /* Invalid */, 0xFFFF /* Invalid */}; + int i; /* Test setting and getting the message ID of a message */ @@ -3917,21 +3721,70 @@ void Test_CFE_SB_SetGetMsgId(void) * all values */ - /* Looping through every value from 0 to 0xffff */ - for (i = 0; i <= 0xFFFF; i++) + /* Looping through values */ + for (i = 0; i < sizeof(Value)/sizeof(Value[0]); i++) { - MsgIdSet = CFE_SB_ValueToMsgId(i); + MsgIdSet = CFE_SB_ValueToMsgId(Value[i]); CFE_SB_SetMsgId(SBCmdPtr, MsgIdSet); MsgIdReturned = CFE_SB_GetMsgId(SBCmdPtr); - if (!CFE_SB_MsgId_Equal(MsgIdReturned, MsgIdSet)) + if (Value[i] < 0x800) { - break; + ASSERT_TRUE(CFE_SB_MsgId_Equal(MsgIdReturned, MsgIdSet)); } } } /* end Test_CFE_SB_SetGetMsgId */ +/* Local helper function for user data length tests */ +/* Runs standard tests given an initialized message */ +void Util_CFE_SB_SetGetUserDataLength(CFE_SB_Msg_t *MsgPtr, uint16 SecHdrSize) +{ + uint16 SetSize[] = {0, 1, 0x8000, 0 /* Max calculated */, 0xFFFF}; + uint16 SizeReturned; + uint16 ActualPktLenField; + uint16 ExpPktLenField; + int i; + bool checkrtn; + + /* Max valid value */ + if (SecHdrSize == 0) + { + SetSize[3] = 0xFFFF; + } + else + { + SetSize[3] = 0xFFFF - SecHdrSize + 1; + } + + for (i = 0; i < sizeof(SetSize)/sizeof(SetSize[0]); i++) + { + /* CCSDS requires >= 1 byte payload, less won't update size */ + /* Over max possible also won't update size */ + if ((SecHdrSize + SetSize[i] < 1) || (SetSize[i] + SecHdrSize > 0x10000)) + { + ExpPktLenField = UT_GetActualPktLenField(MsgPtr); + checkrtn = false; + } + else + { + ExpPktLenField = SecHdrSize + SetSize[i] - 1; + checkrtn = true; + } + + CFE_SB_SetUserDataLength(MsgPtr, SetSize[i]); + SizeReturned = CFE_SB_GetUserDataLength(MsgPtr); + ActualPktLenField = UT_GetActualPktLenField(MsgPtr); + + if (checkrtn) + { + ASSERT_EQ (SizeReturned, SetSize[i]); + } + ASSERT_EQ (ActualPktLenField, ExpPktLenField); + } + +} /* end Util_CFE_SB_SetGetUserDataLength */ + /* ** Test setting and getting the user data size of a message */ @@ -3939,55 +3792,25 @@ void Test_CFE_SB_SetGetUserDataLength_Cmd(void) { SB_UT_Test_Cmd_t SBCmd; CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - int32 SetSize; - uint16 SizeReturned; - int16 ActualPktLenField; - int16 ExpPktLenField; - - /* CCSDS pkt length field = SecHdrSize + data - 1 */ - /* Loop through all pkt length values for cmd pkts w/sec hdr */ + /* Init cmd pkt w/ sec hdr */ CFE_SB_InitMsg(SBCmdPtr, SB_UT_CMD_MID, sizeof(SB_UT_Test_Cmd_t), true); - for (SetSize = 0; SetSize < 0x10000; SetSize++) - { - CFE_SB_SetUserDataLength(SBCmdPtr, SetSize); - SizeReturned = CFE_SB_GetUserDataLength(SBCmdPtr); - ActualPktLenField = UT_GetActualPktLenField(SBCmdPtr); - - ExpPktLenField = sizeof(CFE_SB_CmdHdr_t) + SetSize - sizeof(CCSDS_PriHdr_t) - 1; /* SecHdrSize + data - 1 */ - - ASSERT_EQ (SizeReturned, SetSize); - ASSERT_EQ (ActualPktLenField, ExpPktLenField); - } + /* Calculation for secondary header accounts for possible padding */ + Util_CFE_SB_SetGetUserDataLength(SBCmdPtr, sizeof(CFE_SB_CmdHdr_t) - sizeof(CCSDS_PrimaryHeader_t)); } /* end Test_CFE_SB_SetGetUserDataLength */ void Test_CFE_SB_SetGetUserDataLength_CmdNoSecHdr(void) { - SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt; + SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt = {0}; CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t) &SBNoSecHdrPkt; - int32 SetSize; - uint16 SizeReturned; - int16 ActualPktLenField; - int16 ExpPktLenField; - /* Loop through all pkt length values for cmd pkts wo/sec hdr */ - memset(&SBNoSecHdrPkt, 0, sizeof(SBNoSecHdrPktPtr)); - CFE_SB_SetMsgId(SBNoSecHdrPktPtr, SB_UT_CMD_MID); - CCSDS_WR_SHDR(*(CCSDS_PriHdr_t*)SBNoSecHdrPktPtr, 0); - - for (SetSize = 0; SetSize < 0x10000; SetSize++) - { - CFE_SB_SetUserDataLength(SBNoSecHdrPktPtr, SetSize); - SizeReturned = CFE_SB_GetUserDataLength(SBNoSecHdrPktPtr); - ActualPktLenField = UT_GetActualPktLenField(SBNoSecHdrPktPtr); - ExpPktLenField = 0 + SetSize - 1; /* SecHdrSize + data - 1 */ - - ASSERT_EQ (SizeReturned, SetSize); - ASSERT_EQ (ActualPktLenField, ExpPktLenField); - } + /* Init cmd pkt w/o sec hdr */ + CFE_SB_InitMsg(SBNoSecHdrPktPtr, SB_UT_CMD_MID, sizeof(SBNoSecHdrPkt), true); + CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); + Util_CFE_SB_SetGetUserDataLength(SBNoSecHdrPktPtr, sizeof(CCSDS_SpacePacket_t) - sizeof(CCSDS_PrimaryHeader_t)); } /* end Test_CFE_SB_SetGetUserDataLength */ @@ -3995,25 +3818,12 @@ void Test_CFE_SB_SetGetUserDataLength_Tlm(void) { SB_UT_Test_Tlm_t SBTlm; CFE_SB_MsgPtr_t SBTlmPtr = (CFE_SB_MsgPtr_t) &SBTlm; - int32 SetSize; - uint16 SizeReturned; - int16 ActualPktLenField; - int16 ExpPktLenField; - /* Loop through all pkt length values for tlm pkts w/sec hdr */ + /* Init tlm pkts w/ sec hdr */ CFE_SB_InitMsg(SBTlmPtr, SB_UT_TLM_MID, sizeof(SB_UT_Test_Tlm_t), true); - for (SetSize = 0; SetSize < 0x10000; SetSize++) - { - CFE_SB_SetUserDataLength(SBTlmPtr, SetSize); - SizeReturned = CFE_SB_GetUserDataLength(SBTlmPtr); - ActualPktLenField = UT_GetActualPktLenField(SBTlmPtr); - - ExpPktLenField = sizeof(CCSDS_TelemetryPacket_t) + SetSize - sizeof(CCSDS_PriHdr_t) - 1; /* SecHdrSize + data - 1 */ - - ASSERT_EQ (SizeReturned, SetSize); - ASSERT_EQ (ActualPktLenField, ExpPktLenField); - } + /* Calculation for secondary header accounts for possible padding */ + Util_CFE_SB_SetGetUserDataLength(SBTlmPtr, sizeof(CFE_SB_TlmHdr_t) - sizeof(CCSDS_PrimaryHeader_t)); } /* end Test_CFE_SB_SetGetUserDataLength */ @@ -4021,27 +3831,12 @@ void Test_CFE_SB_SetGetUserDataLength_TlmNoSecHdr(void) { SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt; CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t) &SBNoSecHdrPkt; - int32 SetSize; - uint16 SizeReturned; - int16 ActualPktLenField; - int16 ExpPktLenField; - - /* Loop through all pkt length values for tlm pkts wo/sec hdr */ - memset(&SBNoSecHdrPkt, 0, sizeof(SBNoSecHdrPktPtr)); - CFE_SB_SetMsgId(SBNoSecHdrPktPtr, SB_UT_TLM_MID); - - CCSDS_WR_SHDR(*(CCSDS_PriHdr_t*)SBNoSecHdrPktPtr, 0); - for (SetSize = 0; SetSize < 0x10000; SetSize++) - { - CFE_SB_SetUserDataLength(SBNoSecHdrPktPtr, SetSize); - SizeReturned = CFE_SB_GetUserDataLength(SBNoSecHdrPktPtr); - ActualPktLenField = UT_GetActualPktLenField(SBNoSecHdrPktPtr); - ExpPktLenField = 0 + SetSize - 1; /* SecHdrSize + data - 1 */ + /* Set up tlm pkts wo/sec hdr */ + CFE_SB_InitMsg(SBNoSecHdrPktPtr, SB_UT_TLM_MID, sizeof(SBNoSecHdrPkt), true); + CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); - ASSERT_EQ (SizeReturned, SetSize); - ASSERT_EQ (ActualPktLenField, ExpPktLenField); - } + Util_CFE_SB_SetGetUserDataLength(SBNoSecHdrPktPtr, sizeof(CCSDS_SpacePacket_t) - sizeof(CCSDS_PrimaryHeader_t)); } /* end Test_CFE_SB_SetGetUserDataLength */ @@ -4050,29 +3845,38 @@ void Test_CFE_SB_SetGetUserDataLength_TlmNoSecHdr(void) */ void Test_CFE_SB_SetGetTotalMsgLength(void) { - SB_UT_Test_Cmd_t SBCmd; - CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - int32 SetSize; - uint16 TotalMsgSizeReturned; - int16 ActualPktLenField; - int16 ExpPktLenField; + SB_UT_Test_Cmd_t SBCmd; + CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - /* CCSDS pkt length field = TotalPktSize - 7 */ + /* Known bug CFE_SB_GetTotalMsgLength won't do max CCSDS size */ + uint32 SetSize[] = {0 /* Invalid */, 1 /* Invalid */, 7 /* Min */, 8000, 0xFFFF}; + uint16 TotalMsgSizeReturned; + uint16 ActualPktLenField; + uint16 ExpPktLenField; + int i; /* * Note this is no different for commands vs. telemetry vs. secondary header... * This consolidates all the separate test cases - testing for different header types is redundant. */ - CFE_SB_SetMsgId(SBCmdPtr, SB_UT_CMD_MID); + CFE_SB_InitMsg(SBCmdPtr, SB_UT_CMD_MID, sizeof(SBCmd), true); - for (SetSize = 0; SetSize < 0x10000; SetSize++) + for (i = 0; i < sizeof(SetSize)/sizeof(SetSize[0]); i++) { - CFE_SB_SetTotalMsgLength(SBCmdPtr, SetSize); + if (SetSize[i] < 7) /* Invalid size won't change packet value */ + { + ExpPktLenField = UT_GetActualPktLenField(SBCmdPtr); + } + else + { + ExpPktLenField = SetSize[i] - 7; /* TotalPktSize - 7 */ + } + + CFE_SB_SetTotalMsgLength(SBCmdPtr, SetSize[i]); TotalMsgSizeReturned = CFE_SB_GetTotalMsgLength(SBCmdPtr); ActualPktLenField = UT_GetActualPktLenField(SBCmdPtr); - ExpPktLenField = SetSize - 7; /* TotalPktSize - 7 */ - ASSERT_EQ (TotalMsgSizeReturned, SetSize); + ASSERT_EQ (TotalMsgSizeReturned, ExpPktLenField + 7); ASSERT_EQ (ActualPktLenField, ExpPktLenField); } @@ -4120,8 +3924,7 @@ void Test_CFE_SB_SetGetMsgTime_CmdNoSecHdr(void) /* Set MsgId */ CFE_SB_SetMsgId(SBNoSecHdrPktPtr, SB_UT_TLM_MID); - CCSDS_WR_SHDR(*(CCSDS_PriHdr_t*)SBNoSecHdrPktPtr, 0); - + CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); SetTime.Seconds = 0x4321; SetTime.Subseconds = 0x8765; @@ -4180,7 +3983,7 @@ void Test_CFE_SB_SetGetMsgTime_TlmNoSecHdr(void) /* Set MsgId to 0x0005 */ CFE_SB_SetMsgId(SBNoSecHdrPktPtr, SB_UT_TLM_MID); - CCSDS_WR_SHDR(*((CCSDS_PriHdr_t*)SBNoSecHdrPktPtr), 0); + CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); SetTime.Seconds = 0x01234567; SetTime.Subseconds = 0x89abcdef; ASSERT_EQ(CFE_SB_SetMsgTime(SBNoSecHdrPktPtr, SetTime), CFE_SB_WRONG_MSG_TYPE); @@ -4239,38 +4042,35 @@ void Test_CFE_SB_TimeStampMsg(void) */ void Test_CFE_SB_SetGetCmdCode_Cmd(void) { - SB_UT_Test_Cmd_t SBCmd; - CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - uint16 CmdCodeSet; - uint16 ExpCmdCode; - CCSDS_PriHdr_t *PktPtr; - - /* Loop through all cmd code values(plus a few invalid) for cmd - * pkts w/sec hdr - */ + SB_UT_Test_Cmd_t SBCmd; + CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; + uint16 CmdCodeSet[] = {0, 1, 0x70, 0x7f /* Max */, 0x80 /* Invalid */, 0xFFFF /* Invalid */}; + uint16 ExpCmdCode; + int i; /* Set MsgId to all f's */ memset(SBCmdPtr, 0xff, sizeof(SBCmd)); + CFE_SB_InitMsg(SBCmdPtr, SB_UT_CMD_MID, sizeof(SB_UT_Test_Cmd_t), false); + CFE_MSG_SetHasSecondaryHeader(SBCmdPtr, true); - CFE_SB_InitMsg(SBCmdPtr, SB_UT_CMD_MID, sizeof(SB_UT_Test_Cmd_t), true); - - PktPtr = (CCSDS_PriHdr_t*)SBCmdPtr; - - CCSDS_WR_SHDR(*PktPtr,1); - - for (CmdCodeSet = 0; CmdCodeSet < 0x100; CmdCodeSet++) + for (i = 0; i < sizeof(CmdCodeSet)/sizeof(CmdCodeSet[0]); i++) { - ASSERT_EQ(CFE_SB_SetCmdCode(SBCmdPtr, CmdCodeSet), CFE_SUCCESS); - - /* GSFC CmdCode is the 7 LSBs of the 1st byte of cmd sec hdr */ - ExpCmdCode = CmdCodeSet & 0x007f; - - ASSERT_EQ(CFE_SB_GetCmdCode(SBCmdPtr), ExpCmdCode); - ASSERT_EQ(UT_GetActualCmdCodeField(SBCmdPtr), ExpCmdCode); + if (CmdCodeSet[i] <= 0x7f) /* Valid */ + { + ASSERT_EQ(CFE_SB_SetCmdCode(SBCmdPtr, CmdCodeSet[i]), CFE_SUCCESS); + ASSERT_EQ(CFE_SB_GetCmdCode(SBCmdPtr), CmdCodeSet[i]); + ASSERT_EQ(UT_GetActualCmdCodeField(SBCmdPtr), CmdCodeSet[i]); + } + else /* Invalid */ + { + /* When invalid command code shouldn't change */ + ExpCmdCode = UT_GetActualCmdCodeField(SBCmdPtr); + ASSERT_EQ(CFE_SB_SetCmdCode(SBCmdPtr, CmdCodeSet[i]), CFE_SB_BAD_ARGUMENT); + ASSERT_EQ(CFE_SB_GetCmdCode(SBCmdPtr), ExpCmdCode); + ASSERT_EQ(UT_GetActualCmdCodeField(SBCmdPtr), ExpCmdCode); + } } - - } /* end Test_CFE_SB_SetGetCmdCode */ void Test_CFE_SB_SetGetCmdCode_NonCmd(void) @@ -4279,7 +4079,6 @@ void Test_CFE_SB_SetGetCmdCode_NonCmd(void) CFE_SB_MsgPtr_t SBTlmPtr = (CFE_SB_MsgPtr_t) &SBTlm; SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt; CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t) &SBNoSecHdrPkt; - CCSDS_PriHdr_t *PktPtr; /* Loop through all cmd code values (plus a few invalid) for cmd * pkts wo/sec hdr @@ -4291,16 +4090,14 @@ void Test_CFE_SB_SetGetCmdCode_NonCmd(void) /* Set MsgId */ CFE_SB_SetMsgId(SBNoSecHdrPktPtr, SB_UT_CMD_MID); - PktPtr = (CCSDS_PriHdr_t*)SBNoSecHdrPktPtr; - CCSDS_WR_SHDR(*PktPtr,0); + CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); ASSERT_EQ(CFE_SB_SetCmdCode(SBNoSecHdrPktPtr, 11), CFE_SB_WRONG_MSG_TYPE); ASSERT_EQ(CFE_SB_GetCmdCode(SBNoSecHdrPktPtr), 0); CFE_SB_SetMsgId(SBTlmPtr, SB_UT_TLM_MID); - PktPtr = (CCSDS_PriHdr_t*)SBTlmPtr; - CCSDS_WR_SHDR(*PktPtr,1); + CFE_SB_SetMsgId(SBTlmPtr, true); ASSERT_EQ(CFE_SB_SetCmdCode(SBTlmPtr, 22), CFE_SB_WRONG_MSG_TYPE); ASSERT_EQ(CFE_SB_GetCmdCode(SBTlmPtr), 0); @@ -4326,7 +4123,7 @@ void Test_CFE_SB_ChecksumUtils_Cmd(void) #ifndef MESSAGE_FORMAT_IS_CCSDS_VER_2 ExpRtnFrmGet = 0x2f; #else - ExpRtnFrmGet = 0x65; + ExpRtnFrmGet = 0x5D; #endif ASSERT_EQ(CFE_SB_GetChecksum(SBCmdPtr), ExpRtnFrmGet); @@ -4353,8 +4150,7 @@ void Test_CFE_SB_ChecksumUtils_CmdNoSecHdr(void) CFE_SB_InitMsg(SBNoSecHdrPktPtr, SB_UT_BARE_CMD_MID3, sizeof(SBNoSecHdrPkt), true); - - CCSDS_WR_SHDR( SBNoSecHdrPktPtr->Hdr, 0 ); + CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); /* Set checksum field */ CFE_SB_GenerateChecksum(SBNoSecHdrPktPtr); @@ -4368,7 +4164,7 @@ void Test_CFE_SB_ChecksumUtils_CmdNoSecHdr(void) */ SBNoSecHdrPktPtr->Byte[0] ^= 0x02; - CCSDS_WR_SHDR( SBNoSecHdrPktPtr->Hdr, 0 ); + CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); ASSERT_TRUE(!CFE_SB_ValidateChecksum(SBNoSecHdrPktPtr)); } /* end Test_CFE_SB_ChecksumUtils */ diff --git a/fsw/cfe-core/unit-test/ut_support.c b/fsw/cfe-core/unit-test/ut_support.c index 19c208306..7daac8d34 100644 --- a/fsw/cfe-core/unit-test/ut_support.c +++ b/fsw/cfe-core/unit-test/ut_support.c @@ -472,7 +472,7 @@ void UT_DisplayPkt(CFE_SB_MsgPtr_t ptr, uint32 size) */ int16 UT_GetActualPktLenField(CFE_SB_MsgPtr_t MsgPtr) { - return ( ( MsgPtr->Hdr.Length[0] << 8) + MsgPtr->Hdr.Length[1] ); + return ( ( MsgPtr->CCSDS.Pri.Length[0] << 8) + MsgPtr->CCSDS.Pri.Length[1] ); } /* diff --git a/fsw/cfe-core/ut-stubs/ut_sb_stubs.c b/fsw/cfe-core/ut-stubs/ut_sb_stubs.c index 304d835c8..bfa2bdf89 100644 --- a/fsw/cfe-core/ut-stubs/ut_sb_stubs.c +++ b/fsw/cfe-core/ut-stubs/ut_sb_stubs.c @@ -928,7 +928,7 @@ void *CFE_SB_GetUserData(CFE_SB_MsgPtr_t MsgPtr) if (UT_Stub_CopyToLocal(UT_KEY(CFE_SB_GetUserData), &Result, sizeof(Result)) != sizeof(Result)) { BytePtr = (uint8 *)MsgPtr; - if (CCSDS_RD_TYPE(MsgPtr->Hdr) != CCSDS_TLM) + if ((MsgPtr->Byte[0] & 0x10) != 0) { HdrSize = CFE_SB_CMD_HDR_SIZE; } From 164c75e3e1c67175f1df43611e7cdd22b1a4746e Mon Sep 17 00:00:00 2001 From: Jacob Hageman Date: Fri, 14 Aug 2020 10:53:52 -0400 Subject: [PATCH 4/9] Fix #711, Add msg module unit test --- modules/msg/unit-test-coverage/CMakeLists.txt | 63 +++ modules/msg/unit-test-coverage/msg_UT.c | 55 ++ .../test_cfe_msg_ccsdsext.c | 424 ++++++++++++++++ .../test_cfe_msg_ccsdsext.h | 37 ++ .../test_cfe_msg_ccsdspri.c | 469 ++++++++++++++++++ .../test_cfe_msg_ccsdspri.h | 39 ++ .../test_cfe_msg_checksum.c | 90 ++++ .../test_cfe_msg_checksum.h | 33 ++ .../msg/unit-test-coverage/test_cfe_msg_fc.c | 105 ++++ .../msg/unit-test-coverage/test_cfe_msg_fc.h | 33 ++ .../unit-test-coverage/test_cfe_msg_init.c | 147 ++++++ .../unit-test-coverage/test_cfe_msg_init.h | 37 ++ .../unit-test-coverage/test_cfe_msg_msgid.h | 33 ++ .../test_cfe_msg_msgid_shared.c | 79 +++ .../test_cfe_msg_msgid_shared.h | 33 ++ .../test_cfe_msg_msgid_v1.c | 104 ++++ .../test_cfe_msg_msgid_v2.c | 116 +++++ .../unit-test-coverage/test_cfe_msg_time.c | 98 ++++ .../unit-test-coverage/test_cfe_msg_time.h | 33 ++ .../msg/unit-test-coverage/test_msg_ext_not.c | 85 ++++ modules/msg/unit-test-coverage/test_msg_not.c | 55 ++ modules/msg/unit-test-coverage/test_msg_not.h | 67 +++ .../msg/unit-test-coverage/test_msg_pri_not.c | 102 ++++ .../msg/unit-test-coverage/test_msg_prionly.c | 42 ++ .../msg/unit-test-coverage/test_msg_utils.c | 72 +++ .../msg/unit-test-coverage/test_msg_utils.h | 45 ++ 26 files changed, 2496 insertions(+) create mode 100644 modules/msg/unit-test-coverage/CMakeLists.txt create mode 100644 modules/msg/unit-test-coverage/msg_UT.c create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_ccsdsext.c create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_ccsdsext.h 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_checksum.c create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_checksum.h create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_fc.c create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_fc.h create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_init.c create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_init.h create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_msgid.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_v1.c 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_time.c create mode 100644 modules/msg/unit-test-coverage/test_cfe_msg_time.h create mode 100644 modules/msg/unit-test-coverage/test_msg_ext_not.c 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_pri_not.c create mode 100644 modules/msg/unit-test-coverage/test_msg_prionly.c 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/unit-test-coverage/CMakeLists.txt b/modules/msg/unit-test-coverage/CMakeLists.txt new file mode 100644 index 000000000..5449769c4 --- /dev/null +++ b/modules/msg/unit-test-coverage/CMakeLists.txt @@ -0,0 +1,63 @@ +################################################################## +# +# cFE unit test build recipe +# +# This CMake file contains the recipe for building the cFE unit tests. +# It is invoked from the parent directory when unit tests are enabled. +# +################################################################## + +# Unit test object library sources, options, and includes +add_library(ut_${DEP}_objs OBJECT ${${DEP}_SRC}) +target_compile_options(ut_${DEP}_objs PRIVATE ${UT_COVERAGE_COMPILE_FLAGS}) +target_include_directories(ut_${DEP}_objs PRIVATE + $) + +set (ut_${DEP}_tests + msg_UT.c + test_msg_utils.c + test_msg_not.c + test_msg_pri_not.c + test_cfe_msg_init.c + test_cfe_msg_ccsdspri.c + test_cfe_msg_msgid_shared.c + test_cfe_msg_checksum.c + test_cfe_msg_fc.c + test_cfe_msg_time.c + $) + +# Add extended header tests if appropriate +if (MISSION_INCLUDE_CCSDSEXT_HEADER) + list(APPEND ut_${DEP}_tests + test_msg_ext_not.c + test_cfe_msg_ccsdsext.c) +else (MISSION_INCLUDE_CCSDSEXT_HEADER) + list(APPEND ut_${DEP}_tests + test_msg_prionly.c) +endif (MISSION_INCLUDE_CCSDSEXT_HEADER) + +# Add the correct message id test +if (MISSION_MSGID_V2) + list(APPEND ut_${DEP}_tests + test_cfe_msg_msgid_v2.c) +else (MISSION_MSGID_V2) + list(APPEND ut_${DEP}_tests + test_cfe_msg_msgid_v1.c) +endif (MISSION_MSGID_V2) + +# Add executable +add_executable(${DEP}_UT ${ut_${DEP}_tests}) + +# Add include to get private defaults +target_include_directories(${DEP}_UT PRIVATE ../private_inc) + +# Also add the UT_COVERAGE_LINK_FLAGS to the link command +# This should enable coverage analysis on platforms that support this +target_link_libraries(${DEP}_UT + ${UT_COVERAGE_LINK_FLAGS} + ut_cfe-core_support + ut_cfe-core_stubs + ut_assert) + +add_test(${DEP}_UT ${DEP}_UT) +install(TARGETS ${DEP}_UT DESTINATION ${TGTNAME}/${UT_INSTALL_SUBDIR}) diff --git a/modules/msg/unit-test-coverage/msg_UT.c b/modules/msg/unit-test-coverage/msg_UT.c new file mode 100644 index 000000000..3b0359276 --- /dev/null +++ b/modules/msg/unit-test-coverage/msg_UT.c @@ -0,0 +1,55 @@ +/* +** 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 unit tests + */ + +/* + * Includes + */ +#include "utassert.h" +#include "ut_support.h" +#include "test_cfe_msg_init.h" +#include "test_cfe_msg_ccsdspri.h" +#include "test_cfe_msg_ccsdsext.h" +#include "test_cfe_msg_msgid_shared.h" +#include "test_cfe_msg_msgid.h" +#include "test_cfe_msg_fc.h" +#include "test_cfe_msg_checksum.h" +#include "test_cfe_msg_time.h" + +/* + * Functions + */ +void UtTest_Setup(void) +{ + UT_Init("msg"); + UT_Text("Message header coverage test..."); + + UT_ADD_TEST(Test_MSG_Init); + UT_ADD_TEST(Test_MSG_CCSDSPri); + UT_ADD_TEST(Test_MSG_CCSDSExt); + UT_ADD_TEST(Test_MSG_MsgId_Shared); + UT_ADD_TEST(Test_MSG_MsgId); + UT_ADD_TEST(Test_MSG_Checksum); + UT_ADD_TEST(Test_MSG_FcnCode); + UT_ADD_TEST(Test_MSG_Time); +} diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_ccsdsext.c b/modules/msg/unit-test-coverage/test_cfe_msg_ccsdsext.c new file mode 100644 index 000000000..63b897f26 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_ccsdsext.c @@ -0,0 +1,424 @@ +/* +** 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 Extended 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_ccsdsext.h" +#include "cfe_error.h" +#include "cfe_mission_cfg.h" +#include "cfe_platform_cfg.h" +#include "cfe_msg_defaults.h" +#include + +/* + * Defines + */ +#define TEST_EDSVER_MAX 0x1F /* Maximum value for EDS Version field */ +#define TEST_SUBSYS_MAX 0x1FF /* Maximum value for Subsystem field */ +#define TEST_SYSTEM_MAX 0xFFFF /* Maximum value for System field */ + +#define TEST_DEFAULT_SUBSYS_MASK 0x100 /* Bits that can be set by default subsys if msgid V2 */ + +/* Extended header initialization specific coverage */ +void Test_MSG_Init_Ext(void) +{ + CFE_MSG_Message_t msg; + CFE_SB_MsgId_Atom_t msgidval_exp; + CFE_MSG_HeaderVersion_t hdrver; + CFE_MSG_Subsystem_t subsys; + CFE_MSG_EDSVersion_t edsver; + CFE_MSG_System_t system; + CFE_MSG_Endian_t endian; + bool is_v1; + + /* Get msgid version by checking if msgid sets header version */ + memset(&msg, 0xFF, sizeof(msg)); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0)), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetHeaderVersion(&msg, &hdrver), CFE_SUCCESS); + is_v1 = (hdrver == 0); + + UT_Text("Set to all F's, msgid value = 0, and run with clearing"); + memset(&msg, 0xFF, sizeof(msg)); + msgidval_exp = 0; + ASSERT_EQ(CFE_MSG_Init(&msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(msg), true), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, 0); + + /* Default EDS version check */ + ASSERT_EQ(CFE_MSG_GetEDSVersion(&msg, &edsver), CFE_SUCCESS); + ASSERT_EQ(edsver, CFE_PLATFORM_EDSVER); + + /* Default subsystem check */ + ASSERT_EQ(CFE_MSG_GetSubsystem(&msg, &subsys), CFE_SUCCESS); + if (is_v1) + ASSERT_EQ(subsys, CFE_PLATFORM_DEFAULT_SUBSYS); + else + ASSERT_EQ(subsys, CFE_PLATFORM_DEFAULT_SUBSYS & TEST_DEFAULT_SUBSYS_MASK); + + /* Default system check */ + ASSERT_EQ(CFE_MSG_GetSystem(&msg, &system), CFE_SUCCESS); + ASSERT_EQ(system, CFE_MISSION_SPACECRAFT_ID); + + /* Default endian check */ + ASSERT_EQ(CFE_MSG_GetEndian(&msg, &endian), CFE_SUCCESS); +#if (CFE_PLATFORM_ENDIAN == CCSDS_LITTLE_ENDIAN) + ASSERT_EQ(endian, CFE_MSG_Endian_Little); +#else + ASSERT_EQ(endian, CFE_MSG_Endian_Big); +#endif + + /* Confirm the rest of the fields not already explicitly checked */ + ASSERT_EQ(Test_MSG_Ext_NotZero(&msg) & ~(MSG_EDSVER_FLAG | MSG_ENDIAN_FLAG | MSG_SUBSYS_FLAG | MSG_SYSTEM_FLAG), 0); + + UT_Text("Set to all 0, max msgid value, and run without clearing"); + memset(&msg, 0, sizeof(msg)); + msgidval_exp = CFE_PLATFORM_SB_HIGHEST_VALID_MSGID; + ASSERT_EQ(CFE_MSG_Init(&msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(msg), false), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, 0); + + /* Default subsystem check */ + ASSERT_EQ(CFE_MSG_GetSubsystem(&msg, &subsys), CFE_SUCCESS); + if (is_v1) + ASSERT_EQ(subsys, 0); + else + ASSERT_EQ(subsys, 0xFF); + + /* Confirm the rest of the fields not already explicitly checked */ + ASSERT_EQ(Test_MSG_Ext_NotZero(&msg) & ~MSG_SUBSYS_FLAG, 0); +} + +void Test_MSG_EDSVersion(void) +{ + CFE_MSG_Message_t msg; + CFE_MSG_EDSVersion_t input[] = {0, TEST_EDSVER_MAX / 2, TEST_EDSVER_MAX}; + CFE_MSG_EDSVersion_t actual = TEST_EDSVER_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_GetEDSVersion(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, TEST_EDSVER_MAX); + ASSERT_EQ(CFE_MSG_GetEDSVersion(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetEDSVersion(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetEDSVersion(&msg, TEST_EDSVER_MAX + 1), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetEDSVersion(&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_GetEDSVersion(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, TEST_EDSVER_MAX); + ASSERT_EQ(CFE_MSG_SetEDSVersion(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetEDSVersion(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == TEST_EDSVER_MAX) + { + ASSERT_EQ(Test_MSG_NotF(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_EDSVER_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_GetEDSVersion(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_SetEDSVersion(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetEDSVersion(&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_EDSVER_FLAG); + } + } +} + +void Test_MSG_Endian(void) +{ + CFE_MSG_Message_t msg; + CFE_MSG_Endian_t input[] = {CFE_MSG_Endian_Big, CFE_MSG_Endian_Little}; + CFE_MSG_Endian_t actual = 0; + int i; + + UT_Text("Bad parameter tests, Null pointers and invalid (CFE_MSG_Endian_Invalid, CFE_MSG_Endian_Little + 1"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetEndian(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_GetEndian(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetEndian(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetEndian(&msg, CFE_MSG_Endian_Invalid), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetEndian(&msg, CFE_MSG_Endian_Little + 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_GetEndian(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, CFE_MSG_Endian_Little); + ASSERT_EQ(CFE_MSG_SetEndian(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetEndian(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == CFE_MSG_Endian_Little) + { + ASSERT_EQ(Test_MSG_NotF(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_ENDIAN_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_GetEndian(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, CFE_MSG_Endian_Big); + ASSERT_EQ(CFE_MSG_SetEndian(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetEndian(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == CFE_MSG_Endian_Big) + { + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_ENDIAN_FLAG); + } + } +} + +void Test_MSG_PlaybackFlag(void) +{ + CFE_MSG_Message_t msg; + CFE_MSG_PlaybackFlag_t input[] = {CFE_MSG_PlayFlag_Original, CFE_MSG_PlayFlag_Playback}; + CFE_MSG_PlaybackFlag_t actual = 0; + int i; + + UT_Text("Bad parameter tests, Null pointers and invalid (CFE_MSG_PlayFlag_Invalid, CFE_MSG_PlayFlag_Playback + 1"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetPlaybackFlag(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_GetPlaybackFlag(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetPlaybackFlag(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetPlaybackFlag(&msg, CFE_MSG_PlayFlag_Invalid), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetPlaybackFlag(&msg, CFE_MSG_PlayFlag_Playback + 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_GetPlaybackFlag(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, CFE_MSG_PlayFlag_Playback); + ASSERT_EQ(CFE_MSG_SetPlaybackFlag(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetPlaybackFlag(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == CFE_MSG_PlayFlag_Playback) + { + ASSERT_EQ(Test_MSG_NotF(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_PBACK_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_GetPlaybackFlag(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, CFE_MSG_PlayFlag_Original); + ASSERT_EQ(CFE_MSG_SetPlaybackFlag(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetPlaybackFlag(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == CFE_MSG_PlayFlag_Original) + { + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_PBACK_FLAG); + } + } +} + +void Test_MSG_Subsystem(void) +{ + CFE_MSG_Message_t msg; + CFE_MSG_Subsystem_t input[] = {0, TEST_SUBSYS_MAX / 2, TEST_SUBSYS_MAX}; + CFE_MSG_Subsystem_t actual = TEST_SUBSYS_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_GetSubsystem(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, TEST_SUBSYS_MAX); + ASSERT_EQ(CFE_MSG_GetSubsystem(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetSubsystem(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetSubsystem(&msg, TEST_SUBSYS_MAX + 1), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetSubsystem(&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_GetSubsystem(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, TEST_SUBSYS_MAX); + ASSERT_EQ(CFE_MSG_SetSubsystem(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSubsystem(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == TEST_SUBSYS_MAX) + { + ASSERT_EQ(Test_MSG_NotF(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_SUBSYS_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_GetSubsystem(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_SetSubsystem(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSubsystem(&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_SUBSYS_FLAG); + } + } +} + +void Test_MSG_System(void) +{ + CFE_MSG_Message_t msg; + CFE_MSG_ApId_t input[] = {0, TEST_SYSTEM_MAX / 2, TEST_SYSTEM_MAX}; + CFE_MSG_ApId_t actual = TEST_SYSTEM_MAX; + int i; + + UT_Text("Bad parameter tests, Null pointers"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSystem(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, TEST_SYSTEM_MAX); + ASSERT_EQ(CFE_MSG_GetSystem(&msg, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + ASSERT_EQ(CFE_MSG_SetSystem(NULL, input[0]), 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_GetSystem(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, TEST_SYSTEM_MAX); + ASSERT_EQ(CFE_MSG_SetSystem(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSystem(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + if (input[i] == TEST_SYSTEM_MAX) + { + ASSERT_EQ(Test_MSG_NotF(&msg), 0); + } + else + { + ASSERT_EQ(Test_MSG_NotF(&msg), MSG_SYSTEM_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_GetSystem(&msg, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_SetSystem(&msg, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSystem(&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_SYSTEM_FLAG); + } + } +} + +/* + * Test MSG ccsdsext + */ +void Test_MSG_CCSDSExt(void) +{ + MSG_UT_ADD_SUBTEST(Test_MSG_Init_Ext); + MSG_UT_ADD_SUBTEST(Test_MSG_EDSVersion); + MSG_UT_ADD_SUBTEST(Test_MSG_Endian); + MSG_UT_ADD_SUBTEST(Test_MSG_PlaybackFlag); + MSG_UT_ADD_SUBTEST(Test_MSG_Subsystem); + MSG_UT_ADD_SUBTEST(Test_MSG_System); +} diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_ccsdsext.h b/modules/msg/unit-test-coverage/test_cfe_msg_ccsdsext.h new file mode 100644 index 000000000..d1c416432 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_ccsdsext.h @@ -0,0 +1,37 @@ +/* +** 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_ccsdsext test header + */ +#ifndef test_cfe_msg_ccsdsext_ +#define test_cfe_msg_ccsdsext_ + +/* + * Defines + */ + +/* + * Functions + */ +/* Test CCSDS Extended header accessor functions */ +void Test_MSG_CCSDSExt(void); + +#endif /* test_cfe_msg_ccsdsext_ */ 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..104c2955c --- /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_checksum.c b/modules/msg/unit-test-coverage/test_cfe_msg_checksum.c new file mode 100644 index 000000000..5b3b433c5 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_checksum.c @@ -0,0 +1,90 @@ +/* +** 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 checksum accessors + */ + +/* + * Includes + */ +#include "utassert.h" +#include "ut_support.h" +#include "test_msg_not.h" +#include "test_msg_utils.h" +#include "cfe_msg_api.h" +#include "test_cfe_msg_checksum.h" +#include "cfe_error.h" +#include + +void Test_MSG_Checksum(void) +{ + CFE_SB_CmdHdr_t cmd; + CFE_MSG_Message_t *msgptr = (CFE_MSG_Message_t *)&cmd; + bool actual; + + UT_Text("Bad parameter tests, Null pointers"); + memset(&cmd, 0, sizeof(cmd)); + actual = true; + ASSERT_EQ(CFE_MSG_GenerateChecksum(NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_ValidateChecksum(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, true); + ASSERT_EQ(CFE_MSG_ValidateChecksum(msgptr, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(msgptr), 0); + + UT_Text("Bad message, no secondary header"); + ASSERT_EQ(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); + ASSERT_EQ(actual, true); + ASSERT_EQ(CFE_MSG_GenerateChecksum(msgptr), CFE_MSG_WRONG_MSG_TYPE); + ASSERT_EQ(Test_MSG_NotZero(msgptr), MSG_TYPE_FLAG); + + UT_Text("Bad message, wrong type (telemetry)"); + ASSERT_EQ(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Tlm), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_SetHasSecondaryHeader(msgptr, true), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); + ASSERT_EQ(actual, true); + ASSERT_EQ(CFE_MSG_GenerateChecksum(msgptr), CFE_MSG_WRONG_MSG_TYPE); + ASSERT_EQ(Test_MSG_NotZero(msgptr), MSG_HASSEC_FLAG); + + UT_Text("Set to all F's, validate/generate/validate"); + memset(&cmd, 0xFF, sizeof(cmd)); + ASSERT_EQ(CFE_MSG_SetSize(msgptr, sizeof(cmd)), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, false); + ASSERT_EQ(CFE_MSG_GenerateChecksum(msgptr), CFE_SUCCESS); + Test_MSG_PrintMsg(msgptr, sizeof(cmd)); + ASSERT_EQ(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, true); + ASSERT_EQ(Test_MSG_NotF(msgptr), MSG_LENGTH_FLAG); + + UT_Text("Set to all 0 except secheader and type, validate/generate/validate"); + memset(&cmd, 0, sizeof(cmd)); + ASSERT_EQ(CFE_MSG_SetSize(msgptr, sizeof(cmd)), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_SetHasSecondaryHeader(msgptr, true), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, false); + ASSERT_EQ(CFE_MSG_GenerateChecksum(msgptr), CFE_SUCCESS); + Test_MSG_PrintMsg(msgptr, sizeof(cmd)); + ASSERT_EQ(CFE_MSG_ValidateChecksum(msgptr, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, true); + ASSERT_EQ(Test_MSG_NotZero(msgptr), MSG_LENGTH_FLAG | MSG_HASSEC_FLAG | MSG_TYPE_FLAG); +} diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_checksum.h b/modules/msg/unit-test-coverage/test_cfe_msg_checksum.h new file mode 100644 index 000000000..5b521fe7f --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_checksum.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_checksum test header + */ +#ifndef test_cfe_msg_checksum_ +#define test_cfe_msg_checksum_ + +/* + * Functions + */ +/* Test checksum accessor functions */ +void Test_MSG_Checksum(void); + +#endif /* test_cfe_msg_checksum_ */ diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_fc.c b/modules/msg/unit-test-coverage/test_cfe_msg_fc.c new file mode 100644 index 000000000..062a1d908 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_fc.c @@ -0,0 +1,105 @@ +/* +** 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 function code accessors + */ + +/* + * Includes + */ +#include "utassert.h" +#include "ut_support.h" +#include "test_msg_not.h" +#include "test_msg_utils.h" +#include "cfe_msg_api.h" +#include "test_cfe_msg_fc.h" +#include "cfe_error.h" +#include + +/* + * Defines + */ +#define TEST_FCNCODE_MAX 0x7F /* Maximum value for fc field */ + +void Test_MSG_FcnCode(void) +{ + CFE_SB_CmdHdr_t cmd; + CFE_MSG_Message_t *msgptr = (CFE_MSG_Message_t *)&cmd; + CFE_MSG_FcnCode_t input[] = {0, TEST_FCNCODE_MAX / 2, TEST_FCNCODE_MAX}; + CFE_MSG_FcnCode_t actual = TEST_FCNCODE_MAX; + int i; + + UT_Text("Bad parameter tests, Null pointers, invalid (max valid + 1, max)"); + memset(&cmd, 0, sizeof(cmd)); + ASSERT_EQ(CFE_MSG_GetFcnCode(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual, TEST_FCNCODE_MAX); + ASSERT_EQ(CFE_MSG_GetFcnCode(msgptr, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(msgptr), 0); + ASSERT_EQ(CFE_MSG_SetFcnCode(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetFcnCode(msgptr, TEST_FCNCODE_MAX + 1), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(msgptr), 0); + ASSERT_EQ(CFE_MSG_SetFcnCode(msgptr, 0xFFFF), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(msgptr), 0); + + UT_Text("Bad message, no secondary header"); + ASSERT_EQ(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_SetFcnCode(msgptr, 0), CFE_MSG_WRONG_MSG_TYPE); + ASSERT_EQ(Test_MSG_NotZero(msgptr), MSG_TYPE_FLAG); + + UT_Text("Bad message, wrong type (telemetry)"); + memset(&cmd, 0, sizeof(cmd)); + actual = TEST_FCNCODE_MAX; + ASSERT_EQ(CFE_MSG_SetHasSecondaryHeader(msgptr, true), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_SetFcnCode(msgptr, 0), CFE_MSG_WRONG_MSG_TYPE); + ASSERT_EQ(Test_MSG_NotZero(msgptr), MSG_HASSEC_FLAG); + + UT_Text("Set to all F's, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&cmd, 0xFF, sizeof(cmd)); + ASSERT_EQ(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, TEST_FCNCODE_MAX); + ASSERT_EQ(CFE_MSG_SetFcnCode(msgptr, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(msgptr, sizeof(cmd)); + ASSERT_EQ(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + ASSERT_EQ(Test_MSG_NotF(msgptr), 0); + } + + UT_Text("Set to all 0, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&cmd, 0, sizeof(cmd)); + ASSERT_EQ(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_SetHasSecondaryHeader(msgptr, true), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, 0); + ASSERT_EQ(CFE_MSG_SetFcnCode(msgptr, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(msgptr, sizeof(cmd)); + ASSERT_EQ(CFE_MSG_GetFcnCode(msgptr, &actual), CFE_SUCCESS); + ASSERT_EQ(actual, input[i]); + ASSERT_EQ(Test_MSG_NotZero(msgptr), MSG_HASSEC_FLAG | MSG_TYPE_FLAG); + } +} diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_fc.h b/modules/msg/unit-test-coverage/test_cfe_msg_fc.h new file mode 100644 index 000000000..1dbff0fca --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_fc.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_fc test header + */ +#ifndef test_cfe_msg_fc_ +#define test_cfe_msg_fc_ + +/* + * Functions + */ +/* Test function code accessor functions */ +void Test_MSG_FcnCode(void); + +#endif /* test_cfe_msg_fc_ */ diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_init.c b/modules/msg/unit-test-coverage/test_cfe_msg_init.c new file mode 100644 index 000000000..d49924493 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_init.c @@ -0,0 +1,147 @@ +/* +** 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 message init + */ + +/* + * Includes + */ +#include "utassert.h" +#include "ut_support.h" +#include "test_msg_not.h" +#include "test_msg_utils.h" +#include "cfe_msg_api.h" +#include "test_cfe_msg_init.h" +#include "cfe_error.h" +#include "cfe_msg_defaults.h" +#include + +#define TEST_DEFAULT_APID_MASK 0x780 /* Bits that can be set by default apid if msgid V2 */ + +/* + * Test MSG Init + */ +void Test_MSG_Init(void) +{ + + CFE_MSG_Message_t msg; + CFE_MSG_Size_t size; + CFE_SB_MsgId_Atom_t msgidval_exp; + CFE_SB_MsgId_t msgid_act; + CFE_MSG_HeaderVersion_t hdrver; + CFE_MSG_ApId_t apid; + CFE_MSG_SegmentationFlag_t segflag; + unsigned int flag_exp; + bool hassec; + bool is_v1; + + UT_Text("Bad parameter tests, Null pointer, invalid size, invalid msgid"); + memset(&msg, 0, sizeof(msg)); + ASSERT_EQ(CFE_MSG_Init(NULL, CFE_SB_ValueToMsgId(0), sizeof(msg), false), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_Init(&msg, CFE_SB_ValueToMsgId(0), 0, false), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_Init(&msg, CFE_SB_ValueToMsgId(CFE_PLATFORM_SB_HIGHEST_VALID_MSGID + 1), sizeof(msg), false), + CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_Init(&msg, CFE_SB_ValueToMsgId(-1), sizeof(msg), false), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(&msg), 0); + + UT_Text("Set to all F's, msgid value = 0, and run without clearing"); + memset(&msg, 0xFF, sizeof(msg)); + msgidval_exp = 0; + ASSERT_EQ(CFE_MSG_Init(&msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(msg), false), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, 0); + + /* Get msgid version by checking if header version was set */ + ASSERT_EQ(CFE_MSG_GetHeaderVersion(&msg, &hdrver), CFE_SUCCESS); + is_v1 = (hdrver == 0); + + flag_exp = MSG_TYPE_FLAG | MSG_LENGTH_FLAG | MSG_APID_FLAG; + if (is_v1) + flag_exp |= MSG_HDRVER_FLAG | MSG_HASSEC_FLAG; + + ASSERT_EQ(Test_MSG_Pri_NotF(&msg), flag_exp); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid_act), CFE_SUCCESS); + ASSERT_EQ(CFE_SB_MsgIdToValue(msgid_act), msgidval_exp); + ASSERT_EQ(CFE_MSG_GetSize(&msg, &size), CFE_SUCCESS); + ASSERT_EQ(size, sizeof(msg)); + + UT_Text("Set to all F's, msgid value = 0, and run with clearing"); + memset(&msg, 0xFF, sizeof(msg)); + msgidval_exp = 0; + + ASSERT_EQ(CFE_MSG_Init(&msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(msg), true), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, 0); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid_act), CFE_SUCCESS); + ASSERT_EQ(CFE_SB_MsgIdToValue(msgid_act), msgidval_exp); + ASSERT_EQ(CFE_MSG_GetSize(&msg, &size), CFE_SUCCESS); + ASSERT_EQ(size, sizeof(msg)); + ASSERT_EQ(CFE_MSG_GetSegmentationFlag(&msg, &segflag), CFE_SUCCESS); + ASSERT_EQ(segflag, CFE_MSG_SegFlag_Unsegmented); + + ASSERT_EQ(CFE_MSG_GetApId(&msg, &apid), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetHeaderVersion(&msg, &hdrver), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetHasSecondaryHeader(&msg, &hassec), CFE_SUCCESS); + if (!is_v1) + { + ASSERT_EQ(apid, CFE_PLATFORM_DEFAULT_APID & TEST_DEFAULT_APID_MASK); + ASSERT_EQ(hdrver, CFE_MISSION_CCSDSVER); + ASSERT_EQ(hassec, true); + } + else + { + ASSERT_EQ(apid, 0); + ASSERT_EQ(hdrver, 0); + ASSERT_EQ(hassec, false); + } + + /* Confirm the rest of the fields not already explicitly checked */ + ASSERT_EQ(Test_MSG_Pri_NotZero(&msg) & ~(MSG_APID_FLAG | MSG_HDRVER_FLAG | MSG_HASSEC_FLAG), + MSG_LENGTH_FLAG | MSG_SEGMENT_FLAG); + + UT_Text("Set to all 0, max msgid value, and run without clearing"); + memset(&msg, 0, sizeof(msg)); + msgidval_exp = CFE_PLATFORM_SB_HIGHEST_VALID_MSGID; + ASSERT_EQ(CFE_MSG_Init(&msg, CFE_SB_ValueToMsgId(msgidval_exp), sizeof(msg), false), CFE_SUCCESS); + Test_MSG_PrintMsg(&msg, 0); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid_act), CFE_SUCCESS); + ASSERT_EQ(CFE_SB_MsgIdToValue(msgid_act), msgidval_exp); + ASSERT_EQ(CFE_MSG_GetSize(&msg, &size), CFE_SUCCESS); + ASSERT_EQ(size, sizeof(msg)); + + ASSERT_EQ(CFE_MSG_GetApId(&msg, &apid), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetHasSecondaryHeader(&msg, &hassec), CFE_SUCCESS); + if (!is_v1) + { + ASSERT_EQ(apid & TEST_DEFAULT_APID_MASK, CFE_PLATFORM_DEFAULT_APID & TEST_DEFAULT_APID_MASK); + ASSERT_EQ(hassec, false); + } + else + { + ASSERT_EQ(apid, 0x7FF); + ASSERT_EQ(hassec, true); + } + + ASSERT_EQ(Test_MSG_Pri_NotZero(&msg) & ~(MSG_APID_FLAG | MSG_HASSEC_FLAG), MSG_TYPE_FLAG | MSG_LENGTH_FLAG); + + /* Zero (no default) header version check */ + ASSERT_EQ(CFE_MSG_GetHeaderVersion(&msg, &hdrver), CFE_SUCCESS); + ASSERT_EQ(hdrver, 0); +} diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_init.h b/modules/msg/unit-test-coverage/test_cfe_msg_init.h new file mode 100644 index 000000000..0ee75f86c --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_init.h @@ -0,0 +1,37 @@ +/* +** 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_init test header + */ +#ifndef test_cfe_msg_init_ +#define test_cfe_msg_init_ + +/* + * Includes + */ + +/* + * Functions + */ +/* Test extended header mission functionality */ +void Test_MSG_Init(void); + +#endif /* test_cfe_msg_init_ */ diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_msgid.h b/modules/msg/unit-test-coverage/test_cfe_msg_msgid.h new file mode 100644 index 000000000..8a3a467e9 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_msgid.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_ +#define test_cfe_msg_msgid_ + +/* + * Functions + */ +/* Test msgid accessor functions */ +void Test_MSG_MsgId(void); + +#endif /* test_cfe_msg_msgid_ */ 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..4cec04552 --- /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_v1.c b/modules/msg/unit-test-coverage/test_cfe_msg_msgid_v1.c new file mode 100644 index 000000000..f0e51a2aa --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_msgid_v1.c @@ -0,0 +1,104 @@ +/* +** 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 V1 accessors + */ + +#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.h" +#include "cfe_error.h" +#include + +#define TEST_MAX_APID 0x7FF + +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; + bool hassec; + + 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, 0xFFFF), 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_HDRVER_FLAG | MSG_APID_FLAG | MSG_TYPE_FLAG | MSG_HASSEC_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 | MSG_HASSEC_FLAG); + ASSERT_EQ(CFE_MSG_GetApId(&msg, &apid), CFE_SUCCESS); + ASSERT_EQ(apid, TEST_MAX_APID); + ASSERT_EQ(CFE_MSG_GetType(&msg, &type), CFE_SUCCESS); + ASSERT_EQ(type, CFE_MSG_Type_Cmd); + ASSERT_EQ(CFE_MSG_GetHasSecondaryHeader(&msg, &hassec), CFE_SUCCESS); + ASSERT_EQ(hassec, true); + + UT_Text("Set ApId msgid bits only and verify"); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(TEST_MAX_APID)), 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, TEST_MAX_APID); + + UT_Text("Set has secondary header bit only and verify"); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0x0800)), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetMsgId(&msg, &msgid), CFE_SUCCESS); + ASSERT_EQ(Test_MSG_NotZero(&msg), MSG_HASSEC_FLAG); + ASSERT_EQ(CFE_MSG_GetHasSecondaryHeader(&msg, &hassec), CFE_SUCCESS); + ASSERT_EQ(hassec, true); + + UT_Text("Set type msgid bit only and verify"); + ASSERT_EQ(CFE_MSG_SetMsgId(&msg, CFE_SB_ValueToMsgId(0x1000)), 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); +} 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..cca35be7a --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_msgid_v2.c @@ -0,0 +1,116 @@ +/* +** 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.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); + } +} diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_time.c b/modules/msg/unit-test-coverage/test_cfe_msg_time.c new file mode 100644 index 000000000..6e6977d52 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_time.c @@ -0,0 +1,98 @@ +/* +** 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 time accessors + */ + +/* + * Includes + */ +#include "utassert.h" +#include "ut_support.h" +#include "test_msg_not.h" +#include "test_msg_utils.h" +#include "cfe_msg_api.h" +#include "test_cfe_msg_time.h" +#include "cfe_error.h" +#include + +void Test_MSG_Time(void) +{ + CFE_SB_TlmHdr_t tlm; + CFE_MSG_Message_t *msgptr = (CFE_MSG_Message_t *)&tlm; + CFE_TIME_SysTime_t input[] = {{0, 0}, {0x12345678, 0xABCDEF12}, {0xFFFFFFFF, 0xFFFFFFFF}}; + CFE_TIME_SysTime_t actual = {0xFFFFFFFF, 0xFFFFFFFF}; + int i; + + UT_Text("Bad parameter tests, Null pointers, no secondary header"); + memset(&tlm, 0, sizeof(tlm)); + ASSERT_EQ(CFE_MSG_GetMsgTime(NULL, &actual), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(actual.Seconds, 0xFFFFFFFF); + ASSERT_EQ(actual.Subseconds, 0xFFFFFFFF); + ASSERT_EQ(CFE_MSG_GetMsgTime(msgptr, NULL), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(Test_MSG_NotZero(msgptr), 0); + ASSERT_EQ(CFE_MSG_SetMsgTime(NULL, input[0]), CFE_MSG_BAD_ARGUMENT); + ASSERT_EQ(CFE_MSG_SetMsgTime(msgptr, actual), CFE_MSG_WRONG_MSG_TYPE); + ASSERT_EQ(Test_MSG_NotZero(msgptr), 0); + ASSERT_EQ(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); + ASSERT_EQ(actual.Seconds, 0); + ASSERT_EQ(actual.Subseconds, 0); + + UT_Text("Bad message, wrong type (command)"); + ASSERT_EQ(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Cmd), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_SetMsgTime(msgptr, actual), CFE_MSG_WRONG_MSG_TYPE); + ASSERT_EQ(Test_MSG_NotZero(msgptr), MSG_TYPE_FLAG); + ASSERT_EQ(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_MSG_WRONG_MSG_TYPE); + ASSERT_EQ(actual.Seconds, 0); + ASSERT_EQ(actual.Subseconds, 0); + + UT_Text("Set to all F's, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&tlm, 0xFF, sizeof(tlm)); + ASSERT_EQ(CFE_MSG_SetType(msgptr, CFE_MSG_Type_Tlm), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_SUCCESS); + ASSERT_EQ(actual.Seconds, 0xFFFFFFFF); + ASSERT_EQ(actual.Subseconds, 0xFFFF0000); + ASSERT_EQ(CFE_MSG_SetMsgTime(msgptr, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(msgptr, sizeof(tlm)); + ASSERT_EQ(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_SUCCESS); + ASSERT_EQ(actual.Seconds, input[i].Seconds); + ASSERT_EQ(actual.Subseconds, input[i].Subseconds & 0xFFFF0000); + ASSERT_EQ(Test_MSG_NotF(msgptr), MSG_TYPE_FLAG); + } + + UT_Text("Set to all 0, various valid inputs"); + for (i = 0; i < sizeof(input) / sizeof(input[0]); i++) + { + memset(&tlm, 0, sizeof(tlm)); + ASSERT_EQ(CFE_MSG_SetHasSecondaryHeader(msgptr, true), CFE_SUCCESS); + ASSERT_EQ(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_SUCCESS); + ASSERT_EQ(actual.Seconds, 0); + ASSERT_EQ(actual.Subseconds, 0); + ASSERT_EQ(CFE_MSG_SetMsgTime(msgptr, input[i]), CFE_SUCCESS); + Test_MSG_PrintMsg(msgptr, sizeof(tlm)); + ASSERT_EQ(CFE_MSG_GetMsgTime(msgptr, &actual), CFE_SUCCESS); + ASSERT_EQ(actual.Seconds, input[i].Seconds); + ASSERT_EQ(actual.Subseconds, input[i].Subseconds & 0xFFFF0000); + ASSERT_EQ(Test_MSG_NotZero(msgptr), MSG_HASSEC_FLAG); + } +} diff --git a/modules/msg/unit-test-coverage/test_cfe_msg_time.h b/modules/msg/unit-test-coverage/test_cfe_msg_time.h new file mode 100644 index 000000000..2981d8ee5 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_cfe_msg_time.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_time test header + */ +#ifndef test_cfe_msg_time_ +#define test_cfe_msg_time_ + +/* + * Functions + */ +/* Test time accessor functions */ +void Test_MSG_Time(void); + +#endif /* test_cfe_msg_time_ */ diff --git a/modules/msg/unit-test-coverage/test_msg_ext_not.c b/modules/msg/unit-test-coverage/test_msg_ext_not.c new file mode 100644 index 000000000..d764bfabd --- /dev/null +++ b/modules/msg/unit-test-coverage/test_msg_ext_not.c @@ -0,0 +1,85 @@ +/* +** 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. +*/ + +/* + * Extended message header field not Zero or F + */ + +/* + * Includes + */ +#include "cfe_msg_api.h" +#include "test_msg_not.h" + +unsigned int Test_MSG_Ext_NotZero(const CFE_MSG_Message_t *MsgPtr) +{ + unsigned int bits = 0; + CFE_MSG_EDSVersion_t edsver; + CFE_MSG_Endian_t endian; + CFE_MSG_PlaybackFlag_t playflag; + CFE_MSG_Subsystem_t subsystem; + CFE_MSG_System_t system; + + CFE_MSG_GetEDSVersion(MsgPtr, &edsver); + if (edsver != 0) + bits |= MSG_EDSVER_FLAG; + CFE_MSG_GetEndian(MsgPtr, &endian); + if (endian != CFE_MSG_Endian_Big) + bits |= MSG_ENDIAN_FLAG; + CFE_MSG_GetPlaybackFlag(MsgPtr, &playflag); + if (playflag != CFE_MSG_PlayFlag_Original) + bits |= MSG_PBACK_FLAG; + CFE_MSG_GetSubsystem(MsgPtr, &subsystem); + if (subsystem != 0) + bits |= MSG_SUBSYS_FLAG; + CFE_MSG_GetSystem(MsgPtr, &system); + if (system != 0) + bits |= MSG_SYSTEM_FLAG; + + return bits; +} + +unsigned int Test_MSG_Ext_NotF(const CFE_MSG_Message_t *MsgPtr) +{ + unsigned int bits = 0; + CFE_MSG_EDSVersion_t edsver; + CFE_MSG_Endian_t endian; + CFE_MSG_PlaybackFlag_t playflag; + CFE_MSG_Subsystem_t subsystem; + CFE_MSG_System_t system; + + CFE_MSG_GetEDSVersion(MsgPtr, &edsver); + if (edsver != 0x1F) + bits |= MSG_EDSVER_FLAG; + CFE_MSG_GetEndian(MsgPtr, &endian); + if (endian != CFE_MSG_Endian_Little) + bits |= MSG_ENDIAN_FLAG; + CFE_MSG_GetPlaybackFlag(MsgPtr, &playflag); + if (playflag != CFE_MSG_PlayFlag_Playback) + bits |= MSG_PBACK_FLAG; + CFE_MSG_GetSubsystem(MsgPtr, &subsystem); + if (subsystem != 0x1FF) + bits |= MSG_SUBSYS_FLAG; + CFE_MSG_GetSystem(MsgPtr, &system); + if (system != 0xFFFF) + bits |= MSG_SYSTEM_FLAG; + + return bits; +} 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..8d7d60e86 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_msg_not.c @@ -0,0 +1,55 @@ +/* +** 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 "cfe_msg_api.h" +#include "test_msg_not.h" + +unsigned int Test_MSG_NotZero(const CFE_MSG_Message_t *MsgPtr) +{ + unsigned int bits = 0; + + /* Primary */ + bits |= Test_MSG_Pri_NotZero(MsgPtr); + + /* Extended */ + bits |= Test_MSG_Ext_NotZero(MsgPtr); + + return bits; +} + +unsigned int Test_MSG_NotF(const CFE_MSG_Message_t *MsgPtr) +{ + unsigned int bits = 0; + + /* Primary */ + bits |= Test_MSG_Pri_NotF(MsgPtr); + + /* Extended */ + bits |= Test_MSG_Ext_NotF(MsgPtr); + + 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..10bb706ba --- /dev/null +++ b/modules/msg/unit-test-coverage/test_msg_not.h @@ -0,0 +1,67 @@ +/* +** 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); +unsigned int Test_MSG_Pri_NotZero(const CFE_MSG_Message_t *MsgPtr); +unsigned int Test_MSG_Ext_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); +unsigned int Test_MSG_Pri_NotF(const CFE_MSG_Message_t *MsgPtr); +unsigned int Test_MSG_Ext_NotF(const CFE_MSG_Message_t *MsgPtr); + +#endif /* test_msg_not_ */ diff --git a/modules/msg/unit-test-coverage/test_msg_pri_not.c b/modules/msg/unit-test-coverage/test_msg_pri_not.c new file mode 100644 index 000000000..3f35cf3b0 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_msg_pri_not.c @@ -0,0 +1,102 @@ +/* +** 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. +*/ + +/* + * Primary message header field not Zero or F + */ + +/* + * Includes + */ +#include "test_cfe_msg_ccsdspri.h" /* For TEST_MSG_SIZE_OFFSET */ +#include "cfe_msg_api.h" +#include "test_msg_not.h" + +unsigned int Test_MSG_Pri_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_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; + + return bits; +} + +unsigned int Test_MSG_Pri_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_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; + + return bits; +} diff --git a/modules/msg/unit-test-coverage/test_msg_prionly.c b/modules/msg/unit-test-coverage/test_msg_prionly.c new file mode 100644 index 000000000..6df77d970 --- /dev/null +++ b/modules/msg/unit-test-coverage/test_msg_prionly.c @@ -0,0 +1,42 @@ +/* +** 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. +*/ + +/* + * Extended header stubbed out, use when no extended header is defined + */ + +/* + * Includes + */ +#include "cfe_msg_api.h" +#include "test_msg_not.h" +#include "test_cfe_msg_ccsdsext.h" + +unsigned int Test_MSG_Ext_NotZero(const CFE_MSG_Message_t *MsgPtr) +{ + return 0; +} + +unsigned int Test_MSG_Ext_NotF(const CFE_MSG_Message_t *MsgPtr) +{ + return 0; +} + +void Test_MSG_CCSDSExt(void) {} 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..1b715076e --- /dev/null +++ b/modules/msg/unit-test-coverage/test_msg_utils.c @@ -0,0 +1,72 @@ +/* +** 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" +#include "utassert.h" + +void Test_MSG_PrintMsg(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Size_t Size) +{ + + int i; + char sbuf[121] = {0}; + char wbuf[6] = {0}; + + if (Size == 0) + { + CFE_MSG_GetSize(MsgPtr, &Size); + } + + for (i = 0; i < Size / 2; i++) + { + sprintf(wbuf, "%02X%02X ", MsgPtr->Byte[i * 2], MsgPtr->Byte[(i * 2) + 1]); + strcat(sbuf, wbuf); + + /* Make sure string buffer doesn't overflow */ + if (sizeof(sbuf) < (strlen(sbuf) + 6)) + break; + } + + UtAssert_Message(UTASSERT_CASETYPE_INFO, __FILE__, __LINE__, "Message: %s", sbuf); +} + +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_ */ From 1582beb29ed9ae3a8d9bcebdec0ba1d8207430a9 Mon Sep 17 00:00:00 2001 From: Jacob Hageman Date: Wed, 12 Aug 2020 13:02:28 -0400 Subject: [PATCH 5/9] Fix #795, Remove legacy time header format support --- cmake/sample_defs/sample_mission_cfg.h | 24 --- fsw/cfe-core/src/sb/cfe_sb_verify.h | 9 +- modules/msg/CMakeLists.txt | 2 +- .../msg/mission_inc/default_cfe_msg_sechdr.h | 18 +-- modules/msg/src/cfe_msg_sechdr_time_old.c | 137 ------------------ 5 files changed, 5 insertions(+), 185 deletions(-) delete mode 100644 modules/msg/src/cfe_msg_sechdr_time_old.c diff --git a/cmake/sample_defs/sample_mission_cfg.h b/cmake/sample_defs/sample_mission_cfg.h index 6043ecb32..e736261ef 100644 --- a/cmake/sample_defs/sample_mission_cfg.h +++ b/cmake/sample_defs/sample_mission_cfg.h @@ -67,26 +67,6 @@ #undef MESSAGE_FORMAT_IS_CCSDS_VER_2 - -/** \name Packet timestamp format identifiers */ -/** \{ */ -#define CFE_MISSION_SB_TIME_32_16_SUBS 1 /**< \brief 32 bits seconds + 16 bits subseconds (units = 2^^-16) */ -#define CFE_MISSION_SB_TIME_32_32_SUBS 2 /**< \brief 32 bits seconds + 32 bits subseconds (units = 2^^-32) */ -#define CFE_MISSION_SB_TIME_32_32_M_20 3 /**< \brief 32 bits seconds + 20 bits microsecs + 12 bits reserved */ -/** \} */ - -/** -** \cfemissioncfg Packet Timestamp Format Selection -** -** \par Description: -** Defines the size, format and contents of the telemetry packet timestamp. -** -** \par Limits -** Must be defined as one of the supported formats listed above -*/ -#define CFE_MISSION_SB_PACKET_TIME_FORMAT CFE_MISSION_SB_TIME_32_16_SUBS - - /** ** \cfesbcfg Maximum SB Message Size ** @@ -699,10 +679,6 @@ #ifndef CFE_OMIT_DEPRECATED_6_6 #define CFE_SPACECRAFT_ID CFE_MISSION_SPACECRAFT_ID -#define CFE_SB_TIME_32_16_SUBS CFE_MISSION_SB_TIME_32_16_SUBS -#define CFE_SB_TIME_32_32_SUBS CFE_MISSION_SB_TIME_32_32_SUBS -#define CFE_SB_TIME_32_32_M_20 CFE_MISSION_SB_TIME_32_32_M_20 -#define CFE_SB_PACKET_TIME_FORMAT CFE_MISSION_SB_PACKET_TIME_FORMAT #define CFE_SB_MAX_SB_MSG_SIZE CFE_MISSION_SB_MAX_SB_MSG_SIZE #define CFE_TIME_CFG_DEFAULT_TAI CFE_MISSION_TIME_CFG_DEFAULT_TAI #define CFE_TIME_CFG_DEFAULT_UTC CFE_MISSION_TIME_CFG_DEFAULT_UTC diff --git a/fsw/cfe-core/src/sb/cfe_sb_verify.h b/fsw/cfe-core/src/sb/cfe_sb_verify.h index 311e8f6ba..3b4c3c23f 100644 --- a/fsw/cfe-core/src/sb/cfe_sb_verify.h +++ b/fsw/cfe-core/src/sb/cfe_sb_verify.h @@ -80,12 +80,9 @@ #error CFE_PLATFORM_SB_BUF_MEMORY_BYTES cannot be greater than UINT32_MAX (4 Gigabytes)! #endif -#ifndef CFE_MISSION_SB_PACKET_TIME_FORMAT - #error CFE_MISSION_SB_PACKET_TIME_FORMAT must be defined! -#elif ((CFE_MISSION_SB_PACKET_TIME_FORMAT != CFE_MISSION_SB_TIME_32_16_SUBS) && \ - (CFE_MISSION_SB_PACKET_TIME_FORMAT != CFE_MISSION_SB_TIME_32_32_SUBS) && \ - (CFE_MISSION_SB_PACKET_TIME_FORMAT != CFE_MISSION_SB_TIME_32_32_M_20)) - #error CFE_MISSION_SB_PACKET_TIME_FORMAT must be CFE_MISSION_SB_TIME_32_16_SUBS or CFE_MISSION_SB_TIME_32_32_SUBS or CFE_MISSION_SB_TIME_32_32_M_20! +#if ((CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_SUBS) || \ + (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20)) + #error Legacy CFE_MISSION_SB_PACKET_TIME_FORMAT implementations no longer supported in core #endif #if CFE_MISSION_SB_MAX_SB_MSG_SIZE < 6 diff --git a/modules/msg/CMakeLists.txt b/modules/msg/CMakeLists.txt index 1d6f2e04c..d1abfb5eb 100644 --- a/modules/msg/CMakeLists.txt +++ b/modules/msg/CMakeLists.txt @@ -21,7 +21,7 @@ set(${DEP}_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_msgid_shared.c ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_sechdr_checksum.c ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_sechdr_fc.c - ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_sechdr_time_old.c + ${CMAKE_CURRENT_SOURCE_DIR}/src/cfe_msg_sechdr_time.c ) # Source selection for if CCSDS extended header is included, and MsgId version use diff --git a/modules/msg/mission_inc/default_cfe_msg_sechdr.h b/modules/msg/mission_inc/default_cfe_msg_sechdr.h index d4d7a678a..92edcea2c 100644 --- a/modules/msg/mission_inc/default_cfe_msg_sechdr.h +++ b/modules/msg/mission_inc/default_cfe_msg_sechdr.h @@ -38,22 +38,6 @@ * Defines */ -/* These go away w/ single framework implementation */ -/* CCSDS_TIME_SIZE is specific to the selected CFE_SB time format */ -#if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) -/* 32 bits seconds + 16 bits subseconds */ -#define CCSDS_TIME_SIZE 6 -#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_SUBS) -/* 32 bits seconds + 32 bits subseconds */ -#define CCSDS_TIME_SIZE 8 -#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20) -/* 32 bits seconds + 20 bits microsecs + 12 bits reserved */ -#define CCSDS_TIME_SIZE 8 -#else -/* unknown format */ -#error unable to define CCSDS_TIME_SIZE! -#endif - /* * Type Definitions */ @@ -86,7 +70,7 @@ typedef struct typedef struct { - uint8 Time[CCSDS_TIME_SIZE]; /**< \brief Time sized for selected format */ + uint8 Time[6]; /**< \brief Time, big endian: 4 byte seconds, 2 byte subseconds */ } CFE_MSG_TelemetrySecondaryHeader_t; diff --git a/modules/msg/src/cfe_msg_sechdr_time_old.c b/modules/msg/src/cfe_msg_sechdr_time_old.c deleted file mode 100644 index 7b1a5b16b..000000000 --- a/modules/msg/src/cfe_msg_sechdr_time_old.c +++ /dev/null @@ -1,137 +0,0 @@ -/* -** 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. -*/ - -/****************************************************************************** - * Time field access functions - */ -#include "cfe_msg_api.h" -#include "cfe_msg_priv.h" -#include "cfe_error.h" -#include - -/****************************************************************************** - * Set message time - See API and header file for details - */ -int32 CFE_MSG_SetMsgTime(CFE_MSG_Message_t *MsgPtr, CFE_TIME_SysTime_t NewTime) -{ - - uint32 status; - CFE_MSG_Type_t type; - bool hassechdr = false; - CFE_MSG_TelemetryHeader_t *tlm = (CFE_MSG_TelemetryHeader_t *)MsgPtr; - -/* declare format specific vars */ -#if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) - uint16 LocalSubs16; -#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20) - uint32 LocalSubs32; -#endif - - if (MsgPtr == NULL) - { - return CFE_MSG_BAD_ARGUMENT; - } - - /* Ignore return, pointer already checked */ - CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassechdr); - - status = CFE_MSG_GetType(MsgPtr, &type); - if (status != CFE_SUCCESS || type != CFE_MSG_Type_Tlm || !hassechdr) - { - return CFE_MSG_WRONG_MSG_TYPE; - } - - memcpy(&tlm->Sec.Time[0], &NewTime.Seconds, 4); - -#if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) - - /* convert time from CFE_TIME_SysTime_t format to packet format */ - LocalSubs16 = (uint16)(NewTime.Subseconds >> 16); - memcpy(&tlm->Sec.Time[4], &LocalSubs16, 2); - -#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_SUBS) - - /* no conversion necessary -- packet format = CFE_TIME_SysTime_t format */ - memcpy(&tlm->Sec.Time[4], &NewTime.Subseconds, 4); - -#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20) - - /* convert time from CFE_TIME_SysTime_t format to packet format */ - LocalSubs32 = CFE_TIME_Sub2MicroSecs(NewTime.Subseconds) << 12; - memcpy(&tlm->Sec.Time[4], &LocalSubs32, 4); - -#endif - - return CFE_SUCCESS; -} - -/****************************************************************************** - * Get message time - See API and header file for details - */ -int32 CFE_MSG_GetMsgTime(const CFE_MSG_Message_t *MsgPtr, CFE_TIME_SysTime_t *Time) -{ - - uint32 status; - CFE_MSG_Type_t type; - bool hassechdr = false; - CFE_MSG_TelemetryHeader_t *tlm = (CFE_MSG_TelemetryHeader_t *)MsgPtr; - -#if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) - uint16 LocalSubs16; -#endif - - if (MsgPtr == NULL || Time == NULL) - { - return CFE_MSG_BAD_ARGUMENT; - } - - /* Ignore return, pointer already checked */ - CFE_MSG_GetHasSecondaryHeader(MsgPtr, &hassechdr); - - status = CFE_MSG_GetType(MsgPtr, &type); - if (status != CFE_SUCCESS || type != CFE_MSG_Type_Tlm || !hassechdr) - { - memset(Time, 0, sizeof(*Time)); - return CFE_MSG_WRONG_MSG_TYPE; - } - - memcpy(&Time->Seconds, &tlm->Sec.Time[0], 4); - -#if (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_16_SUBS) - - memcpy(&LocalSubs16, &tlm->Sec.Time[4], 2); - /* convert packet data into CFE_TIME_SysTime_t format */ - Time->Subseconds = ((uint32)LocalSubs16) << 16; - -#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_SUBS) - - memcpy(&Time->Subseconds, &tlm->Sec.Time[4], 4); - /* no conversion necessary -- packet format = CFE_TIME_SysTime_t format */ - -#elif (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20) - - memcpy(&LocalSubs32, &tlm->Sec.Time[4], 4); - /* convert packet data into CFE_TIME_SysTime_t format */ - Time->Subseconds = CFE_TIME_Micro2SubSecs((LocalSubs32 >> 12)); - -#endif - - return CFE_SUCCESS; -} From f2f1c57c012f0c1c64b928e9402d6837e58bdf55 Mon Sep 17 00:00:00 2001 From: Jacob Hageman Date: Fri, 14 Aug 2020 10:26:20 -0400 Subject: [PATCH 6/9] Fix #794, Add msg stubs and update UT --- fsw/cfe-core/unit-test/CMakeLists.txt | 4 - fsw/cfe-core/unit-test/sb_UT.c | 1464 +++++++++++-------------- fsw/cfe-core/unit-test/sb_UT.h | 111 +- fsw/cfe-core/ut-stubs/CMakeLists.txt | 1 + fsw/cfe-core/ut-stubs/ut_msg_stubs.c | 706 ++++++++++++ 5 files changed, 1328 insertions(+), 958 deletions(-) create mode 100644 fsw/cfe-core/ut-stubs/ut_msg_stubs.c diff --git a/fsw/cfe-core/unit-test/CMakeLists.txt b/fsw/cfe-core/unit-test/CMakeLists.txt index ee10db8c4..050cad3f3 100644 --- a/fsw/cfe-core/unit-test/CMakeLists.txt +++ b/fsw/cfe-core/unit-test/CMakeLists.txt @@ -73,10 +73,6 @@ foreach(MODULE ${CFE_CORE_MODULES}) ut_cfe-core_stubs ut_assert) - # TODO short term hack for testing with new code - target_link_libraries(${UT_TARGET_NAME}_UT msg) - #target_link_libraries(${UT_TARGET_NAME}_UT mission_msg) - add_test(${UT_TARGET_NAME}_UT ${UT_TARGET_NAME}_UT) install(TARGETS ${UT_TARGET_NAME}_UT DESTINATION ${TGTNAME}/${UT_INSTALL_SUBDIR}) endforeach(MODULE ${CFE_CORE_MODULES}) diff --git a/fsw/cfe-core/unit-test/sb_UT.c b/fsw/cfe-core/unit-test/sb_UT.c index 068ddaa68..905520a6c 100644 --- a/fsw/cfe-core/unit-test/sb_UT.c +++ b/fsw/cfe-core/unit-test/sb_UT.c @@ -405,10 +405,14 @@ void Test_SB_Cmds(void) */ void Test_SB_Cmds_Noop(void) { - CFE_SB_CmdHdr_t NoParamCmd; - - CFE_SB_InitMsg(&NoParamCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), sizeof(NoParamCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &NoParamCmd, CFE_SB_NOOP_CC); + CFE_SB_CmdHdr_t NoParamCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_NOOP_CC; + CFE_SB_MsgId_t MsgId = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(NoParamCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &NoParamCmd; CFE_SB_ProcessCmdPipePkt(); @@ -423,10 +427,14 @@ void Test_SB_Cmds_Noop(void) */ void Test_SB_Cmds_RstCtrs(void) { - CFE_SB_CmdHdr_t NoParamCmd; + CFE_SB_CmdHdr_t NoParamCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_RESET_COUNTERS_CC; + CFE_SB_MsgId_t MsgId = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(NoParamCmd); - CFE_SB_InitMsg(&NoParamCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), sizeof(NoParamCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &NoParamCmd, CFE_SB_RESET_COUNTERS_CC); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &NoParamCmd; CFE_SB_ProcessCmdPipePkt(); @@ -441,19 +449,33 @@ void Test_SB_Cmds_RstCtrs(void) */ void Test_SB_Cmds_Stats(void) { - CFE_SB_CmdHdr_t NoParamCmd; + CFE_SB_CmdHdr_t NoParamCmd; + CFE_MSG_FcnCode_t FcnCode; + CFE_SB_MsgId_t MsgId; + CFE_MSG_Size_t Size; + + /* For internal SendMsg call */ + MsgId = CFE_SB_ValueToMsgId(CFE_SB_STATS_TLM_MID); + Size = sizeof(CFE_SB.StatTlmMsg); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + + /* For Generic command processing */ + MsgId = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + Size = sizeof(NoParamCmd); + FcnCode = CFE_SB_SEND_SB_STATS_CC; + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - CFE_SB_InitMsg(&NoParamCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), sizeof(NoParamCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &NoParamCmd, CFE_SB_SEND_SB_STATS_CC); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &NoParamCmd; CFE_SB_ProcessCmdPipePkt(); + /* No subs event and command processing event */ EVTCNT(2); EVTSENT(CFE_SB_SND_STATS_EID); - EVTSENT(CFE_SB_SND_STATS_EID); - } /* end Test_SB_Cmds_Stats */ /* @@ -463,11 +485,13 @@ void Test_SB_Cmds_RoutingInfoDef(void) { CFE_SB_PipeId_t PipeId = 0; CFE_SB_WriteFileInfoCmd_t WriteFileCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_SEND_ROUTING_INFO_CC; + CFE_SB_MsgId_t MsgId = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(WriteFileCmd); - CFE_SB_InitMsg(&WriteFileCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(WriteFileCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &WriteFileCmd, - CFE_SB_SEND_ROUTING_INFO_CC); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); strncpy((char *)WriteFileCmd.Payload.Filename, "", sizeof(WriteFileCmd.Payload.Filename)); /* Make some routing info by calling CFE_SB_AppInit */ @@ -497,11 +521,13 @@ void Test_SB_Cmds_RoutingInfoDef(void) void Test_SB_Cmds_RoutingInfoSpec(void) { CFE_SB_WriteFileInfoCmd_t WriteFileCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_SEND_ROUTING_INFO_CC; + CFE_SB_MsgId_t MsgId = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(WriteFileCmd); - CFE_SB_InitMsg(&WriteFileCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(WriteFileCmd), true); - SETUP(CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &WriteFileCmd, - CFE_SB_SEND_ROUTING_INFO_CC)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); strncpy((char *)WriteFileCmd.Payload.Filename, "RoutingTstFile", sizeof(WriteFileCmd.Payload.Filename)); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &WriteFileCmd; @@ -519,11 +545,13 @@ void Test_SB_Cmds_RoutingInfoSpec(void) void Test_SB_Cmds_RoutingInfoCreateFail(void) { CFE_SB_WriteFileInfoCmd_t WriteFileCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_SEND_ROUTING_INFO_CC; + CFE_SB_MsgId_t MsgId = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(WriteFileCmd); - CFE_SB_InitMsg(&WriteFileCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(WriteFileCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &WriteFileCmd, - CFE_SB_SEND_ROUTING_INFO_CC); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); strncpy((char *)WriteFileCmd.Payload.Filename, "RoutingTstFile", sizeof(WriteFileCmd.Payload.Filename)); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &WriteFileCmd; @@ -592,11 +620,13 @@ void Test_SB_Cmds_PipeInfoDef(void) CFE_SB_PipeId_t PipeId2; CFE_SB_PipeId_t PipeId3; uint16 PipeDepth = 10; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_SEND_PIPE_INFO_CC; + CFE_SB_MsgId_t MsgId = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(WriteFileCmd); - CFE_SB_InitMsg(&WriteFileCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(WriteFileCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &WriteFileCmd, - CFE_SB_SEND_PIPE_INFO_CC); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); strncpy((char *)WriteFileCmd.Payload.Filename, "", sizeof(WriteFileCmd.Payload.Filename)); /* Create some pipe info */ @@ -624,11 +654,13 @@ void Test_SB_Cmds_PipeInfoDef(void) void Test_SB_Cmds_PipeInfoSpec(void) { CFE_SB_WriteFileInfoCmd_t WriteFileCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_SEND_PIPE_INFO_CC; + CFE_SB_MsgId_t MsgId = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(WriteFileCmd); - CFE_SB_InitMsg(&WriteFileCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(WriteFileCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &WriteFileCmd, - CFE_SB_SEND_PIPE_INFO_CC); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); strncpy((char *)WriteFileCmd.Payload.Filename, "PipeTstFile", sizeof(WriteFileCmd.Payload.Filename)); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &WriteFileCmd; CFE_SB_ProcessCmdPipePkt(); @@ -713,11 +745,13 @@ void Test_SB_Cmds_MapInfoDef(void) CFE_SB_MsgId_t MsgId4 = SB_UT_TLM_MID5; CFE_SB_MsgId_t MsgId5 = SB_UT_TLM_MID6; uint16 PipeDepth = 10; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_SEND_MAP_INFO_CC; + CFE_SB_MsgId_t MsgId = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(WriteFileCmd); - CFE_SB_InitMsg(&WriteFileCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(WriteFileCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &WriteFileCmd, - CFE_SB_SEND_MAP_INFO_CC); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); strncpy((char *)WriteFileCmd.Payload.Filename, "", sizeof(WriteFileCmd.Payload.Filename)); /* Create some map info */ @@ -755,11 +789,13 @@ void Test_SB_Cmds_MapInfoDef(void) void Test_SB_Cmds_MapInfoSpec(void) { CFE_SB_WriteFileInfoCmd_t WriteFileCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_SEND_MAP_INFO_CC; + CFE_SB_MsgId_t MsgId = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(WriteFileCmd); - CFE_SB_InitMsg(&WriteFileCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(WriteFileCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &WriteFileCmd, - CFE_SB_SEND_MAP_INFO_CC); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); strncpy((char *)WriteFileCmd.Payload.Filename, "MapTstFile", sizeof(WriteFileCmd.Payload.Filename)); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &WriteFileCmd; CFE_SB_ProcessCmdPipePkt(); @@ -853,13 +889,16 @@ void Test_SB_Cmds_EnRouteValParam(void) CFE_SB_PipeId_t PipeId; CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; uint16 PipeDepth = 5; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_ENABLE_ROUTE_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(EnDisRouteCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "EnRouteTestPipe")); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); - CFE_SB_InitMsg(&EnDisRouteCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(EnDisRouteCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &EnDisRouteCmd, - CFE_SB_ENABLE_ROUTE_CC); EnDisRouteCmd.Payload.MsgId = MsgId; EnDisRouteCmd.Payload.Pipe = PipeId; CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &EnDisRouteCmd; @@ -888,14 +927,17 @@ void Test_SB_Cmds_EnRouteNonExist(void) CFE_SB_PipeId_t PipeId2; CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; uint16 PipeDepth = 5; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_ENABLE_ROUTE_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(EnDisRouteCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); SETUP(CFE_SB_CreatePipe(&PipeId1, PipeDepth, "EnRouteTestPipe1")); SETUP(CFE_SB_CreatePipe(&PipeId2, PipeDepth, "EnRouteTestPipe2")); SETUP(CFE_SB_Subscribe(MsgId, PipeId1)); - CFE_SB_InitMsg(&EnDisRouteCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(EnDisRouteCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &EnDisRouteCmd, - CFE_SB_ENABLE_ROUTE_CC); EnDisRouteCmd.Payload.MsgId = MsgId; EnDisRouteCmd.Payload.Pipe = PipeId2; CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &EnDisRouteCmd; @@ -919,11 +961,14 @@ void Test_SB_Cmds_EnRouteNonExist(void) void Test_SB_Cmds_EnRouteInvParam(void) { CFE_SB_RouteCmd_t EnDisRouteCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_ENABLE_ROUTE_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(EnDisRouteCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - CFE_SB_InitMsg(&EnDisRouteCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(EnDisRouteCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &EnDisRouteCmd, - CFE_SB_ENABLE_ROUTE_CC); EnDisRouteCmd.Payload.MsgId = SB_UT_LAST_VALID_MID; EnDisRouteCmd.Payload.Pipe = 3; CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &EnDisRouteCmd; @@ -942,11 +987,14 @@ void Test_SB_Cmds_EnRouteInvParam(void) void Test_SB_Cmds_EnRouteInvParam2(void) { CFE_SB_RouteCmd_t EnDisRouteCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_ENABLE_ROUTE_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(EnDisRouteCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - CFE_SB_InitMsg(&EnDisRouteCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(EnDisRouteCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &EnDisRouteCmd, - CFE_SB_ENABLE_ROUTE_CC); EnDisRouteCmd.Payload.MsgId = CFE_SB_INVALID_MSG_ID; EnDisRouteCmd.Payload.Pipe = 3; CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &EnDisRouteCmd; @@ -966,11 +1014,14 @@ void Test_SB_Cmds_EnRouteInvParam2(void) void Test_SB_Cmds_EnRouteInvParam3(void) { CFE_SB_RouteCmd_t EnDisRouteCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_ENABLE_ROUTE_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(EnDisRouteCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - CFE_SB_InitMsg(&EnDisRouteCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(EnDisRouteCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &EnDisRouteCmd, - CFE_SB_ENABLE_ROUTE_CC); EnDisRouteCmd.Payload.MsgId = SB_UT_ALTERNATE_INVALID_MID; EnDisRouteCmd.Payload.Pipe = 0; CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &EnDisRouteCmd; @@ -992,13 +1043,16 @@ void Test_SB_Cmds_DisRouteValParam(void) CFE_SB_PipeId_t PipeId; CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; uint16 PipeDepth = 5; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_DISABLE_ROUTE_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(EnDisRouteCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "DisRouteTestPipe")); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); - CFE_SB_InitMsg(&EnDisRouteCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(EnDisRouteCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &EnDisRouteCmd, - CFE_SB_DISABLE_ROUTE_CC); EnDisRouteCmd.Payload.MsgId = MsgId; EnDisRouteCmd.Payload.Pipe = PipeId; CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &EnDisRouteCmd; @@ -1025,14 +1079,17 @@ void Test_SB_Cmds_DisRouteNonExist(void) CFE_SB_PipeId_t PipeId1, PipeId2; CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; uint16 PipeDepth = 5; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_DISABLE_ROUTE_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(EnDisRouteCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); SETUP(CFE_SB_CreatePipe(&PipeId1, PipeDepth, "DisRouteTestPipe1")); SETUP(CFE_SB_CreatePipe(&PipeId2, PipeDepth, "DisRouteTestPipe2")); SETUP(CFE_SB_Subscribe(MsgId, PipeId1)); - CFE_SB_InitMsg(&EnDisRouteCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(EnDisRouteCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &EnDisRouteCmd, - CFE_SB_DISABLE_ROUTE_CC); EnDisRouteCmd.Payload.MsgId = MsgId; EnDisRouteCmd.Payload.Pipe = PipeId2; CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &EnDisRouteCmd; @@ -1056,11 +1113,14 @@ void Test_SB_Cmds_DisRouteNonExist(void) void Test_SB_Cmds_DisRouteInvParam(void) { CFE_SB_RouteCmd_t EnDisRouteCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_DISABLE_ROUTE_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(EnDisRouteCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - CFE_SB_InitMsg(&EnDisRouteCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(EnDisRouteCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &EnDisRouteCmd, - CFE_SB_DISABLE_ROUTE_CC); EnDisRouteCmd.Payload.MsgId = SB_UT_LAST_VALID_MID; EnDisRouteCmd.Payload.Pipe = 3; CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &EnDisRouteCmd; @@ -1079,11 +1139,14 @@ void Test_SB_Cmds_DisRouteInvParam(void) void Test_SB_Cmds_DisRouteInvParam2(void) { CFE_SB_RouteCmd_t EnDisRouteCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_DISABLE_ROUTE_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(EnDisRouteCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - CFE_SB_InitMsg(&EnDisRouteCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(EnDisRouteCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &EnDisRouteCmd, - CFE_SB_DISABLE_ROUTE_CC); EnDisRouteCmd.Payload.MsgId = CFE_SB_INVALID_MSG_ID; EnDisRouteCmd.Payload.Pipe = 3; CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &EnDisRouteCmd; @@ -1103,11 +1166,14 @@ void Test_SB_Cmds_DisRouteInvParam2(void) void Test_SB_Cmds_DisRouteInvParam3(void) { CFE_SB_RouteCmd_t EnDisRouteCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_DISABLE_ROUTE_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(EnDisRouteCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - CFE_SB_InitMsg(&EnDisRouteCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), - sizeof(EnDisRouteCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &EnDisRouteCmd, - CFE_SB_DISABLE_ROUTE_CC); EnDisRouteCmd.Payload.MsgId = SB_UT_ALTERNATE_INVALID_MID; EnDisRouteCmd.Payload.Pipe = 0; CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &EnDisRouteCmd; @@ -1126,9 +1192,18 @@ void Test_SB_Cmds_DisRouteInvParam3(void) void Test_SB_Cmds_SendHK(void) { CFE_SB_CmdHdr_t NoParamCmd; - - CFE_SB_InitMsg(&NoParamCmd, CFE_SB_ValueToMsgId(CFE_SB_SEND_HK_MID), - sizeof(NoParamCmd), true); + CFE_SB_MsgId_t MsgIdCmd; + CFE_MSG_Size_t Size; + + /* For internal SendMsg call */ + MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_HK_TLM_MID); + Size = sizeof(CFE_SB.HKTlmMsg); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + + /* For HK command processing */ + MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_SEND_HK_MID); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &NoParamCmd; CFE_SB_ProcessCmdPipePkt(); @@ -1146,16 +1221,17 @@ void Test_SB_Cmds_SendHK(void) void Test_SB_Cmds_SendPrevSubs(void) { CFE_SB_SendPrevSubs_t NoParamCmd; - CFE_SB_PipeId_t PipeId1; - CFE_SB_PipeId_t PipeId2; - CFE_SB_MsgId_t MsgId = SB_UT_BARE_TLM_MID3; - uint16 MsgLim = 4; - uint16 PipeDepth = 50; - int32 i; - int32 NumEvts; + CFE_SB_PipeId_t PipeId1; + CFE_SB_PipeId_t PipeId2; + CFE_SB_MsgId_t MsgId = SB_UT_BARE_TLM_MID3; + uint16 MsgLim = 4; + uint16 PipeDepth = 50; + int32 i; + int32 NumEvts; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_SEND_PREV_SUBS_CC; + CFE_SB_MsgId_t MsgIdCmd; + CFE_MSG_Size_t Size; - CFE_SB_InitMsg(&NoParamCmd, CFE_SB_ValueToMsgId(CFE_SB_SUB_RPT_CTRL_MID), sizeof(CFE_SB_SendPrevSubs_t), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &NoParamCmd, CFE_SB_SEND_PREV_SUBS_CC); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &NoParamCmd; SETUP(CFE_SB_CreatePipe(&PipeId1, PipeDepth, "TestPipe1")); SETUP(CFE_SB_CreatePipe(&PipeId2, PipeDepth, "TestPipe2")); @@ -1181,6 +1257,23 @@ void Test_SB_Cmds_SendPrevSubs(void) SETUP(CFE_SB_SubscribeLocal(MsgId, PipeId2, MsgLim)); + /* For 3 internal SendMsg calls */ + MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_ALLSUBS_TLM_MID); + Size = sizeof(CFE_SB.PrevSubMsg); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + + /* Set buffers for gets */ + MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_SUB_RPT_CTRL_MID); + Size = sizeof(CFE_SB_SendPrevSubs_t); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + CFE_SB_ProcessCmdPipePkt(); NumEvts += 8; /* +2 for the subscribe, +6 for the SEND_PREV_SUBS_CC */ @@ -1197,6 +1290,23 @@ void Test_SB_Cmds_SendPrevSubs(void) SETUP(CFE_SB_SubscribeLocal(MsgId, PipeId2, MsgLim)); + /* For 3 internal SendMsg calls */ + MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_ALLSUBS_TLM_MID); + Size = sizeof(CFE_SB.PrevSubMsg); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + + /* Set buffers for gets */ + MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_SUB_RPT_CTRL_MID); + Size = sizeof(CFE_SB_SendPrevSubs_t); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + CFE_SB_ProcessCmdPipePkt(); NumEvts += 8; /* +2 for the subscribe, +6 for the SEND_PREV_SUBS_CC */ @@ -1218,12 +1328,15 @@ void Test_SB_Cmds_SendPrevSubs(void) */ void Test_SB_Cmds_SubRptOn(void) { - CFE_SB_CmdHdr_t NoParamCmd; + CFE_SB_CmdHdr_t NoParamCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_ENABLE_SUB_REPORTING_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_SUB_RPT_CTRL_MID); + CFE_MSG_Size_t Size = sizeof(NoParamCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - CFE_SB_InitMsg(&NoParamCmd, CFE_SB_ValueToMsgId(CFE_SB_SUB_RPT_CTRL_MID), - sizeof(NoParamCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &NoParamCmd, - CFE_SB_ENABLE_SUB_REPORTING_CC); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &NoParamCmd; CFE_SB_ProcessCmdPipePkt(); @@ -1236,12 +1349,15 @@ void Test_SB_Cmds_SubRptOn(void) */ void Test_SB_Cmds_SubRptOff(void) { - CFE_SB_CmdHdr_t NoParamCmd; + CFE_SB_CmdHdr_t NoParamCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_DISABLE_SUB_REPORTING_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_SUB_RPT_CTRL_MID); + CFE_MSG_Size_t Size = sizeof(NoParamCmd); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - CFE_SB_InitMsg(&NoParamCmd, CFE_SB_ValueToMsgId(CFE_SB_SUB_RPT_CTRL_MID), - sizeof(NoParamCmd), true); - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &NoParamCmd, - CFE_SB_DISABLE_SUB_REPORTING_CC); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &NoParamCmd; CFE_SB_ProcessCmdPipePkt(); @@ -1254,12 +1370,15 @@ void Test_SB_Cmds_SubRptOff(void) */ void Test_SB_Cmds_CmdUnexpCmdCode(void) { - CFE_SB_CmdHdr_t NoParamCmd; + CFE_SB_CmdHdr_t NoParamCmd; + CFE_MSG_FcnCode_t FcnCode = 99; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); - CFE_SB_InitMsg(&NoParamCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), sizeof(NoParamCmd), true); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); /* Use a command code known to be invalid */ - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &NoParamCmd, 99); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &NoParamCmd; CFE_SB_ProcessCmdPipePkt(); EVTCNT(1); @@ -1272,12 +1391,16 @@ void Test_SB_Cmds_CmdUnexpCmdCode(void) */ void Test_SB_Cmds_SubRptUnexpCmdCode(void) { - CFE_SB_CmdHdr_t NoParamCmd; + CFE_SB_CmdHdr_t NoParamCmd; + CFE_MSG_FcnCode_t FcnCode = 99; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_SUB_RPT_CTRL_MID); - CFE_SB_InitMsg(&NoParamCmd, CFE_SB_ValueToMsgId(CFE_SB_SUB_RPT_CTRL_MID), sizeof(NoParamCmd), true); + /* Second GetFcnCode is for reporting */ + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); /* Use a command code known to be invalid */ - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &NoParamCmd, 99); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &NoParamCmd; CFE_SB_ProcessCmdPipePkt(); @@ -1296,11 +1419,17 @@ void Test_SB_Cmds_BadCmdLength(void) * Just choosing "EnableRoute" command here as it has a non-empty payload */ CFE_SB_EnableRoute_t EnableRouteCmd; + CFE_MSG_FcnCode_t FcnCode = CFE_SB_ENABLE_ROUTE_CC; + CFE_SB_MsgId_t MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); + CFE_MSG_Size_t Size = sizeof(EnableRouteCmd) - 1; - CFE_SB_InitMsg(&EnableRouteCmd, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), sizeof(EnableRouteCmd) - 1, true); + /* Second GetMsgId and GetFcnCode are for reporting */ + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - /* Use a command code known to be invalid */ - CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) &EnableRouteCmd, CFE_SB_ENABLE_ROUTE_CC); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &EnableRouteCmd; CFE_SB_ProcessCmdPipePkt(); @@ -1315,10 +1444,11 @@ void Test_SB_Cmds_BadCmdLength(void) */ void Test_SB_Cmds_UnexpMsgId(void) { - CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; + CFE_SB_MsgId_t MsgIdCmd = SB_UT_TLM_MID; CFE_SB_CmdHdr_t NoParamCmd; - CFE_SB_InitMsg(&NoParamCmd, MsgId, sizeof(NoParamCmd), true); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &NoParamCmd; CFE_SB_ProcessCmdPipePkt(); @@ -2115,6 +2245,8 @@ void Test_Subscribe_SendPrevSubs(void) CFE_SB_MsgId_t MsgId2 = SB_UT_TLM_MID3; uint16 PipeDepth = 50; CFE_SB_SendPrevSubs_t SendPrevSubsMsg; + CFE_SB_MsgId_t MsgIdCmd; + CFE_MSG_Size_t Size; /* note that the message is not currently used or required, * but creating one and initializing it for completeness, in @@ -2134,6 +2266,12 @@ void Test_Subscribe_SendPrevSubs(void) /* Set the last list header pointer to NULL to get branch path coverage */ CFE_SB.RoutingTbl[2].ListHeadPtr = NULL; + /* For internal SendMsg call */ + MsgIdCmd = CFE_SB_ValueToMsgId(CFE_SB_ALLSUBS_TLM_MID); + Size = sizeof(CFE_SB.PrevSubMsg); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdCmd, sizeof(MsgIdCmd), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + ASSERT(CFE_SB_SendPrevSubsCmd(&SendPrevSubsMsg)); EVTCNT(19); @@ -2211,12 +2349,20 @@ void Test_Subscribe_SubscriptionReporting(void) CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; CFE_SB_Qos_t Quality; uint16 PipeDepth = 10; + CFE_SB_MsgId_t MsgIdRpt; + CFE_MSG_Size_t Size; SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "TestPipe")); /* Enable subscription reporting */ CFE_SB_SetSubscriptionReporting(CFE_SB_ENABLE); + /* For internal SendMsg call that will report subscription */ + MsgIdRpt = CFE_SB_ValueToMsgId(CFE_SB_ONESUB_TLM_MID); + Size = sizeof(CFE_SB.SubRprtMsg); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgIdRpt, sizeof(MsgIdRpt), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + /* Subscribe to message: GLOBAL */ SETUP(CFE_SB_Subscribe(MsgId, PipeId)); @@ -2585,8 +2731,11 @@ void Test_SendMsg_NoSubscribers(void) CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; + CFE_MSG_Size_t Size = sizeof(TlmPkt); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), true); ASSERT(CFE_SB_SendMsg(TlmPktPtr)); EVTCNT(1); @@ -2603,8 +2752,10 @@ void Test_SendMsg_MaxMsgSizePlusOne(void) CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; + CFE_MSG_Size_t Size = CFE_MISSION_SB_MAX_SB_MSG_SIZE + 1; - CFE_SB_InitMsg(&TlmPkt, MsgId, CFE_MISSION_SB_MAX_SB_MSG_SIZE + 1, false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); ASSERT_EQ(CFE_SB_SendMsg(TlmPktPtr), CFE_SB_MSG_TOO_BIG); @@ -2624,10 +2775,15 @@ void Test_SendMsg_BasicSend(void) SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; int32 PipeDepth = 2; + CFE_MSG_Size_t Size = sizeof(TlmPkt); + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "TestPipe")); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), true); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); ASSERT(CFE_SB_SendMsg(TlmPktPtr)); @@ -2637,6 +2793,16 @@ void Test_SendMsg_BasicSend(void) } /* end Test_SendMsg_BasicSend */ +/* Sequence count hook */ +static int32 UT_CheckSetSequenceCount(void *UserObj, int32 StubRetcode, uint32 CallCount, const UT_StubContext_t *Context) +{ + CFE_MSG_SequenceCount_t *SeqCntPtr = UserObj; + + *SeqCntPtr = UT_Hook_GetArgValueByName(Context, "SeqCnt", CFE_MSG_SequenceCount_t); + + return StubRetcode; +} + /* ** Test successful send/receive for packet sequence count */ @@ -2644,59 +2810,60 @@ void Test_SendMsg_SequenceCount(void) { CFE_SB_PipeId_t PipeId; CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; - CFE_SB_MsgPtr_t PtrToMsg; SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; + CFE_MSG_Size_t Size = sizeof(TlmPkt); + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; uint32 PipeDepth = 10; CFE_MSG_SequenceCount_t SeqCnt; + /* Set up hook for checking CFE_MSG_SetSequenceCount calls */ + UT_SetHookFunction(UT_KEY(CFE_MSG_SetSequenceCount), UT_CheckSetSequenceCount, &SeqCnt); + SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "SeqCntTestPipe")); - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), true); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); - CFE_MSG_SetSequenceCount(TlmPktPtr, 22); - SETUP(CFE_SB_SendMsg(TlmPktPtr)); - ASSERT(CFE_SB_RcvMsg(&PtrToMsg, PipeId, CFE_SB_PEND_FOREVER)); - - ASSERT_TRUE(PtrToMsg != NULL); - - CFE_MSG_GetSequenceCount(PtrToMsg, &SeqCnt); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + SETUP(CFE_SB_SendMsg(TlmPktPtr)); + ASSERT_EQ(UT_GetStubCount(UT_KEY(CFE_MSG_SetSequenceCount)), 1); ASSERT_EQ(SeqCnt, 1); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); ASSERT(CFE_SB_PassMsg(TlmPktPtr)); - ASSERT(CFE_SB_RcvMsg(&PtrToMsg, PipeId, CFE_SB_PEND_FOREVER)); - - ASSERT_TRUE(PtrToMsg != NULL); - - CFE_MSG_GetSequenceCount(PtrToMsg, &SeqCnt); - ASSERT_EQ(SeqCnt, 22); + /* Assert sequence count wasn't set */ + ASSERT_EQ(UT_GetStubCount(UT_KEY(CFE_MSG_SetSequenceCount)), 1); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); ASSERT(CFE_SB_SendMsg(TlmPktPtr)); - - ASSERT(CFE_SB_RcvMsg(&PtrToMsg, PipeId, CFE_SB_PEND_FOREVER)); - - ASSERT_TRUE(PtrToMsg != NULL); - - CFE_MSG_GetSequenceCount(PtrToMsg, &SeqCnt); ASSERT_EQ(SeqCnt, 2); + ASSERT_EQ(UT_GetStubCount(UT_KEY(CFE_MSG_SetSequenceCount)), 2); EVTCNT(3); - EVTSENT(CFE_SB_SUBSCRIPTION_RCVD_EID); SETUP(CFE_SB_Unsubscribe(MsgId, PipeId)); /* should have no subscribers now */ + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); SETUP(CFE_SB_SendMsg(TlmPktPtr)); /* increment to 3 */ + ASSERT_EQ(UT_GetStubCount(UT_KEY(CFE_MSG_SetSequenceCount)), 3); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); /* resubscribe so we can receive a msg */ + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); SETUP(CFE_SB_SendMsg(TlmPktPtr)); /* increment to 4 */ - - SETUP(CFE_SB_RcvMsg(&PtrToMsg, PipeId, CFE_SB_PEND_FOREVER)); - - CFE_MSG_GetSequenceCount(PtrToMsg, &SeqCnt); ASSERT_EQ(SeqCnt, 4); + ASSERT_EQ(UT_GetStubCount(UT_KEY(CFE_MSG_SetSequenceCount)), 4); TEARDOWN(CFE_SB_DeletePipe(PipeId)); @@ -2712,15 +2879,18 @@ void Test_SendMsg_QueuePutError(void) SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; int32 PipeDepth = 2; + CFE_MSG_Size_t Size = sizeof(TlmPkt); + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; SETUP(CFE_SB_CreatePipe(&PipeId4Error, PipeDepth, "TestPipe")); SETUP(CFE_SB_Subscribe(MsgId, PipeId4Error)); - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), false); UT_SetDeferredRetcode(UT_KEY(OS_QueuePut), 1, OS_ERROR); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); ASSERT(CFE_SB_SendMsg(TlmPktPtr)); - EVTCNT(5); EVTSENT(CFE_SB_Q_WR_ERR_EID); @@ -2739,10 +2909,14 @@ void Test_SendMsg_PipeFull(void) SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; int32 PipeDepth = 1; + CFE_MSG_Size_t Size = sizeof(TlmPkt); + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), true); SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "PipeFullTestPipe")); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); /* This send should pass */ ASSERT(CFE_SB_SendMsg(TlmPktPtr)); @@ -2750,6 +2924,10 @@ void Test_SendMsg_PipeFull(void) /* Tell the QueuePut stub to return OS_QUEUE_FULL on its next call */ UT_SetDeferredRetcode(UT_KEY(OS_QueuePut), 1, OS_QUEUE_FULL); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + /* Pipe overflow causes SendMsg to return CFE_SUCCESS */ ASSERT(CFE_SB_SendMsg(TlmPktPtr)); @@ -2771,16 +2949,25 @@ void Test_SendMsg_MsgLimitExceeded(void) SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; int32 PipeDepth = 5; + CFE_MSG_Size_t Size = sizeof(TlmPkt); + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), false); SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "MsgLimTestPipe")); /* Set maximum allowed messages on the pipe at one time to 1 */ CFE_SB_SubscribeEx(MsgId, PipeId, CFE_SB_Default_Qos, 1); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + /* First send should pass */ ASSERT(CFE_SB_SendMsg(TlmPktPtr)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + /* This send should produce a MsgId to Pipe Limit Exceeded message, but * return success */ @@ -2804,11 +2991,13 @@ void Test_SendMsg_GetPoolBufErr(void) SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; int32 PipeDepth; + CFE_MSG_Size_t Size = sizeof(TlmPkt); PipeDepth = 1; - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), true); SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "GetPoolErrPipe")); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); /* Have GetPoolBuf stub return error on its next call (buf descriptor * allocation failed) @@ -2857,15 +3046,19 @@ void Test_SendMsg_ZeroCopyGetPtr(void) /* Increase the peak memory and buffers in use above the expected values in * order to exercise branch paths */ - CFE_SB.StatTlmMsg.Payload.PeakMemInUse = (MsgSize + - sizeof(CFE_SB_BufferD_t)) * 5; + CFE_SB.StatTlmMsg.Payload.MemInUse = 0; + CFE_SB.StatTlmMsg.Payload.PeakMemInUse = sizeof(CFE_SB_ZeroCopyD_t) + MsgSize + + sizeof(CFE_SB_BufferD_t) + 1; CFE_SB.StatTlmMsg.Payload.PeakSBBuffersInUse = CFE_SB.StatTlmMsg.Payload.SBBuffersInUse + 2; ASSERT_TRUE((cpuaddr) CFE_SB_ZeroCopyGetPtr(MsgSize, &ZeroCpyBufHndl) != (cpuaddr) NULL); - ASSERT_TRUE(CFE_SB.StatTlmMsg.Payload.PeakMemInUse == (MsgSize + sizeof(CFE_SB_BufferD_t)) * 5); + ASSERT_EQ(CFE_SB.StatTlmMsg.Payload.PeakMemInUse, sizeof(CFE_SB_ZeroCopyD_t) + MsgSize + + sizeof(CFE_SB_BufferD_t) + 1); + ASSERT_EQ(CFE_SB.StatTlmMsg.Payload.MemInUse, sizeof(CFE_SB_ZeroCopyD_t) + MsgSize + + sizeof(CFE_SB_BufferD_t)); - ASSERT_TRUE(CFE_SB.StatTlmMsg.Payload.PeakSBBuffersInUse == CFE_SB.StatTlmMsg.Payload.SBBuffersInUse + 1); + ASSERT_EQ(CFE_SB.StatTlmMsg.Payload.PeakSBBuffersInUse, CFE_SB.StatTlmMsg.Payload.SBBuffersInUse + 1); EVTCNT(0); @@ -2884,6 +3077,11 @@ void Test_SendMsg_ZeroCopySend(void) uint32 PipeDepth = 10; CFE_SB_ZeroCopyHandle_t ZeroCpyBufHndl = 0; CFE_MSG_SequenceCount_t SeqCnt; + CFE_MSG_Size_t Size = sizeof(SB_UT_Test_Tlm_t); + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + + /* Set up hook for checking CFE_MSG_SetSequenceCount calls */ + UT_SetHookFunction(UT_KEY(CFE_MSG_SetSequenceCount), UT_CheckSetSequenceCount, &SeqCnt); SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "ZeroCpyTestPipe")); @@ -2894,16 +3092,15 @@ void Test_SendMsg_ZeroCopySend(void) { UtAssert_Failed("Unexpected NULL pointer returned from ZeroCopyGetPtr"); } - else - { - CFE_SB_InitMsg(ZeroCpyMsgPtr, MsgId, sizeof(SB_UT_Test_Tlm_t), true); - CFE_MSG_SetSequenceCount(ZeroCpyMsgPtr, 22); - } /* Test response to a get pool information error */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_GetPoolBufInfo), 1, -1); ASSERT_EQ(CFE_SB_ZeroCopySend(ZeroCpyMsgPtr, ZeroCpyBufHndl), CFE_SB_BUFFER_INVALID); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + /* Test a successful zero copy send */ ASSERT(CFE_SB_ZeroCopySend(ZeroCpyMsgPtr, ZeroCpyBufHndl)); @@ -2911,7 +3108,6 @@ void Test_SendMsg_ZeroCopySend(void) ASSERT_TRUE(PtrToMsg != NULL); - CFE_MSG_GetSequenceCount(PtrToMsg, &SeqCnt); ASSERT_EQ(SeqCnt, 1); EVTCNT(3); @@ -2934,8 +3130,12 @@ void Test_SendMsg_ZeroCopyPass(void) CFE_SB_MsgPtr_t ZeroCpyMsgPtr = NULL; uint32 PipeDepth = 10; CFE_SB_ZeroCopyHandle_t ZeroCpyBufHndl = 0; - CFE_MSG_SequenceCount_t ExpectedSeqCnt = 22; - CFE_MSG_SequenceCount_t ActualSeqCnt; + CFE_MSG_SequenceCount_t SeqCnt = 22; + CFE_MSG_Size_t Size = sizeof(SB_UT_Test_Tlm_t); + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + + /* Set up hook for checking CFE_MSG_SetSequenceCount calls */ + UT_SetHookFunction(UT_KEY(CFE_MSG_SetSequenceCount), UT_CheckSetSequenceCount, &SeqCnt); SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "ZeroCpyPassTestPipe")); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); @@ -2947,33 +3147,21 @@ void Test_SendMsg_ZeroCopyPass(void) { UtAssert_Failed("Unexpected NULL pointer returned from ZeroCopyGetPtr"); } - else - { - CFE_SB_InitMsg(ZeroCpyMsgPtr, MsgId, sizeof(SB_UT_Test_Tlm_t), true); - CFE_MSG_SetSequenceCount(ZeroCpyMsgPtr, ExpectedSeqCnt); - } /* Test response to a get pool information error */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_GetPoolBufInfo), 1, -1); ASSERT_EQ(CFE_SB_ZeroCopyPass(ZeroCpyMsgPtr, ZeroCpyBufHndl), CFE_SB_BUFFER_INVALID); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); /* Test a successful zero copy pass */ ASSERT(CFE_SB_ZeroCopyPass(ZeroCpyMsgPtr, ZeroCpyBufHndl)); - - ASSERT(CFE_SB_RcvMsg(&PtrToMsg, PipeId, CFE_SB_PEND_FOREVER)); - - if (PtrToMsg == NULL) - { - UtAssert_Failed("Unexpected NULL return from receive in zero copy pass test"); - } - else - { - CFE_MSG_GetSequenceCount(PtrToMsg, &ActualSeqCnt); - ASSERT_EQ(ExpectedSeqCnt, ActualSeqCnt); - } + ASSERT_TRUE(PtrToMsg != NULL); + ASSERT_EQ(SeqCnt, 22); EVTCNT(3); @@ -3045,6 +3233,8 @@ void Test_SendMsg_DisabledDestination(void) CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; CFE_SB_DestinationD_t *DestPtr; int32 PipeDepth; + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + CFE_MSG_Size_t Size = sizeof(TlmPkt); PipeDepth = 2; @@ -3052,7 +3242,10 @@ void Test_SendMsg_DisabledDestination(void) SETUP(CFE_SB_Subscribe(MsgId, PipeId)); DestPtr = CFE_SB_GetDestPtr(CFE_SB_ConvertMsgIdtoMsgKey(MsgId), PipeId); DestPtr->Active = CFE_SB_INACTIVE; - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), true); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); ASSERT(CFE_SB_SendMsg(TlmPktPtr)); @@ -3084,13 +3277,17 @@ void Test_SendMsg_SendWithMetadata(void) CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPktBufDesc.TlmPkt; int32 PipeDepth; + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + CFE_MSG_Size_t Size = sizeof(TlmPktBufDesc.TlmPkt); memset(&TlmPktBufDesc, 0, sizeof(TlmPktBufDesc)); PipeDepth = 2; SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "TestPipe")); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); - CFE_SB_InitMsg(&TlmPktBufDesc.TlmPkt, MsgId, - sizeof(TlmPktBufDesc.TlmPkt), true); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); ASSERT(CFE_SB_SendMsgFull(TlmPktPtr, CFE_SB_DO_NOT_INCREMENT, CFE_SB_SEND_ZEROCOPY)); @@ -3110,6 +3307,8 @@ void Test_SendMsg_MaxMsgSizePlusOne_ZeroCopy(void) CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr; + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + CFE_MSG_Size_t Size = CFE_MISSION_SB_MAX_SB_MSG_SIZE + 1; TlmPktPtr = CFE_SB_ZeroCopyGetPtr(sizeof(SB_UT_Test_Tlm_t), (CFE_SB_ZeroCopyHandle_t *) &TlmPkt); @@ -3119,7 +3318,10 @@ void Test_SendMsg_MaxMsgSizePlusOne_ZeroCopy(void) } else { - CFE_SB_InitMsg(TlmPktPtr, MsgId, CFE_MISSION_SB_MAX_SB_MSG_SIZE + 1, false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + ASSERT_EQ(CFE_SB_SendMsgFull(TlmPktPtr, CFE_SB_INCREMENT_TLM, CFE_SB_SEND_ZEROCOPY), CFE_SB_MSG_TOO_BIG); @@ -3140,6 +3342,8 @@ void Test_SendMsg_NoSubscribers_ZeroCopy(void) CFE_SB_MsgId_t MsgId = SB_UT_TLM_MID; SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr; + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + CFE_MSG_Size_t Size = sizeof(TlmPkt); TlmPktPtr = CFE_SB_ZeroCopyGetPtr(sizeof(SB_UT_Test_Tlm_t), (CFE_SB_ZeroCopyHandle_t *) &TlmPkt); @@ -3149,7 +3353,10 @@ void Test_SendMsg_NoSubscribers_ZeroCopy(void) } else { - CFE_SB_InitMsg(TlmPktPtr, MsgId, sizeof(SB_UT_Test_Tlm_t), true); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + ASSERT(CFE_SB_SendMsgFull(TlmPktPtr, CFE_SB_INCREMENT_TLM, CFE_SB_SEND_ZEROCOPY)); } @@ -3292,9 +3499,13 @@ void Test_RcvMsg_PendForever(void) CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; CFE_SB_PipeD_t *PipeDscPtr; uint32 PipeDepth = 10; + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + CFE_MSG_Size_t Size = sizeof(TlmPkt); SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "RcvMsgTestPipe")); - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), true); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); SETUP(CFE_SB_SendMsg(TlmPktPtr)); @@ -3377,29 +3588,14 @@ void Test_RcvMsg_InvalidBufferPtr(void) void Test_SB_Utils(void) { SB_UT_ADD_SUBTEST(Test_CFE_SB_InitMsg); - SB_UT_ADD_SUBTEST(Test_CFE_SB_MsgHdrSize_Cmd); - SB_UT_ADD_SUBTEST(Test_CFE_SB_MsgHdrSize_Tlm); - SB_UT_ADD_SUBTEST(Test_CFE_SB_GetUserData_Cmd); - SB_UT_ADD_SUBTEST(Test_CFE_SB_GetUserData_CmdNoSecHdr); - SB_UT_ADD_SUBTEST(Test_CFE_SB_GetUserData_Tlm); - SB_UT_ADD_SUBTEST(Test_CFE_SB_GetUserData_TlmNoSecHdr); + SB_UT_ADD_SUBTEST(Test_CFE_SB_MsgHdrSize); + SB_UT_ADD_SUBTEST(Test_CFE_SB_GetUserData); SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetMsgId); - SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetUserDataLength_Cmd); - SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetUserDataLength_CmdNoSecHdr); - SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetUserDataLength_Tlm); - SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetUserDataLength_TlmNoSecHdr); + SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetUserDataLength); SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetTotalMsgLength); - SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetMsgTime_Cmd); - SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetMsgTime_CmdNoSecHdr); - SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetMsgTime_Tlm); - SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetMsgTime_TlmNoSecHdr); - SB_UT_ADD_SUBTEST(Test_CFE_SB_TimeStampMsg); - SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetCmdCode_Cmd); - SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetCmdCode_NonCmd); - SB_UT_ADD_SUBTEST(Test_CFE_SB_ChecksumUtils_Cmd); - SB_UT_ADD_SUBTEST(Test_CFE_SB_ChecksumUtils_CmdNoSecHdr); - SB_UT_ADD_SUBTEST(Test_CFE_SB_ChecksumUtils_Tlm); - SB_UT_ADD_SUBTEST(Test_CFE_SB_ChecksumUtils_TlmNoSecHdr); + SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetMsgTime); + SB_UT_ADD_SUBTEST(Test_CFE_SB_SetGetCmdCode); + SB_UT_ADD_SUBTEST(Test_CFE_SB_ChecksumUtils); SB_UT_ADD_SUBTEST(Test_CFE_SB_ValidateMsgId); } /* end Test_SB_Utils */ @@ -3408,170 +3604,69 @@ void Test_SB_Utils(void) */ void Test_CFE_SB_InitMsg(void) { - SB_UT_ADD_SUBTEST(Test_CFE_SB_InitMsg_True); - SB_UT_ADD_SUBTEST(Test_CFE_SB_InitMsg_False); -} /* end Test_CFE_SB_InitMsg */ - -/* -** Test message initialization, clearing the message content -*/ -void Test_CFE_SB_InitMsg_True(void) -{ - SB_UT_Test_Cmd_t SBCmd; - CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - - /* Set entire cmd packet to all f's */ - memset(SBCmdPtr, 0xff, sizeof(SBCmd)); - CFE_SB_InitMsg(SBCmdPtr, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), sizeof(SBCmd), true); - ASSERT_EQ(SBCmd.Cmd32Param1, 0); - ASSERT_EQ(SBCmd.Cmd16Param1, 0); - ASSERT_EQ(SBCmd.Cmd16Param2, 0); - ASSERT_EQ(SBCmd.Cmd8Param1, 0); - ASSERT_EQ(SBCmd.Cmd8Param2, 0); - ASSERT_EQ(SBCmd.Cmd8Param3, 0); - ASSERT_EQ(SBCmd.Cmd8Param4, 0); - -} /* end Test_CFE_SB_InitMsg_True */ - -/* -** Test message initialization, leaving the message content unchanged -*/ -void Test_CFE_SB_InitMsg_False(void) -{ - SB_UT_Test_Cmd_t SBCmd; - CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - - /* Set entire cmd packet to all f's */ - memset(SBCmdPtr, 0xff, sizeof(SBCmd)); - CFE_SB_InitMsg(SBCmdPtr, CFE_SB_ValueToMsgId(CFE_SB_CMD_MID), sizeof(SBCmd), false); + CFE_MSG_Message_t msg; - ASSERT_EQ(SBCmd.Cmd32Param1, 0xffffffff); - ASSERT_EQ(SBCmd.Cmd16Param1, 0xffff); - ASSERT_EQ(SBCmd.Cmd16Param2, 0xffff); - ASSERT_EQ(SBCmd.Cmd8Param1, 0xff); - ASSERT_EQ(SBCmd.Cmd8Param2, 0xff); - ASSERT_EQ(SBCmd.Cmd8Param3, 0xff); - ASSERT_EQ(SBCmd.Cmd8Param4, 0xff); + /* Pass through function */ + CFE_SB_InitMsg(&msg, CFE_SB_ValueToMsgId(0), 0, false); - -} /* end Test_CFE_SB_InitMsg_False */ +} /* end Test_CFE_SB_InitMsg */ /* ** Test getting the size of a command/telemetry message header */ -void Test_CFE_SB_MsgHdrSize_Cmd(void) -{ - SB_UT_Test_Cmd_t testCmd; - CFE_SB_MsgPtr_t MsgPtr = (CFE_SB_MsgPtr_t)&testCmd; - - /* Test for cmds w/sec hdr */ - CFE_SB_InitMsg(MsgPtr, SB_UT_CMD_MID, sizeof(testCmd), true); - ASSERT_EQ(CFE_SB_MsgHdrSize(MsgPtr), sizeof(CFE_SB_CmdHdr_t)); - - /* Test for cmds wo/sec hdr */ - CFE_MSG_SetHasSecondaryHeader(MsgPtr, false); - ASSERT_EQ(CFE_SB_MsgHdrSize(MsgPtr), sizeof(CCSDS_SpacePacket_t)); +void Test_CFE_SB_MsgHdrSize(void) +{ + CFE_SB_Msg_t msg; + bool hassec; + CFE_MSG_Type_t type; + + /* No secondary */ + hassec = false; + type = CFE_MSG_Type_Invalid; + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); + ASSERT_EQ(CFE_SB_MsgHdrSize(&msg), sizeof(CCSDS_SpacePacket_t)); + + /* Has secondary, tlm type */ + hassec = true; + type = CFE_MSG_Type_Tlm; + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); + ASSERT_EQ(CFE_SB_MsgHdrSize(&msg), sizeof(CFE_SB_TlmHdr_t)); + + /* Has secondary, cmd type */ + type = CFE_MSG_Type_Cmd; + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); + ASSERT_EQ(CFE_SB_MsgHdrSize(&msg), sizeof(CFE_SB_CmdHdr_t)); + + /* Has secondary, invalid type */ + type = CFE_MSG_Type_Invalid; + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); + ASSERT_EQ(CFE_SB_MsgHdrSize(&msg), 0); } /* end Test_CFE_SB_MsgHdrSize */ -void Test_CFE_SB_MsgHdrSize_Tlm(void) -{ - SB_UT_Test_Tlm_t testTlm; - CFE_SB_MsgPtr_t MsgPtr = (CFE_SB_MsgPtr_t)&testTlm; - - /* Test for tlm w/sec hdr */ - CFE_SB_InitMsg(MsgPtr, SB_UT_TLM_MID, sizeof(testTlm), true); - ASSERT_EQ(CFE_SB_MsgHdrSize(MsgPtr), sizeof(CFE_SB_TlmHdr_t)); - - /* Test for tlm wo/sec hdr */ - CFE_MSG_SetHasSecondaryHeader(MsgPtr, false); - ASSERT_EQ(CFE_SB_MsgHdrSize(MsgPtr), sizeof(CCSDS_SpacePacket_t)); - -} /* end Test_CFE_SB_MsgHdrSize_Tlm */ - /* ** Test getting a pointer to the user data portion of a message */ -void Test_CFE_SB_GetUserData_Cmd(void) -{ - SB_UT_Test_Cmd_t SBCmd; - CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - uint8 *ActualAdrReturned; - uint8 *ExpAdrReturned; - - /* Test address returned for cmd pkts w/sec hdr */ - ExpAdrReturned = (uint8 *) SBCmdPtr + sizeof(CFE_SB_CmdHdr_t); - - CFE_SB_InitMsg(SBCmdPtr, SB_UT_CMD_MID, sizeof(SB_UT_Test_Cmd_t), true); - ActualAdrReturned = CFE_SB_GetUserData(SBCmdPtr); - - UtAssert_True(ActualAdrReturned == ExpAdrReturned, - "Address of data for commands with secondary header is " - "packet address + 8\n PktAddr %p, Rtn %p, Exp %p", - (void *) SBCmdPtr, ActualAdrReturned, ExpAdrReturned); - - -} /* end Test_CFE_SB_GetUserData */ - -void Test_CFE_SB_GetUserData_CmdNoSecHdr(void) -{ - SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt; - CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t)&SBNoSecHdrPkt; - uint8 *ActualAdrReturned; - uint8 *ExpAdrReturned; - - /* Test address returned for cmd pkts wo/sec hdr */ - CFE_SB_InitMsg(SBNoSecHdrPktPtr, SB_UT_CMD_MID, sizeof(SBNoSecHdrPkt), true); - CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); - - ActualAdrReturned = CFE_SB_GetUserData(SBNoSecHdrPktPtr); - ExpAdrReturned = (uint8 *) SBNoSecHdrPktPtr + sizeof(CCSDS_SpacePacket_t); - - UtAssert_True(ActualAdrReturned == ExpAdrReturned, - "Address of data for commands without secondary header is " - "packet address + CCSDS header(s)\n PktAddr %p, Rtn %p, Exp %p", - (void *) SBNoSecHdrPktPtr, ActualAdrReturned, ExpAdrReturned); - -} /* end Test_CFE_SB_GetUserData */ - -void Test_CFE_SB_GetUserData_Tlm(void) +void Test_CFE_SB_GetUserData(void) { - SB_UT_Test_Tlm_t SBTlm; - CFE_SB_MsgPtr_t SBTlmPtr = (CFE_SB_MsgPtr_t) &SBTlm; - uint8 *ActualAdrReturned; + CFE_SB_Msg_t msg; uint8 *ExpAdrReturned; + bool hassec; + CFE_MSG_Type_t type = CFE_MSG_Type_Invalid; - /* Test address returned for tlm pkts w/sec hdr */ - CFE_SB_InitMsg(SBTlmPtr, SB_UT_TLM_MID, sizeof(SB_UT_Test_Tlm_t), true); - ActualAdrReturned = CFE_SB_GetUserData(SBTlmPtr); + /* No secondary */ + hassec = false; + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); - ExpAdrReturned = (uint8 *) SBTlmPtr + sizeof(CFE_SB_TlmHdr_t); + /* Expected return */ + ExpAdrReturned = (uint8 *)&msg + sizeof(CCSDS_SpacePacket_t); - UtAssert_True(ActualAdrReturned == ExpAdrReturned, - "Address of data for telemetry packets with secondary header " - "is Pkt Addr + 12\n PktAddr %p, Rtn %p, Exp %p", - (void *) SBTlmPtr, ActualAdrReturned, ExpAdrReturned); - -} /* end Test_CFE_SB_GetUserData */ - -void Test_CFE_SB_GetUserData_TlmNoSecHdr(void) -{ - SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt; - CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t) &SBNoSecHdrPkt; - uint8 *ActualAdrReturned; - uint8 *ExpAdrReturned; - - /* Test address returned for tlm pkts wo/sec hdr */ - CFE_SB_InitMsg(SBNoSecHdrPktPtr, SB_UT_TLM_MID, sizeof(SBNoSecHdrPkt), true); - CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); - - ActualAdrReturned = CFE_SB_GetUserData(SBNoSecHdrPktPtr); - ExpAdrReturned = (uint8 *) SBNoSecHdrPktPtr + sizeof(CCSDS_SpacePacket_t); - - UtAssert_True(ActualAdrReturned == ExpAdrReturned, - "Address of data for telemetry packets without secondary " - "header is Pkt Addr + 6\n PktAddr %p, Rtn %p, Exp %p", - (void *) SBNoSecHdrPktPtr, ActualAdrReturned, ExpAdrReturned); + ASSERT_TRUE(CFE_SB_GetUserData(&msg) == ExpAdrReturned); } /* end Test_CFE_SB_GetUserData */ @@ -3580,527 +3675,130 @@ void Test_CFE_SB_GetUserData_TlmNoSecHdr(void) */ void Test_CFE_SB_SetGetMsgId(void) { - SB_UT_Test_Cmd_t SBCmd; - CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - CFE_SB_MsgId_t MsgIdReturned; - CFE_SB_MsgId_t MsgIdSet; - uint16 Value[] = {0, 0x700, 0x7FF /* Max */, 0x800 /* Invalid */, 0xFFFF /* Invalid */}; - int i; - - /* Test setting and getting the message ID of a message */ - - /* Set entire command packet to all f's */ - memset(SBCmdPtr, 0xff, sizeof(SBCmd)); - MsgIdSet = CFE_SB_ValueToMsgId(CFE_SB_CMD_MID); - CFE_SB_SetMsgId(SBCmdPtr, MsgIdSet); - MsgIdReturned = CFE_SB_GetMsgId(SBCmdPtr); + CFE_MSG_Message_t msg; + CFE_SB_MsgId_t msgid = 5; - UtAssert_True(CFE_SB_MsgId_Equal(MsgIdReturned, MsgIdSet), - "CFE_SB_GetMsgId returned 0x%lx, expected 0x%lx", - (unsigned long) CFE_SB_MsgIdToValue(MsgIdReturned), - (unsigned long) CFE_SB_MsgIdToValue(MsgIdSet)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &msgid, sizeof(msgid), false); - - /* Test setting and getting the message ID of a message looping through - * all values - */ - - /* Looping through values */ - for (i = 0; i < sizeof(Value)/sizeof(Value[0]); i++) - { - MsgIdSet = CFE_SB_ValueToMsgId(Value[i]); - CFE_SB_SetMsgId(SBCmdPtr, MsgIdSet); - MsgIdReturned = CFE_SB_GetMsgId(SBCmdPtr); - - if (Value[i] < 0x800) - { - ASSERT_TRUE(CFE_SB_MsgId_Equal(MsgIdReturned, MsgIdSet)); - } - } + /* Pass through functions */ + ASSERT_EQ(CFE_SB_GetMsgId(&msg), msgid); + CFE_SB_SetMsgId(&msg, CFE_SB_ValueToMsgId(0)); } /* end Test_CFE_SB_SetGetMsgId */ -/* Local helper function for user data length tests */ -/* Runs standard tests given an initialized message */ -void Util_CFE_SB_SetGetUserDataLength(CFE_SB_Msg_t *MsgPtr, uint16 SecHdrSize) -{ - uint16 SetSize[] = {0, 1, 0x8000, 0 /* Max calculated */, 0xFFFF}; - uint16 SizeReturned; - uint16 ActualPktLenField; - uint16 ExpPktLenField; - int i; - bool checkrtn; - - /* Max valid value */ - if (SecHdrSize == 0) - { - SetSize[3] = 0xFFFF; - } - else - { - SetSize[3] = 0xFFFF - SecHdrSize + 1; - } - - for (i = 0; i < sizeof(SetSize)/sizeof(SetSize[0]); i++) - { - /* CCSDS requires >= 1 byte payload, less won't update size */ - /* Over max possible also won't update size */ - if ((SecHdrSize + SetSize[i] < 1) || (SetSize[i] + SecHdrSize > 0x10000)) - { - ExpPktLenField = UT_GetActualPktLenField(MsgPtr); - checkrtn = false; - } - else - { - ExpPktLenField = SecHdrSize + SetSize[i] - 1; - checkrtn = true; - } - - CFE_SB_SetUserDataLength(MsgPtr, SetSize[i]); - SizeReturned = CFE_SB_GetUserDataLength(MsgPtr); - ActualPktLenField = UT_GetActualPktLenField(MsgPtr); - - if (checkrtn) - { - ASSERT_EQ (SizeReturned, SetSize[i]); - } - ASSERT_EQ (ActualPktLenField, ExpPktLenField); - } - -} /* end Util_CFE_SB_SetGetUserDataLength */ - /* -** Test setting and getting the user data size of a message +** Test setting and getting the user data length of a message */ -void Test_CFE_SB_SetGetUserDataLength_Cmd(void) -{ - SB_UT_Test_Cmd_t SBCmd; - CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - - /* Init cmd pkt w/ sec hdr */ - CFE_SB_InitMsg(SBCmdPtr, SB_UT_CMD_MID, sizeof(SB_UT_Test_Cmd_t), true); - - /* Calculation for secondary header accounts for possible padding */ - Util_CFE_SB_SetGetUserDataLength(SBCmdPtr, sizeof(CFE_SB_CmdHdr_t) - sizeof(CCSDS_PrimaryHeader_t)); - -} /* end Test_CFE_SB_SetGetUserDataLength */ - -void Test_CFE_SB_SetGetUserDataLength_CmdNoSecHdr(void) -{ - SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt = {0}; - CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t) &SBNoSecHdrPkt; - - /* Init cmd pkt w/o sec hdr */ - CFE_SB_InitMsg(SBNoSecHdrPktPtr, SB_UT_CMD_MID, sizeof(SBNoSecHdrPkt), true); - CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); - - Util_CFE_SB_SetGetUserDataLength(SBNoSecHdrPktPtr, sizeof(CCSDS_SpacePacket_t) - sizeof(CCSDS_PrimaryHeader_t)); - -} /* end Test_CFE_SB_SetGetUserDataLength */ - -void Test_CFE_SB_SetGetUserDataLength_Tlm(void) -{ - SB_UT_Test_Tlm_t SBTlm; - CFE_SB_MsgPtr_t SBTlmPtr = (CFE_SB_MsgPtr_t) &SBTlm; - - /* Init tlm pkts w/ sec hdr */ - CFE_SB_InitMsg(SBTlmPtr, SB_UT_TLM_MID, sizeof(SB_UT_Test_Tlm_t), true); - - /* Calculation for secondary header accounts for possible padding */ - Util_CFE_SB_SetGetUserDataLength(SBTlmPtr, sizeof(CFE_SB_TlmHdr_t) - sizeof(CCSDS_PrimaryHeader_t)); - -} /* end Test_CFE_SB_SetGetUserDataLength */ - -void Test_CFE_SB_SetGetUserDataLength_TlmNoSecHdr(void) +void Test_CFE_SB_SetGetUserDataLength(void) { - SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt; - CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t) &SBNoSecHdrPkt; + CFE_MSG_Message_t msg; + CFE_MSG_Size_t size = 10; + CFE_MSG_Type_t type = CFE_MSG_Type_Invalid; + bool hassec = false; - /* Set up tlm pkts wo/sec hdr */ - CFE_SB_InitMsg(SBNoSecHdrPktPtr, SB_UT_TLM_MID, sizeof(SBNoSecHdrPkt), true); - CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); + /* Pass through functions */ + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &size, sizeof(size), false); + ASSERT_EQ(CFE_SB_GetUserDataLength(&msg), size - sizeof(CCSDS_SpacePacket_t)); - Util_CFE_SB_SetGetUserDataLength(SBNoSecHdrPktPtr, sizeof(CCSDS_SpacePacket_t) - sizeof(CCSDS_PrimaryHeader_t)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); + CFE_SB_SetUserDataLength(&msg, 0); -} /* end Test_CFE_SB_SetGetUserDataLength */ +} /* end Util_CFE_SB_SetGetUserDataLength */ /* ** Test setting and getting the total message size */ void Test_CFE_SB_SetGetTotalMsgLength(void) { - SB_UT_Test_Cmd_t SBCmd; - CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - - /* Known bug CFE_SB_GetTotalMsgLength won't do max CCSDS size */ - uint32 SetSize[] = {0 /* Invalid */, 1 /* Invalid */, 7 /* Min */, 8000, 0xFFFF}; - uint16 TotalMsgSizeReturned; - uint16 ActualPktLenField; - uint16 ExpPktLenField; - int i; - - /* - * Note this is no different for commands vs. telemetry vs. secondary header... - * This consolidates all the separate test cases - testing for different header types is redundant. - */ - CFE_SB_InitMsg(SBCmdPtr, SB_UT_CMD_MID, sizeof(SBCmd), true); - - for (i = 0; i < sizeof(SetSize)/sizeof(SetSize[0]); i++) - { - if (SetSize[i] < 7) /* Invalid size won't change packet value */ - { - ExpPktLenField = UT_GetActualPktLenField(SBCmdPtr); - } - else - { - ExpPktLenField = SetSize[i] - 7; /* TotalPktSize - 7 */ - } + CFE_MSG_Message_t msg; + CFE_MSG_Size_t size = 6; - CFE_SB_SetTotalMsgLength(SBCmdPtr, SetSize[i]); - TotalMsgSizeReturned = CFE_SB_GetTotalMsgLength(SBCmdPtr); - ActualPktLenField = UT_GetActualPktLenField(SBCmdPtr); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &size, sizeof(size), false); - ASSERT_EQ (TotalMsgSizeReturned, ExpPktLenField + 7); - ASSERT_EQ (ActualPktLenField, ExpPktLenField); - } + /* Pass through functions */ + ASSERT_EQ(CFE_SB_GetTotalMsgLength(&msg), size); + CFE_SB_SetTotalMsgLength(&msg, 0); } /* end Test_CFE_SB_SetGetTotalMsgLength */ -/* -** Test setting and getting the message time field -*/ -void Test_CFE_SB_SetGetMsgTime_Cmd(void) -{ - SB_UT_Test_Cmd_t SBCmd; - CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - CFE_TIME_SysTime_t SetTime, GetTime; - - /* Set MsgId to all f's */ - memset(SBCmdPtr, 0xff, sizeof(SBCmd)); - - /* Set MsgId */ - CFE_SB_SetMsgId(SBCmdPtr, SB_UT_CMD_MID); - - SetTime.Seconds = 0x4321; - SetTime.Subseconds = 0x8765; - /* Verify CFE_SB_SetMsgTime returns CFE_SB_WRONG_MSG_TYPE for cmd - * pkts w/sec hdr */ - ASSERT_EQ(CFE_SB_SetMsgTime(SBCmdPtr, SetTime), CFE_SB_WRONG_MSG_TYPE); - - GetTime.Seconds = 0xffff; - GetTime.Subseconds = 0xffff; - GetTime = CFE_SB_GetMsgTime(SBCmdPtr); - - /* Verify the call to CFE_SB_GetMsgTime returns a time value of zero */ - ASSERT_EQ(GetTime.Seconds, 0); - ASSERT_EQ(GetTime.Subseconds, 0); - -} /* end Test_CFE_SB_SetGetMsgTime */ - -void Test_CFE_SB_SetGetMsgTime_CmdNoSecHdr(void) -{ - SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt; - CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t) &SBNoSecHdrPkt; - CFE_TIME_SysTime_t SetTime, GetTime; - - /* Set MsgId to all f's */ - memset(SBNoSecHdrPktPtr, 0xff, sizeof(SBNoSecHdrPkt)); - - /* Set MsgId */ - CFE_SB_SetMsgId(SBNoSecHdrPktPtr, SB_UT_TLM_MID); - CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); - - SetTime.Seconds = 0x4321; - SetTime.Subseconds = 0x8765; - /* Verify CFE_SB_SetMsgTime returns CFE_SB_WRONG_MSG_TYPE for cmd - * pkts wo/sec hdr */ - ASSERT_EQ(CFE_SB_SetMsgTime(SBNoSecHdrPktPtr, SetTime), CFE_SB_WRONG_MSG_TYPE); - - GetTime.Seconds = 0xffff; - GetTime.Subseconds = 0xffff; - GetTime = CFE_SB_GetMsgTime(SBNoSecHdrPktPtr); - - /* Verify the call to CFE_SB_GetMsgTime returns a time value of zero */ - ASSERT_EQ(GetTime.Seconds, 0); - ASSERT_EQ(GetTime.Subseconds, 0); - -} /* end Test_CFE_SB_SetGetMsgTime */ - -void Test_CFE_SB_SetGetMsgTime_Tlm(void) -{ - SB_UT_Test_Tlm_t SBTlm; - CFE_SB_MsgPtr_t SBTlmPtr = (CFE_SB_MsgPtr_t) &SBTlm; - CFE_TIME_SysTime_t SetTime, GetTime; - - /* Begin test for tlm pkts w/sec hdr */ - - /* Set MsgId to all f's */ - memset(SBTlmPtr, 0xff, sizeof(SBTlm)); - - /* Set MsgId to 0x0805 */ - CFE_SB_SetMsgId(SBTlmPtr, SB_UT_TLM_MID); - SetTime.Seconds = 0x01234567; - SetTime.Subseconds = 0x89abcdef; - /* Verify CFE_SB_SetMsgTime returns CFE_SUCCESS for tlm pkts w/sec hdr */ - ASSERT_EQ(CFE_SB_SetMsgTime(SBTlmPtr, SetTime), CFE_SUCCESS); - - GetTime.Seconds = 0xffff; - GetTime.Subseconds = 0xffff; - GetTime = CFE_SB_GetMsgTime(SBTlmPtr); - - /* Verify CFE_SB_GetMsgTime returns the SetTime value w/2 LSBytes - * of subseconds zeroed out - */ - ASSERT_EQ(GetTime.Seconds, SetTime.Seconds); - ASSERT_EQ(GetTime.Subseconds, SetTime.Subseconds & 0xffff0000); - -} /* end Test_CFE_SB_SetGetMsgTime */ - -void Test_CFE_SB_SetGetMsgTime_TlmNoSecHdr(void) +void Test_CFE_SB_SetGetMsgTime(void) { - SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt; - CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t) &SBNoSecHdrPkt; - CFE_TIME_SysTime_t SetTime, GetTime; - - /* Set MsgId to all f's */ - memset(SBNoSecHdrPktPtr, 0xff, sizeof(SBNoSecHdrPkt)); + CFE_MSG_Message_t msg; + CFE_TIME_SysTime_t time = {0xb, 0xa0000}; + CFE_TIME_SysTime_t actual; - /* Set MsgId to 0x0005 */ - CFE_SB_SetMsgId(SBNoSecHdrPktPtr, SB_UT_TLM_MID); - CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); - SetTime.Seconds = 0x01234567; - SetTime.Subseconds = 0x89abcdef; - ASSERT_EQ(CFE_SB_SetMsgTime(SBNoSecHdrPktPtr, SetTime), CFE_SB_WRONG_MSG_TYPE); - GetTime.Seconds = 0xffff; - GetTime.Subseconds = 0xffff; - GetTime = CFE_SB_GetMsgTime(SBNoSecHdrPktPtr); + /* Set up buffer */ + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgTime), &time, sizeof(time), false); - /* Verify the call to CFE_SB_GetMsgTime returns a time value of zero */ - ASSERT_EQ(GetTime.Seconds, 0); - ASSERT_EQ(GetTime.Subseconds, 0); + /* Pass through functions */ + actual = CFE_SB_GetMsgTime(&msg); + ASSERT_TRUE(actual.Seconds == time.Seconds); + ASSERT_TRUE(actual.Subseconds == time.Subseconds); + CFE_SB_SetMsgTime(&msg, time); + CFE_SB_TimeStampMsg(&msg); } /* end Test_CFE_SB_SetGetMsgTime */ -/* -** Test setting the time field to the current time -*/ -void Test_CFE_SB_TimeStampMsg(void) -{ - SB_UT_Test_Tlm_t SBTlm; - CFE_SB_MsgPtr_t SBTlmPtr = (CFE_SB_MsgPtr_t) &SBTlm; - CFE_TIME_SysTime_t GetTime; - uint32 ExpSecs; - - /* Note: Only Tlm Pkt with Sec Hdr is tested here because this function - * (Test_CFE_SB_TimeStampMsg) is simply a call to - * Test_CFE_SB_SetGetMsgTime. Test_CFE_SB_SetGetMsgTime has covered - * the other pkt types - */ - - /* Set MsgId to all f's */ - memset(SBTlmPtr, 0xff, sizeof(SBTlm)); - - /* Set MsgId to 0x0805 */ - CFE_SB_SetMsgId(SBTlmPtr, SB_UT_TLM_MID); - CFE_SB_TimeStampMsg(SBTlmPtr); - GetTime.Seconds = 0xffff; - GetTime.Subseconds = 0xffff; - GetTime = CFE_SB_GetMsgTime(SBTlmPtr); - ExpSecs = GetTime.Seconds + 1; - CFE_SB_TimeStampMsg(SBTlmPtr); - GetTime.Seconds = 0xffff; - GetTime.Subseconds = 0xffff; - GetTime = CFE_SB_GetMsgTime(SBTlmPtr); - - /* Verify CFE_SB_GetMsgTime returns the time value expected by - * CFE_TIME_GetTime. The stub for CFE_TIME_GetTime simply increments - * the seconds cnt on each call - */ - ASSERT_EQ(GetTime.Seconds, ExpSecs); - ASSERT_EQ(GetTime.Subseconds, 0); - -} /* end Test_CFE_SB_TimeStampMsg */ - -/* -** Test setting and getting the opcode field of message -*/ -void Test_CFE_SB_SetGetCmdCode_Cmd(void) +void Test_CFE_SB_SetGetCmdCode(void) { - SB_UT_Test_Cmd_t SBCmd; - CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - uint16 CmdCodeSet[] = {0, 1, 0x70, 0x7f /* Max */, 0x80 /* Invalid */, 0xFFFF /* Invalid */}; - uint16 ExpCmdCode; - int i; + CFE_MSG_Message_t msg; + CFE_MSG_FcnCode_t fcncode = 7; - /* Set MsgId to all f's */ - memset(SBCmdPtr, 0xff, sizeof(SBCmd)); - CFE_SB_InitMsg(SBCmdPtr, SB_UT_CMD_MID, sizeof(SB_UT_Test_Cmd_t), false); - CFE_MSG_SetHasSecondaryHeader(SBCmdPtr, true); + /* Set up buffer */ + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &fcncode, sizeof(fcncode), false); - for (i = 0; i < sizeof(CmdCodeSet)/sizeof(CmdCodeSet[0]); i++) - { - if (CmdCodeSet[i] <= 0x7f) /* Valid */ - { - ASSERT_EQ(CFE_SB_SetCmdCode(SBCmdPtr, CmdCodeSet[i]), CFE_SUCCESS); - ASSERT_EQ(CFE_SB_GetCmdCode(SBCmdPtr), CmdCodeSet[i]); - ASSERT_EQ(UT_GetActualCmdCodeField(SBCmdPtr), CmdCodeSet[i]); - } - else /* Invalid */ - { - /* When invalid command code shouldn't change */ - ExpCmdCode = UT_GetActualCmdCodeField(SBCmdPtr); - ASSERT_EQ(CFE_SB_SetCmdCode(SBCmdPtr, CmdCodeSet[i]), CFE_SB_BAD_ARGUMENT); - ASSERT_EQ(CFE_SB_GetCmdCode(SBCmdPtr), ExpCmdCode); - ASSERT_EQ(UT_GetActualCmdCodeField(SBCmdPtr), ExpCmdCode); - } - } + /* Pass through functions */ + ASSERT_EQ(CFE_SB_GetCmdCode(&msg), fcncode); + CFE_SB_SetCmdCode(&msg, 0); } /* end Test_CFE_SB_SetGetCmdCode */ -void Test_CFE_SB_SetGetCmdCode_NonCmd(void) -{ - SB_UT_Test_Tlm_t SBTlm; - CFE_SB_MsgPtr_t SBTlmPtr = (CFE_SB_MsgPtr_t) &SBTlm; - SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt; - CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t) &SBNoSecHdrPkt; - - /* Loop through all cmd code values (plus a few invalid) for cmd - * pkts wo/sec hdr - */ - - /* Set MsgId to all f's */ - memset(SBNoSecHdrPktPtr, 0xff, sizeof(SB_UT_TstPktWoSecHdr_t)); - memset(SBTlmPtr, 0xff, sizeof(SBTlm)); - - /* Set MsgId */ - CFE_SB_SetMsgId(SBNoSecHdrPktPtr, SB_UT_CMD_MID); - CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); - - ASSERT_EQ(CFE_SB_SetCmdCode(SBNoSecHdrPktPtr, 11), CFE_SB_WRONG_MSG_TYPE); - ASSERT_EQ(CFE_SB_GetCmdCode(SBNoSecHdrPktPtr), 0); - - - CFE_SB_SetMsgId(SBTlmPtr, SB_UT_TLM_MID); - CFE_SB_SetMsgId(SBTlmPtr, true); - - ASSERT_EQ(CFE_SB_SetCmdCode(SBTlmPtr, 22), CFE_SB_WRONG_MSG_TYPE); - ASSERT_EQ(CFE_SB_GetCmdCode(SBTlmPtr), 0); - -} /* end Test_CFE_SB_SetGetCmdCode */ /* -** Test generating, setting, getting, and validating a checksum field -** for a message -*/ -void Test_CFE_SB_ChecksumUtils_Cmd(void) -{ - SB_UT_Test_Cmd_t SBCmd; - CFE_SB_MsgPtr_t SBCmdPtr = (CFE_SB_MsgPtr_t) &SBCmd; - uint16 ExpRtnFrmGet; - - /* Initialize pkt, setting data to zero */ - CFE_SB_InitMsg(SBCmdPtr, SB_UT_CMD_MID4, sizeof(SBCmd), true); - - /* Set checksum field */ - +** Test checksum utils +*/ +void Test_CFE_SB_ChecksumUtils(void) +{ + CFE_SB_CmdHdr_t SBCmd; + CFE_SB_Msg_t *SBCmdPtr = (CFE_SB_Msg_t *) &SBCmd; + bool hassec; + CFE_MSG_Type_t type; + bool validcksum; + + /* Has secondary, tlm type */ + hassec = true; + type = CFE_MSG_Type_Tlm; + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); + ASSERT_EQ(CFE_SB_GetChecksum(SBCmdPtr), 0); + + /* No secondary, cmd type */ + hassec = false; + type = CFE_MSG_Type_Cmd; + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); + ASSERT_EQ(CFE_SB_GetChecksum(SBCmdPtr), 0); + + /* Valid, 0 */ + hassec = true; + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); + memset(&SBCmd, 1, sizeof(SBCmd)); + ASSERT_EQ(CFE_SB_GetChecksum(SBCmdPtr), 1); + + /* Valid, 0xFF */ + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetHasSecondaryHeader), &hassec, sizeof(hassec), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetType), &type, sizeof(type), false); + memset(&SBCmd, 0xFF, sizeof(SBCmd)); + ASSERT_EQ(CFE_SB_GetChecksum(SBCmdPtr), 0xFF); + + /* Execute passthrough functions */ + validcksum = true; CFE_SB_GenerateChecksum(SBCmdPtr); - -#ifndef MESSAGE_FORMAT_IS_CCSDS_VER_2 - ExpRtnFrmGet = 0x2f; -#else - ExpRtnFrmGet = 0x5D; -#endif - ASSERT_EQ(CFE_SB_GetChecksum(SBCmdPtr), ExpRtnFrmGet); - - /* Validation expected to return true */ - ASSERT_TRUE(CFE_SB_ValidateChecksum(SBCmdPtr)); - - /* Flip 1 bit in pkt and verify checksum is no longer valid. - * Validation expected to return false - */ - SBCmdPtr->Byte[0] ^= 0x02; - - ASSERT_TRUE(!CFE_SB_ValidateChecksum(SBCmdPtr)); - -} /* end Test_CFE_SB_ChecksumUtils */ - -void Test_CFE_SB_ChecksumUtils_CmdNoSecHdr(void) -{ - SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt; - CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t) &SBNoSecHdrPkt; - - /* Begin test for cmd pkts wo/sec hdr */ - - /* Initialize pkt, setting data to zero */ - CFE_SB_InitMsg(SBNoSecHdrPktPtr, SB_UT_BARE_CMD_MID3, - sizeof(SBNoSecHdrPkt), true); - - CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); - - /* Set checksum field */ - CFE_SB_GenerateChecksum(SBNoSecHdrPktPtr); - ASSERT_EQ(CFE_SB_GetChecksum(SBNoSecHdrPktPtr), 0); - - /* Validation expected to return false */ - ASSERT_TRUE(!CFE_SB_ValidateChecksum(SBNoSecHdrPktPtr)); - - /* Flip 1 bit in pkt and verify checksum is no longer valid. - * Validation expected to return false - */ - SBNoSecHdrPktPtr->Byte[0] ^= 0x02; - - CFE_MSG_SetHasSecondaryHeader(SBNoSecHdrPktPtr, false); - ASSERT_TRUE(!CFE_SB_ValidateChecksum(SBNoSecHdrPktPtr)); - -} /* end Test_CFE_SB_ChecksumUtils */ - -void Test_CFE_SB_ChecksumUtils_Tlm(void) -{ - SB_UT_Test_Tlm_t SBTlm; - CFE_SB_MsgPtr_t SBTlmPtr = (CFE_SB_MsgPtr_t) &SBTlm; - - /* Begin test for tlm pkts w/sec hdr */ - - /* Initialize pkt, setting data to zero */ - CFE_SB_InitMsg(SBTlmPtr, CFE_SB_ValueToMsgId(0x0805), sizeof(SBTlm), true); - - /* Set checksum field */ - CFE_SB_GenerateChecksum(SBTlmPtr); - ASSERT_EQ(CFE_SB_GetChecksum(SBTlmPtr), 0); - - /* Validation expected to return false */ - ASSERT_TRUE(!CFE_SB_ValidateChecksum(SBTlmPtr)); - - /* Flip 1 bit in pkt and verify checksum is no longer valid. - * Validation expected to return false - */ - SBTlmPtr->Byte[0] ^= 0x02; - - ASSERT_TRUE(!CFE_SB_ValidateChecksum(SBTlmPtr)); - -} /* end Test_CFE_SB_ChecksumUtils */ - -void Test_CFE_SB_ChecksumUtils_TlmNoSecHdr(void) -{ - SB_UT_TstPktWoSecHdr_t SBNoSecHdrPkt; - CFE_SB_MsgPtr_t SBNoSecHdrPktPtr = (CFE_SB_MsgPtr_t) &SBNoSecHdrPkt; - - /* Begin test for tlm pkts wo/sec hdr */ - /* Initialize pkt, setting data to zero */ - CFE_SB_InitMsg(SBNoSecHdrPktPtr, SB_UT_BARE_TLM_MID3, - sizeof(SBNoSecHdrPkt), true); - - /* Setting checksum field */ - CFE_SB_GenerateChecksum(SBNoSecHdrPktPtr); - ASSERT_EQ(CFE_SB_GetChecksum(SBNoSecHdrPktPtr), 0); - - /* Validation expected to return false */ - ASSERT_TRUE(!CFE_SB_ValidateChecksum(SBNoSecHdrPktPtr)); - - /* Flip 1 bit in pkt and verify checksum is no longer valid. - * Validation expected to return false - */ - SBNoSecHdrPktPtr->Byte[0] ^= 0x02; - ASSERT_TRUE(!CFE_SB_ValidateChecksum(SBNoSecHdrPktPtr)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_ValidateChecksum), &validcksum, sizeof(validcksum), false); + ASSERT_EQ(CFE_SB_ValidateChecksum(SBCmdPtr), validcksum); } /* end Test_CFE_SB_ChecksumUtils */ @@ -4113,11 +3811,12 @@ void Test_CFE_SB_ValidateMsgId(void) /* Validate Msg Id */ MsgId = SB_UT_LAST_VALID_MID; - CFE_SB_ValidateMsgId(MsgId); + ASSERT_EQ(CFE_SB_ValidateMsgId(MsgId), CFE_SUCCESS); /* Test for invalid msg id */ MsgId = SB_UT_ALTERNATE_INVALID_MID; - CFE_SB_ValidateMsgId(MsgId); + ASSERT_EQ(CFE_SB_ValidateMsgId(MsgId), CFE_SB_FAILED); + } /* @@ -4327,9 +4026,19 @@ void Test_SB_SendMsgPaths_Nominal(void) SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; int32 PipeDepth = 2; + CFE_MSG_Size_t Size; + CFE_MSG_Type_t Type; + + /* For internal SendMsg call */ + MsgId = CFE_SB_ValueToMsgId(CFE_SB_HK_TLM_MID); + Size = sizeof(CFE_SB.HKTlmMsg); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + + /* For HK command processing */ + MsgId = CFE_SB_ValueToMsgId(CFE_SB_SEND_HK_MID); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); - CFE_SB_InitMsg(&NoParamCmd, CFE_SB_ValueToMsgId(CFE_SB_SEND_HK_MID), - sizeof(NoParamCmd), true); CFE_SB.CmdPipePktPtr = (CFE_SB_MsgPtr_t) &NoParamCmd; CFE_SB.StopRecurseFlags[1] |= CFE_BIT(CFE_SB_SEND_NO_SUBS_EID_BIT); CFE_SB_ProcessCmdPipePkt(); @@ -4338,8 +4047,18 @@ void Test_SB_SendMsgPaths_Nominal(void) CFE_SB.HKTlmMsg.Payload.MsgSendErrorCounter = 0; CFE_SB.StopRecurseFlags[1] |= CFE_BIT(CFE_SB_GET_BUF_ERR_EID_BIT); - MsgId = CFE_SB_GetMsgId((CFE_SB_MsgPtr_t) &CFE_SB.HKTlmMsg); - CFE_SB.MsgMap[CFE_SB_MsgKeyToValue(CFE_SB_ConvertMsgIdtoMsgKey(MsgId))] = CFE_SB_INVALID_ROUTE_IDX; + + /* For internal SendMsg call */ + MsgId = CFE_SB_ValueToMsgId(CFE_SB_HK_TLM_MID); + Size = sizeof(CFE_SB.HKTlmMsg); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + + /* For HK command processing */ + MsgId = CFE_SB_ValueToMsgId(CFE_SB_SEND_HK_MID); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + + CFE_SB.MsgMap[CFE_SB_MsgKeyToValue(CFE_SB_ConvertMsgIdtoMsgKey(CFE_SB_HK_TLM_MID))] = CFE_SB_INVALID_ROUTE_IDX; UT_SetDeferredRetcode(UT_KEY(CFE_ES_GetPoolBuf), 1, CFE_ES_ERR_MEM_BLOCK_SIZE); CFE_SB_ProcessCmdPipePkt(); ASSERT_EQ(CFE_SB.HKTlmMsg.Payload.MsgSendErrorCounter, 0); @@ -4352,10 +4071,18 @@ void Test_SB_SendMsgPaths_Nominal(void) /* Create a message ID with the command bit set and disable reporting */ MsgId = SB_UT_CMD_MID; + Size = sizeof(TlmPkt); + Type = CFE_MSG_Type_Cmd; CFE_SB.SenderReporting = 0; SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "TestPipe")); - SETUP(CFE_SB_Subscribe(MsgId, PipeId)); - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), true); + + /* Will fail because of deferred CFE_ES_GetPoolBuf failure return */ + ASSERT_EQ(CFE_SB_Subscribe(MsgId, PipeId), CFE_SB_BUF_ALOC_ERR); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + ASSERT(CFE_SB_SendMsg(TlmPktPtr)); EVTCNT(3); @@ -4370,19 +4097,27 @@ void Test_SB_SendMsgPaths_LimitErr(void) SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; int32 PipeDepth = 2; - + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + CFE_MSG_Size_t Size = sizeof(TlmPkt); /* Test inhibiting sending a "message ID limit error" message */ MsgId = SB_UT_TLM_MID; - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), false); SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "MsgLimTestPipe")); /* Set maximum allowed messages on the pipe at one time to 1 */ SETUP(CFE_SB_SubscribeEx(MsgId, PipeId, CFE_SB_Default_Qos, 1)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + /* First send should pass */ ASSERT(CFE_SB_SendMsg(TlmPktPtr)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + CFE_SB.StopRecurseFlags[1] |= CFE_BIT(CFE_SB_MSGID_LIM_ERR_EID_BIT); ASSERT(CFE_SB_SendMsg(TlmPktPtr)); CFE_SB.StopRecurseFlags[1] = 0; @@ -4401,16 +4136,25 @@ void Test_SB_SendMsgPaths_FullErr(void) SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; int32 PipeDepth = 2; + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + CFE_MSG_Size_t Size = sizeof(TlmPkt); /* Test inhibiting sending a "pipe full" message */ MsgId = SB_UT_TLM_MID; - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), true); SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "PipeFullTestPipe")); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + /* This send should pass */ ASSERT(CFE_SB_SendMsg(TlmPktPtr)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + /* Tell the QueuePut stub to return OS_QUEUE_FULL on its next call */ UT_SetDeferredRetcode(UT_KEY(OS_QueuePut), 1, OS_QUEUE_FULL); CFE_SB.StopRecurseFlags[1] |= CFE_BIT(CFE_SB_Q_FULL_ERR_EID_BIT); @@ -4431,17 +4175,27 @@ void Test_SB_SendMsgPaths_WriteErr(void) SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; int32 PipeDepth = 2; - + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + CFE_MSG_Size_t Size = sizeof(TlmPkt); /* Test inhibiting sending a "pipe write error" message */ MsgId = SB_UT_TLM_MID; SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "TestPipe")); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), false); UT_SetDeferredRetcode(UT_KEY(OS_QueuePut), 1, OS_ERROR); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + CFE_SB.StopRecurseFlags[1] |= CFE_BIT(CFE_SB_Q_WR_ERR_EID_BIT); ASSERT(CFE_SB_SendMsg(TlmPktPtr)); CFE_SB.StopRecurseFlags[1] = 0; + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + ASSERT(CFE_SB_SendMsg(TlmPktPtr)); EVTCNT(3); @@ -4459,15 +4213,19 @@ void Test_SB_SendMsgPaths_IgnoreOpt(void) SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; int32 PipeDepth = 2; - + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + CFE_MSG_Size_t Size = sizeof(TlmPkt); /* Setup Test skipping sending to a pipe when the pipe option is set to ignore */ MsgId = SB_UT_TLM_MID; - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), true); SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "SkipPipe")); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); SETUP(CFE_SB_SetPipeOpts(PipeId, CFE_SB_PIPEOPTS_IGNOREMINE)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); + /* Test skipping this pipe and the send should pass */ ASSERT(CFE_SB_SendMsg(TlmPktPtr)); @@ -4489,10 +4247,14 @@ void Test_RcvMsg_UnsubResubPath(void) SB_UT_Test_Tlm_t TlmPkt; CFE_SB_MsgPtr_t TlmPktPtr = (CFE_SB_MsgPtr_t) &TlmPkt; uint32 PipeDepth = 10; + CFE_MSG_Type_t Type = CFE_MSG_Type_Tlm; + CFE_MSG_Size_t Size = sizeof(TlmPkt); SETUP(CFE_SB_CreatePipe(&PipeId, PipeDepth, "RcvMsgTestPipe")); - CFE_SB_InitMsg(&TlmPkt, MsgId, sizeof(TlmPkt), true); SETUP(CFE_SB_Subscribe(MsgId, PipeId)); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &MsgId, sizeof(MsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &Size, sizeof(Size), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetTypeFromMsgId), &Type, sizeof(Type), false); SETUP(CFE_SB_SendMsg(TlmPktPtr)); SETUP(CFE_SB_Unsubscribe(MsgId, PipeId)); diff --git a/fsw/cfe-core/unit-test/sb_UT.h b/fsw/cfe-core/unit-test/sb_UT.h index b62fca00b..e3ed017fc 100644 --- a/fsw/cfe-core/unit-test/sb_UT.h +++ b/fsw/cfe-core/unit-test/sb_UT.h @@ -3017,7 +3017,7 @@ void Test_CleanupApp_API(void); ** \sa #UT_Text, #Test_CFE_SB_InitMsg, #Test_CFE_SB_MsgHdrSize, ** \sa #Test_CFE_SB_GetUserData, #Test_CFE_SB_SetGetMsgId, ** \sa #Test_CFE_SB_SetGetUserDataLength, #Test_CFE_SB_SetGetTotalMsgLength, -** \sa #Test_CFE_SB_SetGetMsgTime, #Test_CFE_SB_TimeStampMsg, +** \sa #Test_CFE_SB_SetGetMsgTime, ** \sa #Test_CFE_SB_SetGetCmdCode, #Test_CFE_SB_ChecksumUtils ** ******************************************************************************/ @@ -3036,52 +3036,12 @@ void Test_SB_Utils(void); ** \returns ** This function does not return a value. ** -** \sa #UT_Text, #Test_CFE_SB_InitMsg_True, #Test_CFE_SB_InitMsg_False -** ******************************************************************************/ void Test_CFE_SB_InitMsg(void); /*****************************************************************************/ /** -** \brief Test message initialization, clearing the message content -** -** \par Description -** This function tests message initialization (clearing the message -** content). -** -** \par Assumptions, External Events, and Notes: -** None -** -** \returns -** This function does not return a value. -** -** \sa #UT_Text, #SB_ResetUnitTest, #CFE_SB_InitMsg, #UT_Report -** -******************************************************************************/ -void Test_CFE_SB_InitMsg_True(void); - -/*****************************************************************************/ -/** -** \brief Test message initialization, leaving the message content unchanged -** -** \par Description -** This function tests message initialization (leaving the message -** content unchanged). -** -** \par Assumptions, External Events, and Notes: -** None -** -** \returns -** This function does not return a value. -** -** \sa #UT_Text, #SB_ResetUnitTest, #CFE_SB_InitMsg, #UT_Report -** -******************************************************************************/ -void Test_CFE_SB_InitMsg_False(void); - -/*****************************************************************************/ -/** -** \brief Test getting the size of a command message header +** \brief Test getting the size of a message header ** ** \par Description ** This function tests getting the size of a command message @@ -3096,26 +3056,7 @@ void Test_CFE_SB_InitMsg_False(void); ** \sa #UT_Text, #SB_ResetUnitTest, #CFE_SB_MsgHdrSize, #UT_Report ** ******************************************************************************/ -void Test_CFE_SB_MsgHdrSize_Cmd(void); - -/*****************************************************************************/ -/** -** \brief Test getting the size of a telemetry message header -** -** \par Description -** This function tests getting the size of a telemetry message -** header. -** -** \par Assumptions, External Events, and Notes: -** None -** -** \returns -** This function does not return a value. -** -** \sa #UT_Text, #SB_ResetUnitTest, #CFE_SB_MsgHdrSize, #UT_Report -** -******************************************************************************/ -void Test_CFE_SB_MsgHdrSize_Tlm(void); +void Test_CFE_SB_MsgHdrSize(void); /*****************************************************************************/ /** @@ -3135,10 +3076,7 @@ void Test_CFE_SB_MsgHdrSize_Tlm(void); ** \sa #UT_Report ** ******************************************************************************/ -void Test_CFE_SB_GetUserData_Cmd(void); -void Test_CFE_SB_GetUserData_CmdNoSecHdr(void); -void Test_CFE_SB_GetUserData_Tlm(void); -void Test_CFE_SB_GetUserData_TlmNoSecHdr(void); +void Test_CFE_SB_GetUserData(void); /*****************************************************************************/ /** @@ -3178,10 +3116,7 @@ void Test_CFE_SB_SetGetMsgId(void); ** \sa #UT_GetActualPktLenField, #UT_Report ** ******************************************************************************/ -void Test_CFE_SB_SetGetUserDataLength_Cmd(void); -void Test_CFE_SB_SetGetUserDataLength_CmdNoSecHdr(void); -void Test_CFE_SB_SetGetUserDataLength_Tlm(void); -void Test_CFE_SB_SetGetUserDataLength_TlmNoSecHdr(void); +void Test_CFE_SB_SetGetUserDataLength(void); /*****************************************************************************/ /** @@ -3220,29 +3155,7 @@ void Test_CFE_SB_SetGetTotalMsgLength(void); ** \sa #CFE_SB_GetMsgTime, #UT_DisplayPkt, #UT_Report ** ******************************************************************************/ -void Test_CFE_SB_SetGetMsgTime_Cmd(void); -void Test_CFE_SB_SetGetMsgTime_CmdNoSecHdr(void); -void Test_CFE_SB_SetGetMsgTime_Tlm(void); -void Test_CFE_SB_SetGetMsgTime_TlmNoSecHdr(void); - -/*****************************************************************************/ -/** -** \brief Test setting the time field to the current time -** -** \par Description -** This function tests setting the time field to the current time. -** -** \par Assumptions, External Events, and Notes: -** None -** -** \returns -** This function does not return a value. -** -** \sa #UT_Text, #SB_ResetUnitTest, #CFE_SB_SetMsgId, #CFE_SB_TimeStampMsg, -** \sa #CFE_SB_GetMsgTime, #UT_DisplayPkt, #UT_Report -** -******************************************************************************/ -void Test_CFE_SB_TimeStampMsg(void); +void Test_CFE_SB_SetGetMsgTime(void); /*****************************************************************************/ /** @@ -3262,8 +3175,7 @@ void Test_CFE_SB_TimeStampMsg(void); ** \sa #UT_Report ** ******************************************************************************/ -void Test_CFE_SB_SetGetCmdCode_Cmd(void); -void Test_CFE_SB_SetGetCmdCode_NonCmd(void); +void Test_CFE_SB_SetGetCmdCode(void); /*****************************************************************************/ /** @@ -3280,15 +3192,8 @@ void Test_CFE_SB_SetGetCmdCode_NonCmd(void); ** \returns ** This function does not return a value. ** -** \sa #UT_Text, #SB_ResetUnitTest, #CFE_SB_InitMsg, #CFE_SB_GenerateChecksum, -** \sa #CFE_SB_GetChecksum, #CFE_SB_ValidateChecksum, #UT_DisplayPkt, -** \sa #CFE_SB_SetMsgId, #UT_Report -** ******************************************************************************/ -void Test_CFE_SB_ChecksumUtils_Cmd(void); -void Test_CFE_SB_ChecksumUtils_CmdNoSecHdr(void); -void Test_CFE_SB_ChecksumUtils_Tlm(void); -void Test_CFE_SB_ChecksumUtils_TlmNoSecHdr(void); +void Test_CFE_SB_ChecksumUtils(void); /*****************************************************************************/ /** diff --git a/fsw/cfe-core/ut-stubs/CMakeLists.txt b/fsw/cfe-core/ut-stubs/CMakeLists.txt index f11209015..f2bc4acf6 100644 --- a/fsw/cfe-core/ut-stubs/CMakeLists.txt +++ b/fsw/cfe-core/ut-stubs/CMakeLists.txt @@ -18,6 +18,7 @@ include_directories(${osal_MISSION_DIR}/ut_assert/inc) add_library(ut_cfe-core_stubs STATIC ut_es_stubs.c ut_evs_stubs.c + ut_msg_stubs.c ut_sb_stubs.c ut_tbl_stubs.c ut_time_stubs.c diff --git a/fsw/cfe-core/ut-stubs/ut_msg_stubs.c b/fsw/cfe-core/ut-stubs/ut_msg_stubs.c new file mode 100644 index 000000000..77e14b03e --- /dev/null +++ b/fsw/cfe-core/ut-stubs/ut_msg_stubs.c @@ -0,0 +1,706 @@ +/* +** 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: ut_msg_stubs.c +** +** Purpose: +** Unit test stubs for MSG routines +** +** Notes: +** Minimal work is done, only what is required for unit testing +** +*/ + +/* +** Includes +*/ +#include "cfe.h" +#include "utstubs.h" +#include "uttools.h" + +/* +** Defines +*/ + +/* For reporting no value for get */ +#define UTASSERT_GETSTUB(Expression) \ + UtAssert_Type(TSF, Expression, "%s: Check for get value provided by test", __func__); + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GenerateChecksum + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GenerateChecksum(CFE_MSG_Message_t *MsgPtr) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GenerateChecksum), MsgPtr); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GenerateChecksum); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetApId + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetApId(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_ApId_t *ApId) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetApId), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetApId), ApId); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetApId); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetApId), (uint8 *)ApId, sizeof(*ApId)) == sizeof(*ApId)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetEDSVersion + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetEDSVersion(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_EDSVersion_t *Version) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetEDSVersion), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetEDSVersion), Version); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetEDSVersion); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetEDSVersion), (uint8 *)Version, sizeof(*Version)) == + sizeof(*Version)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetEndian + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetEndian(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Endian_t *Endian) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetEndian), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetEndian), Endian); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetEndian); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetEndian), (uint8 *)Endian, sizeof(*Endian)) == + sizeof(*Endian)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetFcnCode + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetFcnCode(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_FcnCode_t *FcnCode) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetFcnCode), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetFcnCode), FcnCode); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetFcnCode); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetFcnCode), (uint8 *)FcnCode, sizeof(*FcnCode)) == + sizeof(*FcnCode)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetHasSecondaryHeader + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetHasSecondaryHeader(const CFE_MSG_Message_t *MsgPtr, bool *HasSecondary) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetHasSecondaryHeader), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetHasSecondaryHeader), HasSecondary); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetHasSecondaryHeader); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetHasSecondaryHeader), (uint8 *)HasSecondary, + sizeof(*HasSecondary)) == sizeof(*HasSecondary)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetHeaderVersion + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetHeaderVersion(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_HeaderVersion_t *Version) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetHeaderVersion), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetHeaderVersion), Version); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetHeaderVersion); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetHeaderVersion), (uint8 *)Version, sizeof(*Version)) == + sizeof(*Version)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetMsgId + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetMsgId(const CFE_MSG_Message_t *MsgPtr, CFE_SB_MsgId_t *MsgId) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetMsgId), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetMsgId), MsgId); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetMsgId); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetMsgId), (uint8 *)MsgId, sizeof(*MsgId)) == + sizeof(*MsgId)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetMsgTime + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetMsgTime(const CFE_MSG_Message_t *MsgPtr, CFE_TIME_SysTime_t *Time) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetMsgTime), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetMsgTime), Time); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetMsgTime); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetMsgTime), (uint8 *)Time, sizeof(*Time)) == + sizeof(*Time)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetPlaybackFlag + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetPlaybackFlag(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_PlaybackFlag_t *PlayFlag) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetPlaybackFlag), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetPlaybackFlag), PlayFlag); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetPlaybackFlag); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetPlaybackFlag), (uint8 *)PlayFlag, sizeof(*PlayFlag)) == + sizeof(*PlayFlag)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetSegmentationFlag + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetSegmentationFlag(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_SegmentationFlag_t *SegFlag) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetSegmentationFlag), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetSegmentationFlag), SegFlag); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetSegmentationFlag); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetSegmentationFlag), (uint8 *)SegFlag, sizeof(*SegFlag)) == + sizeof(*SegFlag)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetSequenceCount + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetSequenceCount(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_SequenceCount_t *SeqCnt) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetSequenceCount), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetSequenceCount), SeqCnt); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetSequenceCount); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetSequenceCount), (uint8 *)SeqCnt, sizeof(*SeqCnt)) == + sizeof(*SeqCnt)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetSize + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetSize(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Size_t *Size) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetSize), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetSize), Size); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetSize); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetSize), (uint8 *)Size, sizeof(*Size)) == sizeof(*Size)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetSubsystem + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetSubsystem(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Subsystem_t *Subsystem) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetSubsystem), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetSubsystem), Subsystem); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetSubsystem); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetSubsystem), (uint8 *)Subsystem, sizeof(*Subsystem)) == + sizeof(*Subsystem)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetSystem + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetSystem(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_System_t *System) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetSystem), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetSystem), System); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetSystem); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetSystem), (uint8 *)System, sizeof(*System)) == + sizeof(*System)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetType + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetType(const CFE_MSG_Message_t *MsgPtr, CFE_MSG_Type_t *Type) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetType), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetType), Type); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetType); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetType), (uint8 *)Type, sizeof(*Type)) == sizeof(*Type)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_GetTypeFromMsgId + * ----------------------------------------------------------- + */ +int32 CFE_MSG_GetTypeFromMsgId(CFE_SB_MsgId_t MsgId, CFE_MSG_Type_t *Type) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetTypeFromMsgId), MsgId); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_GetTypeFromMsgId), Type); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_GetTypeFromMsgId); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_GetTypeFromMsgId), (uint8 *)Type, sizeof(*Type)) == + sizeof(*Type)); + } + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_Init + * ----------------------------------------------------------- + */ +int32 CFE_MSG_Init(CFE_MSG_Message_t *MsgPtr, CFE_SB_MsgId_t MsgId, CFE_MSG_Size_t Size, bool Clear) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_Init), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_Init), MsgId); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_Init), Size); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_Init), Clear); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_Init); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetApId + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetApId(CFE_MSG_Message_t *MsgPtr, CFE_MSG_ApId_t ApId) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetApId), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetApId), ApId); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetApId); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetEDSVersion + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetEDSVersion(CFE_MSG_Message_t *MsgPtr, CFE_MSG_EDSVersion_t Version) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetEDSVersion), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetEDSVersion), Version); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetEDSVersion); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetEndian + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetEndian(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Endian_t Endian) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetEndian), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetEndian), Endian); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetEndian); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetFcnCode + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetFcnCode(CFE_MSG_Message_t *MsgPtr, CFE_MSG_FcnCode_t FcnCode) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetFcnCode), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetFcnCode), FcnCode); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetFcnCode); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetHasSecondaryHeader + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetHasSecondaryHeader(CFE_MSG_Message_t *MsgPtr, bool HasSecondary) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetHasSecondaryHeader), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetHasSecondaryHeader), HasSecondary); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetHasSecondaryHeader); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetHeaderVersion + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetHeaderVersion(CFE_MSG_Message_t *MsgPtr, CFE_MSG_HeaderVersion_t Version) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetHeaderVersion), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetHeaderVersion), Version); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetHeaderVersion); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetMsgId + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetMsgId(CFE_MSG_Message_t *MsgPtr, CFE_SB_MsgId_t MsgId) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetMsgId), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetMsgId), MsgId); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetMsgId); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetMsgTime + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetMsgTime(CFE_MSG_Message_t *MsgPtr, CFE_TIME_SysTime_t Time) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetMsgTime), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetMsgTime), Time); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetMsgTime); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetPlaybackFlag + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetPlaybackFlag(CFE_MSG_Message_t *MsgPtr, CFE_MSG_PlaybackFlag_t PlayFlag) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetPlaybackFlag), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetPlaybackFlag), PlayFlag); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetPlaybackFlag); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetSegmentationFlag + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetSegmentationFlag(CFE_MSG_Message_t *MsgPtr, CFE_MSG_SegmentationFlag_t SegFlag) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetSegmentationFlag), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetSegmentationFlag), SegFlag); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetSegmentationFlag); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetSequenceCount + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetSequenceCount(CFE_MSG_Message_t *MsgPtr, CFE_MSG_SequenceCount_t SeqCnt) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetSequenceCount), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetSequenceCount), SeqCnt); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetSequenceCount); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetSize + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetSize(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Size_t Size) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetSize), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetSize), Size); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetSize); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetSubsystem + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetSubsystem(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Subsystem_t Subsystem) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetSubsystem), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetSubsystem), Subsystem); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetSubsystem); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetSystem + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetSystem(CFE_MSG_Message_t *MsgPtr, CFE_MSG_System_t System) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetSystem), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetSystem), System); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetSystem); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_SetType + * ----------------------------------------------------------- + */ +int32 CFE_MSG_SetType(CFE_MSG_Message_t *MsgPtr, CFE_MSG_Type_t Type) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetType), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_SetType), Type); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_SetType); + + return status; +} + +/* + * ----------------------------------------------------------- + * Stub implementation of CFE_MSG_ValidateChecksum + * ----------------------------------------------------------- + */ +int32 CFE_MSG_ValidateChecksum(const CFE_MSG_Message_t *MsgPtr, bool *IsValid) +{ + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_ValidateChecksum), MsgPtr); + UT_Stub_RegisterContextGenericArg(UT_KEY(CFE_MSG_ValidateChecksum), IsValid); + + int32 status; + + status = UT_DEFAULT_IMPL(CFE_MSG_ValidateChecksum); + if (status >= 0) + { + UTASSERT_GETSTUB(UT_Stub_CopyToLocal(UT_KEY(CFE_MSG_ValidateChecksum), (uint8 *)IsValid, sizeof(*IsValid)) == + sizeof(*IsValid)); + } + + return status; +} From 582ea3bfd0150fc837d475f4704b7d1bbd450aa7 Mon Sep 17 00:00:00 2001 From: Jacob Hageman Date: Mon, 24 Aug 2020 18:10:18 -0400 Subject: [PATCH 7/9] HOTFIX: Deprecated time format verify logic fix --- fsw/cfe-core/src/sb/cfe_sb_verify.h | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/fsw/cfe-core/src/sb/cfe_sb_verify.h b/fsw/cfe-core/src/sb/cfe_sb_verify.h index 3b4c3c23f..9a0083db7 100644 --- a/fsw/cfe-core/src/sb/cfe_sb_verify.h +++ b/fsw/cfe-core/src/sb/cfe_sb_verify.h @@ -80,8 +80,11 @@ #error CFE_PLATFORM_SB_BUF_MEMORY_BYTES cannot be greater than UINT32_MAX (4 Gigabytes)! #endif -#if ((CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_SUBS) || \ - (CFE_MISSION_SB_PACKET_TIME_FORMAT == CFE_MISSION_SB_TIME_32_32_M_20)) +/* + * Legacy time formats no longer supported in core cFE, this will pass + * if default is selected or if both defines are removed + */ +#if (CFE_MISSION_SB_PACKET_TIME_FORMAT != CFE_MISSION_SB_TIME_32_16_SUBS) #error Legacy CFE_MISSION_SB_PACKET_TIME_FORMAT implementations no longer supported in core #endif From 1d68ce8e208ba43d10890bd3e62ee7058ad973a8 Mon Sep 17 00:00:00 2001 From: Jacob Hageman Date: Tue, 25 Aug 2020 13:25:50 -0400 Subject: [PATCH 8/9] HOTFIX, No longer add tests from within tests in msg UT --- modules/msg/unit-test-coverage/msg_UT.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/modules/msg/unit-test-coverage/msg_UT.c b/modules/msg/unit-test-coverage/msg_UT.c index 3b0359276..21973d939 100644 --- a/modules/msg/unit-test-coverage/msg_UT.c +++ b/modules/msg/unit-test-coverage/msg_UT.c @@ -45,9 +45,9 @@ void UtTest_Setup(void) UT_Text("Message header coverage test..."); UT_ADD_TEST(Test_MSG_Init); - UT_ADD_TEST(Test_MSG_CCSDSPri); - UT_ADD_TEST(Test_MSG_CCSDSExt); - UT_ADD_TEST(Test_MSG_MsgId_Shared); + Test_MSG_CCSDSPri(); + Test_MSG_CCSDSExt(); + Test_MSG_MsgId_Shared(); UT_ADD_TEST(Test_MSG_MsgId); UT_ADD_TEST(Test_MSG_Checksum); UT_ADD_TEST(Test_MSG_FcnCode); From 993d556fab477336615d5dfc0f666ee66b16ccd3 Mon Sep 17 00:00:00 2001 From: Yasir Khan Date: Tue, 25 Aug 2020 13:37:01 -0400 Subject: [PATCH 9/9] Increase version to 6.8.0-rc1+dev26, update readme Update cfe to reflect HOTFIX nasa/cfe#840 --- README.md | 8 ++++++++ fsw/cfe-core/src/inc/cfe_version.h | 4 ++-- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index c88bbc373..71f7fdf6c 100644 --- a/README.md +++ b/README.md @@ -10,6 +10,14 @@ The detailed cFE user's guide can be viewed at + ### Development Build: 6.8.0-rc1+dev13 - Deprecates `CFE_SB_GetLastSenderId()` API by introducing new `CFE_OMIT_DEPRECATED_6_8` tag diff --git a/fsw/cfe-core/src/inc/cfe_version.h b/fsw/cfe-core/src/inc/cfe_version.h index 57e55fe66..4745e1a95 100644 --- a/fsw/cfe-core/src/inc/cfe_version.h +++ b/fsw/cfe-core/src/inc/cfe_version.h @@ -35,8 +35,8 @@ /* Development Build Macro Definitions */ -#define CFE_BUILD_NUMBER 13 /*!< Development Build: Number of commits since baseline */ -#define CFE_BUILD_BASELINE "v6.8.0-rc1+dev" /*!< Development Build: git tag that is the base for the current development */ +#define CFE_BUILD_NUMBER 28 /*!< Development Build: Number of commits since baseline */ +#define CFE_BUILD_BASELINE "v6.8.0-rc1" /*!< Development Build: git tag that is the base for the current development */ /* Version Macro Definitions */