From ad7fbe8f657e43bfdbf99205251fc4f4c3acd66d Mon Sep 17 00:00:00 2001 From: Joseph Hickey Date: Thu, 22 Jan 2026 17:03:32 -0500 Subject: [PATCH] NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" Batch update of latest cFS software release Reflects commit e02a51fb7d3c34aa5cd5f7209097b3a54ecc9e86 from NASA internal development repo --- .github/workflows/build-documentation.yml | 8 + .github/workflows/build-run-app.yml | 8 + .github/workflows/codeql-build.yml | 9 +- .github/workflows/format-check.yml | 5 +- .github/workflows/static-analysis.yml | 8 + .github/workflows/unit-test-coverage.yml | 8 + CMakeLists.txt | 6 + arch_build.cmake | 19 + config/default_cs_extern_typedefs.h | 74 + config/default_cs_fcncode_values.h | 73 + config/default_cs_interface_cfg_values.h | 39 + config/default_cs_internal_cfg_values.h | 38 + .../default_cs_mission_cfg.h | 38 +- config/default_cs_msg.h | 31 + config/default_cs_msgdefs.h | 130 + config/default_cs_msgid_values.h | 32 + .../cs_msgids.h => config/default_cs_msgids.h | 19 +- config/default_cs_msgstruct.h | 591 +++ config/default_cs_platform_cfg.h | 41 + config/default_cs_tbl.h | 59 + config/default_cs_tbldefs.h | 119 + config/default_cs_topicid_values.h | 28 + config/eds_cs_extern_typedefs.h | 36 + config/eds_cs_fcncode_values.h | 39 + config/eds_cs_interface_cfg_values.h | 40 + config/eds_cs_msgdefs.h | 31 + config/eds_cs_msgstruct.h | 35 + config/eds_cs_tbldefs.h | 30 + config/eds_cs_topicid_values.h | 30 + docs/dox_src/CMakeLists.txt | 1 - docs/dox_src/cs-common.doxyfile.in | 1 + eds/cs.xml | 579 +++ fsw/inc/{cs_events.h => cs_eventids.h} | 77 +- fsw/inc/{cs_msgdefs.h => cs_fcncodes.h} | 234 +- fsw/inc/cs_interface_cfg.h | 104 + .../{cs_platform_cfg.h => cs_internal_cfg.h} | 127 +- fsw/inc/cs_msg.h | 203 - fsw/inc/cs_perfids.h | 5 +- fsw/inc/cs_tbldefs.h | 143 - fsw/inc/cs_topicids.h | 52 + fsw/src/cs_app.c | 400 +- fsw/src/cs_app.h | 283 +- fsw/src/cs_app_cmds.c | 276 +- fsw/src/cs_app_cmds.h | 17 +- fsw/src/cs_cmds.c | 270 +- fsw/src/cs_cmds.h | 48 +- fsw/src/cs_compute.c | 851 ++-- fsw/src/cs_compute.h | 7 +- fsw/src/cs_dispatch.c | 435 ++ fsw/src/cs_dispatch.h | 68 + fsw/src/cs_eds_dispatch.c | 135 + fsw/src/cs_eeprom_cmds.c | 458 +- fsw/src/cs_eeprom_cmds.h | 25 +- fsw/src/cs_init.c | 241 +- fsw/src/cs_init.h | 5 +- fsw/src/cs_memory_cmds.c | 469 +-- fsw/src/cs_memory_cmds.h | 25 +- fsw/src/cs_table_cmds.c | 277 +- fsw/src/cs_table_cmds.h | 17 +- fsw/src/cs_table_processing.c | 1222 +++--- fsw/src/cs_table_processing.h | 192 +- fsw/src/cs_utils.c | 941 +++-- fsw/src/cs_utils.h | 396 +- fsw/src/cs_verify.h | 5 +- fsw/src/cs_version.h | 11 +- fsw/tables/cs_apptbl.c | 53 +- fsw/tables/cs_eepromtbl.c | 40 +- fsw/tables/cs_memorytbl.c | 40 +- fsw/tables/cs_tablestbl.c | 53 +- mission_build.cmake | 16 + unit-test/CMakeLists.txt | 1 + unit-test/cs_app_cmds_tests.c | 314 +- unit-test/cs_app_tests.c | 3304 +-------------- unit-test/cs_cmds_tests.c | 787 ++-- unit-test/cs_compute_tests.c | 721 +++- unit-test/cs_dispatch_tests.c | 2822 +++++++++++++ unit-test/cs_eds_dispatch_tests.c | 72 + unit-test/cs_eeprom_cmds_tests.c | 417 +- unit-test/cs_init_tests.c | 63 +- unit-test/cs_memory_cmds_tests.c | 409 +- unit-test/cs_table_cmds_tests.c | 364 +- unit-test/cs_table_processing_tests.c | 3675 +++-------------- unit-test/cs_utils_tests.c | 426 +- unit-test/stubs/cs_app_cmds_stubs.c | 61 +- unit-test/stubs/cs_app_stubs.c | 45 +- unit-test/stubs/cs_appdata_global_stub.c | 5 +- unit-test/stubs/cs_cmds_stubs.c | 143 +- unit-test/stubs/cs_compute_stubs.c | 5 +- unit-test/stubs/cs_dispatch_stubs.c | 54 + unit-test/stubs/cs_eeprom_cmds_stubs.c | 61 +- unit-test/stubs/cs_init_stubs.c | 5 +- unit-test/stubs/cs_memory_cmds_stubs.c | 61 +- unit-test/stubs/cs_table_cmds_stubs.c | 69 +- unit-test/stubs/cs_table_processing_stubs.c | 68 +- unit-test/stubs/cs_utils_stubs.c | 145 +- unit-test/utilities/cs_test_utils.c | 125 +- unit-test/utilities/cs_test_utils.h | 9 +- 97 files changed, 12671 insertions(+), 11986 deletions(-) create mode 100644 arch_build.cmake create mode 100644 config/default_cs_extern_typedefs.h create mode 100644 config/default_cs_fcncode_values.h create mode 100644 config/default_cs_interface_cfg_values.h create mode 100644 config/default_cs_internal_cfg_values.h rename fsw/inc/cs_mission_cfg.h => config/default_cs_mission_cfg.h (51%) create mode 100644 config/default_cs_msg.h create mode 100644 config/default_cs_msgdefs.h create mode 100644 config/default_cs_msgid_values.h rename fsw/inc/cs_msgids.h => config/default_cs_msgids.h (66%) create mode 100644 config/default_cs_msgstruct.h create mode 100644 config/default_cs_platform_cfg.h create mode 100644 config/default_cs_tbl.h create mode 100644 config/default_cs_tbldefs.h create mode 100644 config/default_cs_topicid_values.h create mode 100644 config/eds_cs_extern_typedefs.h create mode 100644 config/eds_cs_fcncode_values.h create mode 100644 config/eds_cs_interface_cfg_values.h create mode 100644 config/eds_cs_msgdefs.h create mode 100644 config/eds_cs_msgstruct.h create mode 100644 config/eds_cs_tbldefs.h create mode 100644 config/eds_cs_topicid_values.h create mode 100644 eds/cs.xml rename fsw/inc/{cs_events.h => cs_eventids.h} (95%) rename fsw/inc/{cs_msgdefs.h => cs_fcncodes.h} (89%) create mode 100644 fsw/inc/cs_interface_cfg.h rename fsw/inc/{cs_platform_cfg.h => cs_internal_cfg.h} (66%) delete mode 100644 fsw/inc/cs_msg.h delete mode 100644 fsw/inc/cs_tbldefs.h create mode 100644 fsw/inc/cs_topicids.h create mode 100644 fsw/src/cs_dispatch.c create mode 100644 fsw/src/cs_dispatch.h create mode 100644 fsw/src/cs_eds_dispatch.c create mode 100644 unit-test/cs_dispatch_tests.c create mode 100644 unit-test/cs_eds_dispatch_tests.c create mode 100644 unit-test/stubs/cs_dispatch_stubs.c diff --git a/.github/workflows/build-documentation.yml b/.github/workflows/build-documentation.yml index da77f6e..c69056a 100644 --- a/.github/workflows/build-documentation.yml +++ b/.github/workflows/build-documentation.yml @@ -2,7 +2,15 @@ name: Build and Deploy Documentation on: push: + branches: + - dev + - main pull_request: + types: + - opened + - reopened + - synchronize + workflow_dispatch: jobs: build-documentation: diff --git a/.github/workflows/build-run-app.yml b/.github/workflows/build-run-app.yml index 52bbb8c..b780d37 100644 --- a/.github/workflows/build-run-app.yml +++ b/.github/workflows/build-run-app.yml @@ -2,7 +2,15 @@ name: Build and Run on: push: + branches: + - dev + - main pull_request: + types: + - opened + - reopened + - synchronize + workflow_dispatch: jobs: build-run: diff --git a/.github/workflows/codeql-build.yml b/.github/workflows/codeql-build.yml index 263da4f..d02f93a 100644 --- a/.github/workflows/codeql-build.yml +++ b/.github/workflows/codeql-build.yml @@ -2,8 +2,15 @@ name: CodeQl Analysis on: push: + branches: + - dev + - main pull_request: - + types: + - opened + - reopened + - synchronize + workflow_dispatch: jobs: codeql: diff --git a/.github/workflows/format-check.yml b/.github/workflows/format-check.yml index b9d1f11..441199a 100644 --- a/.github/workflows/format-check.yml +++ b/.github/workflows/format-check.yml @@ -2,8 +2,11 @@ name: Format Check # Run on all push and pull requests on: - push: pull_request: + types: + - opened + - reopened + - synchronize jobs: format-check: diff --git a/.github/workflows/static-analysis.yml b/.github/workflows/static-analysis.yml index fa6bb81..800c300 100644 --- a/.github/workflows/static-analysis.yml +++ b/.github/workflows/static-analysis.yml @@ -3,7 +3,15 @@ name: Static Analysis # Run on all push and pull requests on: push: + branches: + - dev + - main pull_request: + types: + - opened + - reopened + - synchronize + workflow_dispatch: jobs: static-analysis: diff --git a/.github/workflows/unit-test-coverage.yml b/.github/workflows/unit-test-coverage.yml index d67e62b..5056711 100644 --- a/.github/workflows/unit-test-coverage.yml +++ b/.github/workflows/unit-test-coverage.yml @@ -2,7 +2,15 @@ name: Unit Test and Coverage on: push: + branches: + - dev + - main pull_request: + types: + - opened + - reopened + - synchronize + workflow_dispatch: jobs: unit-test-coverage: diff --git a/CMakeLists.txt b/CMakeLists.txt index 51246a9..16333c4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -13,6 +13,12 @@ set(APP_SRC_FILES fsw/src/cs_compute.c ) +if (CFE_EDS_ENABLED) + list(APPEND APP_SRC_FILES fsw/src/cs_eds_dispatch.c) +else() + list(APPEND APP_SRC_FILES fsw/src/cs_dispatch.c) +endif() + # Create the app module add_cfe_app(cs ${APP_SRC_FILES}) diff --git a/arch_build.cmake b/arch_build.cmake new file mode 100644 index 0000000..5fe36c2 --- /dev/null +++ b/arch_build.cmake @@ -0,0 +1,19 @@ +########################################################### +# +# CS App platform 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 +# +########################################################### + +# The list of header files that control the app configuration +set(CS_PLATFORM_CONFIG_FILE_LIST + cs_internal_cfg_values.h + cs_msgid_values.h + cs_msgids.h + cs_platform_cfg.h +) + +generate_configfile_set(${CS_PLATFORM_CONFIG_FILE_LIST}) diff --git a/config/default_cs_extern_typedefs.h b/config/default_cs_extern_typedefs.h new file mode 100644 index 0000000..24cd239 --- /dev/null +++ b/config/default_cs_extern_typedefs.h @@ -0,0 +1,74 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Specification for the CFS Checksum command and telemetry + * messages. + */ +#ifndef DEFAULT_CS_EXTERN_TYPEDEFS_H +#define DEFAULT_CS_EXTERN_TYPEDEFS_H + +/** + * \name CS Checksum Type Number Definitions + * \{ + */ + +typedef enum +{ + CS_ChecksumType_CFECORE = 0, /**< \brief cFE Core checksum */ + CS_ChecksumType_OSCORE = 1, /**< \brief OS Core checksum */ + CS_ChecksumType_EEPROM_TABLE = 2, /**< \brief EEPROM checksum */ + CS_ChecksumType_MEMORY_TABLE = 3, /**< \brief Memory checksum */ + CS_ChecksumType_TABLES_TABLE = 4, /**< \brief Tables checksum */ + CS_ChecksumType_APP_TABLE = 5 /**< \brief App checksum */ +} CS_ChecksumType_Enum_t; + +/* Compatibility macros (e.g. existing table definitions) */ +#define CS_CFECORE CS_ChecksumType_CFECORE +#define CS_OSCORE CS_ChecksumType_OSCORE +#define CS_EEPROM_TABLE CS_ChecksumType_EEPROM_TABLE +#define CS_MEMORY_TABLE CS_ChecksumType_MEMORY_TABLE +#define CS_TABLES_TABLE CS_ChecksumType_TABLES_TABLE +#define CS_APP_TABLE CS_ChecksumType_APP_TABLE + +#define CS_NUM_TABLES 6 /**< \brief Number of checksum types*/ + +/**\}*/ + +/** + * \name CS Checkum States + * \{ + */ +typedef enum +{ + CS_ChecksumState_EMPTY = 0x00, /**< \brief Entry unused */ + CS_ChecksumState_ENABLED = 0x01, /**< \brief Entry or table enabled */ + CS_ChecksumState_DISABLED = 0x02, /**< \brief Entry or table disabled */ + CS_ChecksumState_UNDEFINED = 0x03 /**< \brief Entry not found state undefined */ +} CS_ChecksumState_Enum_t; + +/* Compatibility macros (e.g. existing table definitions) */ +#define CS_STATE_EMPTY CS_ChecksumState_EMPTY +#define CS_STATE_ENABLED CS_ChecksumState_ENABLED +#define CS_STATE_DISABLED CS_ChecksumState_DISABLED +#define CS_STATE_UNDEFINED CS_ChecksumState_UNDEFINED + +/**\}*/ + +#endif diff --git a/config/default_cs_fcncode_values.h b/config/default_cs_fcncode_values.h new file mode 100644 index 0000000..e7edbb1 --- /dev/null +++ b/config/default_cs_fcncode_values.h @@ -0,0 +1,73 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Specification for the CFS Checksum command and telemetry + * messages. + */ +#ifndef DEFAULT_CS_FCNCODE_VALUES_H +#define DEFAULT_CS_FCNCODE_VALUES_H + +#define CS_CCVAL(x) CS_FunctionCode_##x + +enum CS_FunctionCode +{ + CS_FunctionCode_NOOP = 0, + CS_FunctionCode_RESET = 1, + CS_FunctionCode_ONE_SHOT = 2, + CS_FunctionCode_CANCEL_ONE_SHOT = 3, + CS_FunctionCode_ENABLE_ALL_CS = 4, + CS_FunctionCode_DISABLE_ALL_CS = 5, + CS_FunctionCode_ENABLE_CFE_CORE = 6, + CS_FunctionCode_DISABLE_CFE_CORE = 7, + CS_FunctionCode_REPORT_BASELINE_CFE_CORE = 8, + CS_FunctionCode_RECOMPUTE_BASELINE_CFE_CORE = 9, + CS_FunctionCode_ENABLE_OS = 10, + CS_FunctionCode_DISABLE_OS = 11, + CS_FunctionCode_REPORT_BASELINE_OS = 12, + CS_FunctionCode_RECOMPUTE_BASELINE_OS = 13, + CS_FunctionCode_ENABLE_EEPROM = 14, + CS_FunctionCode_DISABLE_EEPROM = 15, + CS_FunctionCode_REPORT_BASELINE_ENTRY_ID_EEPROM = 16, + CS_FunctionCode_RECOMPUTE_BASELINE_EEPROM = 17, + CS_FunctionCode_ENABLE_ENTRY_ID_EEPROM = 18, + CS_FunctionCode_DISABLE_ENTRY_ID_EEPROM = 19, + CS_FunctionCode_GET_ENTRY_ID_EEPROM = 20, + CS_FunctionCode_ENABLE_MEMORY = 21, + CS_FunctionCode_DISABLE_MEMORY = 22, + CS_FunctionCode_REPORT_BASELINE_ENTRY_ID_MEMORY = 23, + CS_FunctionCode_RECOMPUTE_BASELINE_MEMORY = 24, + CS_FunctionCode_ENABLE_ENTRY_ID_MEMORY = 25, + CS_FunctionCode_DISABLE_ENTRY_ID_MEMORY = 26, + CS_FunctionCode_GET_ENTRY_ID_MEMORY = 27, + CS_FunctionCode_ENABLE_TABLES = 28, + CS_FunctionCode_DISABLE_TABLES = 29, + CS_FunctionCode_REPORT_BASELINE_TABLE = 30, + CS_FunctionCode_RECOMPUTE_BASELINE_TABLE = 31, + CS_FunctionCode_ENABLE_NAME_TABLE = 32, + CS_FunctionCode_DISABLE_NAME_TABLE = 33, + CS_FunctionCode_ENABLE_APPS = 34, + CS_FunctionCode_DISABLE_APPS = 35, + CS_FunctionCode_REPORT_BASELINE_APP = 36, + CS_FunctionCode_RECOMPUTE_BASELINE_APP = 37, + CS_FunctionCode_ENABLE_NAME_APP = 38, + CS_FunctionCode_DISABLE_NAME_APP = 39, +}; + +#endif diff --git a/config/default_cs_interface_cfg_values.h b/config/default_cs_interface_cfg_values.h new file mode 100644 index 0000000..8726bbb --- /dev/null +++ b/config/default_cs_interface_cfg_values.h @@ -0,0 +1,39 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Checksum (CS) Application Public Definitions + * + * This provides default values for configurable items that affect + * the interface(s) of this module. This includes the CMD/TLM message + * interface, tables definitions, and any other data products that + * serve to exchange information with other entities. + * + * @note This file may be overridden/superceded by mission-provided defintions + * either by overriding this header or by generating definitions from a command/data + * dictionary tool. + */ + +#ifndef DEFAULT_CS_INTERFACE_CFG_VALUES_H +#define DEFAULT_CS_INTERFACE_CFG_VALUES_H + +/* Use the default configuration value for all */ +#define CS_INTERFACE_CFGVAL(x) DEFAULT_CS_INTERFACE_##x + +#endif \ No newline at end of file diff --git a/config/default_cs_internal_cfg_values.h b/config/default_cs_internal_cfg_values.h new file mode 100644 index 0000000..ffc197d --- /dev/null +++ b/config/default_cs_internal_cfg_values.h @@ -0,0 +1,38 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Checksum (CS) Application Private Config Definitions + * + * This provides default values for configurable items that are internal + * to this module and do NOT affect the interface(s) of this module. Changes + * to items in this file only affect the local module and will be transparent + * to external entities that are using the public interface(s). + * + * @note This file may be overridden/superceded by mission-provided defintions + * either by overriding this header or by generating definitions from a command/data + * dictionary tool. + */ +#ifndef DEFAULT_CS_INTERNAL_CFG_H +#define DEFAULT_CS_INTERNAL_CFG_H + +/* Use the default configuration value for all */ +#define CS_INTERNAL_CFGVAL(x) DEFAULT_CS_INTERNAL_##x + +#endif \ No newline at end of file diff --git a/fsw/inc/cs_mission_cfg.h b/config/default_cs_mission_cfg.h similarity index 51% rename from fsw/inc/cs_mission_cfg.h rename to config/default_cs_mission_cfg.h index 03c9c95..befbd84 100644 --- a/fsw/inc/cs_mission_cfg.h +++ b/config/default_cs_mission_cfg.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -19,32 +18,19 @@ /** * @file - * Specification for the CFS Checksum macro constants that can - * be configured from one mission to another - */ -#ifndef CS_MISSION_CFG_H -#define CS_MISSION_CFG_H - -#include - -/** - * \defgroup cfscsmissioncfg CFS Checksum Mission Configuration - * \{ - */ - -/** - * \brief default CRC algorithm * - * \par Description: - * This parameter is the algorithm used by CS to checksum - * the requested data. + * Checksum (CS) Application Mission Configuration Header File + * + * This is a compatibility header for the "mission_cfg.h" file that has + * traditionally provided public config definitions for each CFS app. * - * \par Limits: - * This parameter is limited to either #CFE_MISSION_ES_DEFAULT_CRC, - * or #CFE_ES_CrcType_CRC_16 + * @note This file may be overridden/superceded by mission-provided defintions + * either by overriding this header or by generating definitions from a command/data + * dictionary tool. */ -#define CS_DEFAULT_ALGORITHM CFE_MISSION_ES_DEFAULT_CRC +#ifndef DEFAULT_CS_MISSION_CFG_H +#define DEFAULT_CS_MISSION_CFG_H -/**\}*/ +#include "cs_interface_cfg.h" #endif diff --git a/config/default_cs_msg.h b/config/default_cs_msg.h new file mode 100644 index 0000000..edd2863 --- /dev/null +++ b/config/default_cs_msg.h @@ -0,0 +1,31 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Specification for the CFS Checksum command and telemetry + * messages. + */ +#ifndef DEFAULT_CS_MSG_H +#define DEFAULT_CS_MSG_H + +#include "cs_fcncodes.h" +#include "cs_msgdefs.h" +#include "cs_msgstruct.h" + +#endif diff --git a/config/default_cs_msgdefs.h b/config/default_cs_msgdefs.h new file mode 100644 index 0000000..ef07361 --- /dev/null +++ b/config/default_cs_msgdefs.h @@ -0,0 +1,130 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Specification for the CFS Checksum command and telemetry + * messages. + */ +#ifndef DEFAULT_CS_MSGDEFS_H +#define DEFAULT_CS_MSGDEFS_H + +#include "common_types.h" +#include "cs_fcncodes.h" +#include "cs_extern_typedefs.h" +#include "cfe_es_extern_typedefs.h" + +/** + * \defgroup cfscstlm CFS Checksum Telemetry + * \{ + */ + +/** + * \brief Housekeeping Payload Structure + */ +typedef struct +{ + uint8 CmdCounter; /**< \brief CS Application Command Counter */ + uint8 CmdErrCounter; /**< \brief CS Application Command Error Counter */ + + uint8 ChecksumState; /**< \brief CS Application global checksum state */ + uint8 EepromCSState; /**< \brief CS EEPROM table checksum state */ + uint8 MemoryCSState; /**< \brief CS Memory table checksum state */ + uint8 AppCSState; /**< \brief CS App table checksum state */ + uint8 TablesCSState; /**< \brief CS Tables table checksum state */ + uint8 OSCSState; /**< \brief OS code segment checksum state */ + uint8 CfeCoreCSState; /**< \brief cFE Core code segment checksum state */ + + uint8 RecomputeInProgress; /**< \brief CS "Recompute In Progress" flag */ + uint8 OneShotInProgress; /**< \brief CS "OneShot In Progress" flag */ + uint8 Filler8; /**< \brief 8 bit padding */ + + uint16 EepromCSErrCounter; /**< \brief EEPROM miscompare counter */ + uint16 MemoryCSErrCounter; /**< \brief Memory miscompare counter */ + uint16 AppCSErrCounter; /**< \brief App miscompare counter */ + uint16 TablesCSErrCounter; /**< \brief Tables miscompare counter */ + uint16 CfeCoreCSErrCounter; /**< \brief cFE core miscompare counter */ + uint16 OSCSErrCounter; /**< \brief OS code segment miscopmare counter */ + + uint16 CurrentCSTable; /**< \brief Current table being checksummed */ + uint16 CurrentEntryInTable; /**< \brief Current entry ID in table being checksummed */ + uint32 EepromBaseline; /**< \brief Baseline checksum for all of EEPROM */ + uint32 OSBaseline; /**< \brief Baseline checksum for the OS code segment */ + uint32 CfeCoreBaseline; /**< \brief Basline checksum for the cFE core */ + + CFE_ES_MemAddress_t LastOneShotAddress; /**< \brief Address used in last one shot checksum command */ + uint32 LastOneShotSize; /**< \brief Size used in the last one shot checksum command */ + uint32 LastOneShotMaxBytesPerCycle; /**< \brief Max bytes per cycle for last one shot checksum command */ + uint32 LastOneShotChecksum; /**< \brief Checksum of the last one shot checksum command */ + + uint32 PassCounter; /**< \brief Number of times CS has passed through all of its tables */ +} CS_HkPacket_Payload_t; + +/**\}*/ + +/** + * \defgroup cfscscmdstructs CFS Checksum Command Structures + * \{ + */ + +/** + * \brief Get entry ID command payload + */ +typedef struct +{ + CFE_ES_MemAddress_t Address; /**< \brief Address to get the ID for */ +} CS_GetEntryIDCmd_Payload_t; + +/** + * \brief Payload for commands using Memory or EEPROM tables + */ +typedef struct +{ + uint32 EntryID; /**< \brief EntryID to perform a command on */ +} CS_EntryCmd_Payload_t; + +/** + * \brief Payload for commanding by table name + */ +typedef struct +{ + char Name[CFE_MISSION_TBL_MAX_FULL_NAME_LEN]; /**< \brief Table name to perform a command on */ +} CS_TableNameCmd_Payload_t; + +/** + * \brief Payload for commanding by app name + */ +typedef struct +{ + char Name[CFE_MISSION_MAX_API_LEN]; /**< \brief App name to perform a command on */ +} CS_AppNameCmd_Payload_t; + +/** + * \brief Payload for sending one shot calculation + */ +typedef struct +{ + CFE_ES_MemAddress_t Address; /**< \brief Address to start checksum */ + uint32 Size; /**< \brief Number of bytes to checksum */ + uint32 MaxBytesPerCycle; /**< \brief Max Number of bytes to compute per cycle. Value of Zero to use platform config + value */ +} CS_OneShotCmd_Payload_t; + +/**\}*/ + +#endif diff --git a/config/default_cs_msgid_values.h b/config/default_cs_msgid_values.h new file mode 100644 index 0000000..e9b2f8b --- /dev/null +++ b/config/default_cs_msgid_values.h @@ -0,0 +1,32 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Checksum (CS) Application Message IDs + */ +#ifndef DEFAULT_CS_MSGID_VALUES_H +#define DEFAULT_CS_MSGID_VALUES_H + +#include "cfe_core_api_base_msgids.h" +#include "cs_topicids.h" + +#define CFE_PLATFORM_CS_CMD_MIDVAL(x) CFE_PLATFORM_CMD_TOPICID_TO_MIDV(CFE_MISSION_CS_##x##_TOPICID) +#define CFE_PLATFORM_CS_TLM_MIDVAL(x) CFE_PLATFORM_TLM_TOPICID_TO_MIDV(CFE_MISSION_CS_##x##_TOPICID) + +#endif diff --git a/fsw/inc/cs_msgids.h b/config/default_cs_msgids.h similarity index 66% rename from fsw/inc/cs_msgids.h rename to config/default_cs_msgids.h index 0a66f54..8e97184 100644 --- a/fsw/inc/cs_msgids.h +++ b/config/default_cs_msgids.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -21,17 +20,19 @@ * @file * Specification for the CFS Checksum constants for message IDs */ -#ifndef CS_MSGIDS_H -#define CS_MSGIDS_H +#ifndef DEFAULT_CS_MSGIDS_H +#define DEFAULT_CS_MSGIDS_H + +#include "cs_msgid_values.h" /** * \defgroup cfscscmdmid CFS Checksum Command Message IDs * \{ */ -#define CS_CMD_MID (0x189F) /**< \brief CS Command Message ID */ -#define CS_SEND_HK_MID (0x18A0) /**< \brief CS Housekeeping Request Message ID */ -#define CS_BACKGROUND_CYCLE_MID (0x18A1) /**< \brief CS Background Cycle Message ID */ +#define CS_CMD_MID CFE_PLATFORM_CS_CMD_MIDVAL(CMD) +#define CS_SEND_HK_MID CFE_PLATFORM_CS_CMD_MIDVAL(SEND_HK) +#define CS_BACKGROUND_CYCLE_MID CFE_PLATFORM_CS_CMD_MIDVAL(BACKGROUND_CYCLE) /**\}*/ @@ -40,7 +41,7 @@ * \{ */ -#define CS_HK_TLM_MID (0x08A4) /**< \brief CS Housekeeping Telemetry Message ID */ +#define CS_HK_TLM_MID CFE_PLATFORM_CS_TLM_MIDVAL(HK_TLM) /**\}*/ diff --git a/config/default_cs_msgstruct.h b/config/default_cs_msgstruct.h new file mode 100644 index 0000000..868290a --- /dev/null +++ b/config/default_cs_msgstruct.h @@ -0,0 +1,591 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Specification for the CFS Checksum command and telemetry + * messages. + */ +#ifndef DEFAULT_CS_MSGSTRUCT_H +#define DEFAULT_CS_MSGSTRUCT_H + +#include "cs_msgdefs.h" +#include "cfe_msg_hdr.h" + +/** + * \defgroup cfscstlm CFS Checksum Telemetry + * \{ + */ + +/** + * \brief Housekeeping Packet Structure + */ +typedef struct +{ + CFE_MSG_TelemetryHeader_t TelemetryHeader; /**< \brief cFE SB Tlm Msg Hdr */ + CS_HkPacket_Payload_t Payload; /**< \brief CS HK Payload */ +} CS_HkPacket_t; + +/**\}*/ + +/** + * \defgroup cfscscmdstructs CFS Checksum Command Structures + * \{ + */ + +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; /**< \brief Command header */ +} CS_SendHkCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_NoopCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_ResetCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_BackgroundCheckCycleCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_DisableAllCSCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_EnableAllCSCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_DisableCfeCoreCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_EnableCfeCoreCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_DisableOSCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_EnableOSCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_ReportBaselineCfeCoreCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_ReportBaselineOSCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_RecomputeBaselineCfeCoreCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_RecomputeBaselineOSCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_CancelOneShotCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_DisableAppsCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_EnableAppsCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_DisableEepromCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_EnableEepromCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_DisableMemoryCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_EnableMemoryCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_DisableTablesCmd_t; + +/** + * \brief No arguments command data type + * + * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, + * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, + * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, + * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC + * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; +} CS_EnableTablesCmd_t; + +/** + * \brief Get entry ID command + * + * For command details see CS_GET_ENTRY_ID_EEPROM_CC, #CS_GET_ENTRY_ID_MEMORY_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_GetEntryIDCmd_Payload_t Payload; +} CS_GetEntryIDEepromCmd_t; + +/** + * \brief Get entry ID command + * + * For command details see CS_GET_ENTRY_ID_EEPROM_CC, #CS_GET_ENTRY_ID_MEMORY_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_GetEntryIDCmd_Payload_t Payload; +} CS_GetEntryIDMemoryCmd_t; + +/** + * \brief Command type for commands using Memory or EEPROM tables + * + * For command details see #CS_ENABLE_ENTRY_ID_EEPROM_CC, #CS_DISABLE_ENTRY_ID_EEPROM_CC, + * #CS_ENABLE_ENTRY_ID_MEMORY_CC, #CS_DISABLE_ENTRY_ID_MEMORY_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_EntryCmd_Payload_t Payload; +} CS_ReportBaselineEntryIDEepromCmd_t; + +/** + * \brief Command type for commands using Memory or EEPROM tables + * + * For command details see #CS_ENABLE_ENTRY_ID_EEPROM_CC, #CS_DISABLE_ENTRY_ID_EEPROM_CC, + * #CS_ENABLE_ENTRY_ID_MEMORY_CC, #CS_DISABLE_ENTRY_ID_MEMORY_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_EntryCmd_Payload_t Payload; +} CS_DisableEntryIDEepromCmd_t; + +/** + * \brief Command type for commands using Memory or EEPROM tables + * + * For command details see #CS_ENABLE_ENTRY_ID_EEPROM_CC, #CS_DISABLE_ENTRY_ID_EEPROM_CC, + * #CS_ENABLE_ENTRY_ID_MEMORY_CC, #CS_DISABLE_ENTRY_ID_MEMORY_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_EntryCmd_Payload_t Payload; +} CS_RecomputeBaselineEepromCmd_t; + +/** + * \brief Command type for commands using Memory or EEPROM tables + * + * For command details see #CS_ENABLE_ENTRY_ID_EEPROM_CC, #CS_DISABLE_ENTRY_ID_EEPROM_CC, + * #CS_ENABLE_ENTRY_ID_MEMORY_CC, #CS_DISABLE_ENTRY_ID_MEMORY_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_EntryCmd_Payload_t Payload; +} CS_EnableEntryIDEepromCmd_t; + +/** + * \brief Command type for commands using Memory or EEPROM tables + * + * For command details see #CS_ENABLE_ENTRY_ID_EEPROM_CC, #CS_DISABLE_ENTRY_ID_EEPROM_CC, + * #CS_ENABLE_ENTRY_ID_MEMORY_CC, #CS_DISABLE_ENTRY_ID_MEMORY_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_EntryCmd_Payload_t Payload; +} CS_ReportBaselineEntryIDMemoryCmd_t; + +/** + * \brief Command type for commands using Memory or EEPROM tables + * + * For command details see #CS_ENABLE_ENTRY_ID_EEPROM_CC, #CS_DISABLE_ENTRY_ID_EEPROM_CC, + * #CS_ENABLE_ENTRY_ID_MEMORY_CC, #CS_DISABLE_ENTRY_ID_MEMORY_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_EntryCmd_Payload_t Payload; +} CS_DisableEntryIDMemoryCmd_t; + +/** + * \brief Command type for commands using Memory or EEPROM tables + * + * For command details see #CS_ENABLE_ENTRY_ID_EEPROM_CC, #CS_DISABLE_ENTRY_ID_EEPROM_CC, + * #CS_ENABLE_ENTRY_ID_MEMORY_CC, #CS_DISABLE_ENTRY_ID_MEMORY_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_EntryCmd_Payload_t Payload; +} CS_RecomputeBaselineMemoryCmd_t; + +/** + * \brief Command type for commands using Memory or EEPROM tables + * + * For command details see #CS_ENABLE_ENTRY_ID_EEPROM_CC, #CS_DISABLE_ENTRY_ID_EEPROM_CC, + * #CS_ENABLE_ENTRY_ID_MEMORY_CC, #CS_DISABLE_ENTRY_ID_MEMORY_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_EntryCmd_Payload_t Payload; +} CS_EnableEntryIDMemoryCmd_t; + +/** + * \brief Command type for commanding by table name + * + * For command details see #CS_ENABLE_NAME_TABLE_CC, #CS_DISABLE_NAME_TABLE_CC, + * #CS_RECOMPUTE_BASELINE_TABLE_CC, #CS_REPORT_BASELINE_TABLE_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_TableNameCmd_Payload_t Payload; +} CS_ReportBaselineTableCmd_t; + +/** + * \brief Command type for commanding by table name + * + * For command details see #CS_ENABLE_NAME_TABLE_CC, #CS_DISABLE_NAME_TABLE_CC, + * #CS_RECOMPUTE_BASELINE_TABLE_CC, #CS_REPORT_BASELINE_TABLE_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_TableNameCmd_Payload_t Payload; +} CS_RecomputeBaselineTableCmd_t; + +/** + * \brief Command type for commanding by table name + * + * For command details see #CS_ENABLE_NAME_TABLE_CC, #CS_DISABLE_NAME_TABLE_CC, + * #CS_RECOMPUTE_BASELINE_TABLE_CC, #CS_REPORT_BASELINE_TABLE_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_TableNameCmd_Payload_t Payload; +} CS_DisableNameTableCmd_t; + +/** + * \brief Command type for commanding by table name + * + * For command details see #CS_ENABLE_NAME_TABLE_CC, #CS_DISABLE_NAME_TABLE_CC, + * #CS_RECOMPUTE_BASELINE_TABLE_CC, #CS_REPORT_BASELINE_TABLE_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_TableNameCmd_Payload_t Payload; +} CS_EnableNameTableCmd_t; + +/** + * \brief Command type for commanding by app name + * + * For command details see e #CS_ENABLE_NAME_APP_CC, #CS_DISABLE_NAME_APP_CC, + * #CS_RECOMPUTE_BASELINE_APP_CC, #CS_REPORT_BASELINE_APP_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_AppNameCmd_Payload_t Payload; +} CS_ReportBaselineAppCmd_t; + +/** + * \brief Command type for commanding by app name + * + * For command details see e #CS_ENABLE_NAME_APP_CC, #CS_DISABLE_NAME_APP_CC, + * #CS_RECOMPUTE_BASELINE_APP_CC, #CS_REPORT_BASELINE_APP_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_AppNameCmd_Payload_t Payload; +} CS_RecomputeBaselineAppCmd_t; + +/** + * \brief Command type for commanding by app name + * + * For command details see e #CS_ENABLE_NAME_APP_CC, #CS_DISABLE_NAME_APP_CC, + * #CS_RECOMPUTE_BASELINE_APP_CC, #CS_REPORT_BASELINE_APP_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_AppNameCmd_Payload_t Payload; +} CS_DisableNameAppCmd_t; + +/** + * \brief Command type for commanding by app name + * + * For command details see e #CS_ENABLE_NAME_APP_CC, #CS_DISABLE_NAME_APP_CC, + * #CS_RECOMPUTE_BASELINE_APP_CC, #CS_REPORT_BASELINE_APP_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_AppNameCmd_Payload_t Payload; +} CS_EnableNameAppCmd_t; + +/** + * \brief Command type for sending one shot calculation + * + * For command details see #CS_ONE_SHOT_CC + */ +typedef struct +{ + CFE_MSG_CommandHeader_t CommandHeader; + CS_OneShotCmd_Payload_t Payload; +} CS_OneShotCmd_t; + +/**\}*/ + +#endif diff --git a/config/default_cs_platform_cfg.h b/config/default_cs_platform_cfg.h new file mode 100644 index 0000000..10480c5 --- /dev/null +++ b/config/default_cs_platform_cfg.h @@ -0,0 +1,41 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * + * Checksum (CS) Application Platform Configuration Header File + * + * This is a compatibility header for the "platform_cfg.h" file that has + * traditionally provided both public and private config definitions + * for each CFS app. + * + * These definitions are now provided in two separate files, one for + * the public/mission scope and one for internal scope. + * + * @note This file may be overridden/superceded by mission-provided defintions + * either by overriding this header or by generating definitions from a command/data + * dictionary tool. + */ +#ifndef DEFAULT_CS_PLATFORM_CFG_H +#define DEFAULT_CS_PLATFORM_CFG_H + +#include "cs_mission_cfg.h" +#include "cs_internal_cfg.h" + +#endif diff --git a/config/default_cs_tbl.h b/config/default_cs_tbl.h new file mode 100644 index 0000000..e4ca49d --- /dev/null +++ b/config/default_cs_tbl.h @@ -0,0 +1,59 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Specification for the CFS Checksum tables. + */ +#ifndef DEFAULT_CS_TBL_H +#define DEFAULT_CS_TBL_H + +/************************************************************************** + ** + ** Include section + ** + **************************************************************************/ +#include "cs_tbldefs.h" + +/************************************************************************** + ** + ** Macro definitions + ** + **************************************************************************/ + +/** + * \brief table names for definition tables + * \{ + */ +#define CS_DEF_EEPROM_TABLE_NAME "DefEepromTbl" +#define CS_DEF_MEMORY_TABLE_NAME "DefMemoryTbl" +#define CS_DEF_TABLES_TABLE_NAME "DefTablesTbl" +#define CS_DEF_APP_TABLE_NAME "DefAppTbl" +/**\}*/ + +/** + * \brief names for the results tables + * \{ + */ +#define CS_RESULTS_EEPROM_TABLE_NAME "ResEepromTbl" +#define CS_RESULTS_MEMORY_TABLE_NAME "ResMemoryTbl" +#define CS_RESULTS_TABLES_TABLE_NAME "ResTablesTbl" +#define CS_RESULTS_APP_TABLE_NAME "ResAppTbl" +/**\}*/ + +#endif diff --git a/config/default_cs_tbldefs.h b/config/default_cs_tbldefs.h new file mode 100644 index 0000000..36a0f19 --- /dev/null +++ b/config/default_cs_tbldefs.h @@ -0,0 +1,119 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Specification for the CFS Checksum tables. + */ +#ifndef DEFAULT_CS_TBLDEFS_H +#define DEFAULT_CS_TBLDEFS_H + +/************************************************************************** + ** + ** Include section + ** + **************************************************************************/ +#include "cfe_mission_cfg.h" +#include "cfe_es_extern_typedefs.h" +#include "cfe_tbl_extern_typedefs.h" +#include "cs_extern_typedefs.h" + +/************************************************************************** + ** + ** Type definitions + ** + **************************************************************************/ + +/** + * \brief Data structure for the EEPROM or Memory definition table + */ +typedef struct +{ + CFE_ES_MemAddress_t StartAddress; /**< \brief The Start address to Checksum */ + uint16 State; /**< \brief Uses the CS_STATE_... defines from above */ + uint16 Filler16; /** <\brief Padding */ + uint32 NumBytesToChecksum; /**< \brief The number of Bytes to Checksum */ +} CS_Def_EepromMemory_Table_Entry_t; + +/** + * \brief Data structure for the Eeporom or Memory results table + */ +typedef struct +{ + CFE_ES_MemAddress_t StartAddress; /**< \brief The Start address to Checksum */ + uint16 State; /**< \brief Uses the CS_STATE_... defines from above */ + uint16 ComputedYet; /**< \brief Have we computed an Integrity value yet */ + uint32 NumBytesToChecksum; /**< \brief The number of Bytes to Checksum */ + uint32 ComparisonValue; /**< \brief The Memory Integrity Value */ + uint32 ByteOffset; /**< \brief Where a previous unfinished calc left off */ + uint32 TempChecksumValue; /**< \brief The unfinished caluculation */ + uint32 Filler32; /**< \brief Padding */ +} CS_Res_EepromMemory_Table_Entry_t; + +/** + * \brief Data structure for the Tables definition table + */ +typedef struct +{ + uint16 State; /**< \brief Uses the CS_STATE_... defines from above */ + char Name[CFE_MISSION_TBL_MAX_FULL_NAME_LEN]; /**< \brief name of the table */ +} CS_Def_Tables_Table_Entry_t; + +/** + * \brief Data structure for the App definition table + */ +typedef struct +{ + uint16 State; /**< \brief Uses the CS_STATE_... defines from above */ + char Name[CFE_MISSION_MAX_API_LEN]; /**< \brief name of the app */ +} CS_Def_App_Table_Entry_t; + +/** + * \brief Data structure for the Tables result table + */ +typedef struct +{ + CFE_ES_MemAddress_t StartAddress; /**< \brief The Start address to Checksum */ + uint16 State; /**< \brief Uses the CS_STATE_... defines from above */ + uint16 ComputedYet; /**< \brief Have we computed an Integrity value yet */ + uint32 NumBytesToChecksum; /**< \brief The number of Bytes to Checksum */ + uint32 ComparisonValue; /**< \brief The Memory Integrity Value */ + uint32 ByteOffset; /**< \brief Where a previous unfinished calc left off */ + uint32 TempChecksumValue; /**< \brief The unfinished caluculation */ + CFE_TBL_HandleId_t TblHandleID; /**< \brief handle recieved from CFE_TBL */ + bool IsCSOwner; /**< \brief Is CS the original owner of this table */ + bool Filler8; /**< \brief Padding */ + char Name[CFE_MISSION_TBL_MAX_FULL_NAME_LEN]; /**< \brief name of the table */ +} CS_Res_Tables_Table_Entry_t; + +/** + * \brief Data structure for the app result table + */ +typedef struct +{ + CFE_ES_MemAddress_t StartAddress; /**< \brief The Start address to Checksum */ + uint16 State; /**< \brief Uses the CS_STATE_... defines from above */ + uint16 ComputedYet; /**< \brief Have we computed an Integrity value yet */ + uint32 NumBytesToChecksum; /**< \brief The number of Bytes to Checksum */ + uint32 ComparisonValue; /**< \brief The Memory Integrity Value */ + uint32 ByteOffset; /**< \brief Where a previous unfinished calc left off */ + uint32 TempChecksumValue; /**< \brief The unfinished caluculation */ + char Name[CFE_MISSION_MAX_API_LEN]; /**< \brief name of the app */ +} CS_Res_App_Table_Entry_t; + +#endif diff --git a/config/default_cs_topicid_values.h b/config/default_cs_topicid_values.h new file mode 100644 index 0000000..a256d47 --- /dev/null +++ b/config/default_cs_topicid_values.h @@ -0,0 +1,28 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Checksum (CS) Application Topic IDs + */ +#ifndef DEFAULT_CS_TOPICID_VALUES_H +#define DEFAULT_CS_TOPICID_VALUES_H + +#define CFE_MISSION_CS_TIDVAL(x) DEFAULT_CFE_MISSION_CS_##x##_TOPICID + +#endif \ No newline at end of file diff --git a/config/eds_cs_extern_typedefs.h b/config/eds_cs_extern_typedefs.h new file mode 100644 index 0000000..6a36767 --- /dev/null +++ b/config/eds_cs_extern_typedefs.h @@ -0,0 +1,36 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * + * Declarations and prototypes for cs_extern_typedefs module + */ + +#ifndef EDS_CS_EXTERN_TYPEDEFS_H +#define EDS_CS_EXTERN_TYPEDEFS_H + +#include "common_types.h" +#include "cfe_resourceid_typedef.h" + +/* Source the definitions from EDS */ +#include "cs_eds_typedefs.h" + +#define CS_NUM_TABLES (1 + EdsDataType_EdsEnum_CS_ChecksumType_t_MAX) + +#endif diff --git a/config/eds_cs_fcncode_values.h b/config/eds_cs_fcncode_values.h new file mode 100644 index 0000000..49e9f03 --- /dev/null +++ b/config/eds_cs_fcncode_values.h @@ -0,0 +1,39 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Checksum (CS) Application command function codes + * + * @note + * This file should be strictly limited to the command/function code (CC) + * macro definitions. Other definitions such as enums, typedefs, or other + * macros should be placed in the msgdefs.h or msg.h files. + */ +#ifndef EDS_CS_FCNCODES_H +#define EDS_CS_FCNCODES_H + +#include "cs_eds_cc.h" + +/************************************************************************ + * Macro Definitions + ************************************************************************/ + +#define CS_CCVAL(x) EDS_CONTAINER_CS_##x##_CC + +#endif \ No newline at end of file diff --git a/config/eds_cs_interface_cfg_values.h b/config/eds_cs_interface_cfg_values.h new file mode 100644 index 0000000..57c404d --- /dev/null +++ b/config/eds_cs_interface_cfg_values.h @@ -0,0 +1,40 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Checksum (CS) Application Public Definitions + * + * This provides default values for configurable items that affect + * the interface(s) of this module. This includes the CMD/TLM message + * interface, tables definitions, and any other data products that + * serve to exchange information with other entities. + * + * @note This file may be overridden/superceded by mission-provided defintions + * either by overriding this header or by generating definitions from a command/data + * dictionary tool. + */ + +#ifndef EDS_CS_INTERFACE_CFG_VALUES_H +#define EDS_CS_INTERFACE_CFG_VALUES_H + +#include "cs_eds_designparameters.h" + +#define CS_INTERFACE_CFGVAL(x) EdsParam_CS_##x + +#endif \ No newline at end of file diff --git a/config/eds_cs_msgdefs.h b/config/eds_cs_msgdefs.h new file mode 100644 index 0000000..ae105a4 --- /dev/null +++ b/config/eds_cs_msgdefs.h @@ -0,0 +1,31 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Checksum (CS) Application command and telemetry + * message constant definitions. + */ +#ifndef EDS_CS_MSGDEFS_H +#define EDS_CS_MSGDEFS_H + +#include "cs_extern_typedefs.h" +#include "cs_eds_typedefs.h" +#include "cs_fcncodes.h" + +#endif \ No newline at end of file diff --git a/config/eds_cs_msgstruct.h b/config/eds_cs_msgstruct.h new file mode 100644 index 0000000..5c78778 --- /dev/null +++ b/config/eds_cs_msgstruct.h @@ -0,0 +1,35 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Checksum (CS) Application Command and Telemetry packet definition file. + * + * @note + * Constants and enumerated types related to these message structures + * are defined in cf_msgdefs.h. + */ +#ifndef EDS_CS_MSGSTRUCT_H +#define EDS_CS_MSGSTRUCT_H + +/************************************************************************ + * Includes + ************************************************************************/ +#include "cs_eds_typedefs.h" + +#endif \ No newline at end of file diff --git a/config/eds_cs_tbldefs.h b/config/eds_cs_tbldefs.h new file mode 100644 index 0000000..3cc5e5e --- /dev/null +++ b/config/eds_cs_tbldefs.h @@ -0,0 +1,30 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Checksum (CS) Application table related + * constant definitions. + */ +#ifndef EDS_CS_TBLDEFS_H +#define EDS_CS_TBLDEFS_H + +#include "cs_extern_typedefs.h" +#include "cs_eds_typedefs.h" + +#endif \ No newline at end of file diff --git a/config/eds_cs_topicid_values.h b/config/eds_cs_topicid_values.h new file mode 100644 index 0000000..0000c7f --- /dev/null +++ b/config/eds_cs_topicid_values.h @@ -0,0 +1,30 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Checksum (CS) Application Topic IDs + */ +#ifndef EDS_CS_TOPICID_VALUES_H +#define EDS_CS_TOPICID_VALUES_H + +#include "cfe_mission_eds_designparameters.h" + +#define CFE_MISSION_CS_TIDVAL(x) EdsParam_CFE_MISSION_CS_##x##_TOPICID + +#endif \ No newline at end of file diff --git a/docs/dox_src/CMakeLists.txt b/docs/dox_src/CMakeLists.txt index 04bf82a..47c88e4 100644 --- a/docs/dox_src/CMakeLists.txt +++ b/docs/dox_src/CMakeLists.txt @@ -10,7 +10,6 @@ # case of a self-contained/standalone build) or by a separate script # (useful if integrating into a larger project with a separate doc build) -cmake_minimum_required(VERSION 3.5) project(CS_DOCS NONE) # generate the configuration files diff --git a/docs/dox_src/cs-common.doxyfile.in b/docs/dox_src/cs-common.doxyfile.in index 4eebad3..f2e5418 100644 --- a/docs/dox_src/cs-common.doxyfile.in +++ b/docs/dox_src/cs-common.doxyfile.in @@ -5,3 +5,4 @@ # Include front material followed by everything in fsw INPUT += @cs_MISSION_DIR@/docs/dox_src/cfs_cs.dox INPUT += @cs_MISSION_DIR@/fsw +INPUT += @cs_MISSION_DIR@/config diff --git a/eds/cs.xml b/eds/cs.xml new file mode 100644 index 0000000..0d22295 --- /dev/null +++ b/eds/cs.xml @@ -0,0 +1,579 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/fsw/inc/cs_events.h b/fsw/inc/cs_eventids.h similarity index 95% rename from fsw/inc/cs_events.h rename to fsw/inc/cs_eventids.h index 9cdfc8a..c85bb9f 100644 --- a/fsw/inc/cs_events.h +++ b/fsw/inc/cs_eventids.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -21,8 +20,8 @@ * @file * Specification for the CFS Checksum event identifiers. */ -#ifndef CS_EVENTS_H -#define CS_EVENTS_H +#ifndef CS_EVENTIDS_H +#define CS_EVENTIDS_H /** * \defgroup cfscsevents CFS Checksum Event IDs @@ -915,7 +914,7 @@ * for the Tables entry specifiedcommand has been received * and there is a baseline computed to report. */ -#define CS_BASELINE_TABLES_INF_EID 69 +#define CS_BASELINE_TABLE_INF_EID 69 /** * \brief CS Baseline Table Checksum Pending Event ID @@ -928,7 +927,7 @@ * for the command specified table command has been * received but the baseline has not yet been computed. */ -#define CS_NO_BASELINE_TABLES_INF_EID 70 +#define CS_NO_BASELINE_TABLE_INF_EID 70 /** * \brief CS Baseline Table Checksum Failed Table Not Found Event ID @@ -940,7 +939,7 @@ * This event message is issued when a report baseline * for the command specified table command has been * received but specified table name cannot be found - * or is marked as #CS_STATE_EMPTY. + * or is marked as #CS_ChecksumState_EMPTY. */ #define CS_BASELINE_INVALID_NAME_TABLES_ERR_EID 71 @@ -981,7 +980,7 @@ * This event message is issued when a recompute baseline * for the command specified table command has been * received but specified table cannot be found in CS - * or is marked as #CS_STATE_EMPTY. + * or is marked as #CS_ChecksumState_EMPTY. */ #define CS_RECOMPUTE_UNKNOWN_NAME_TABLES_ERR_EID 74 @@ -1020,7 +1019,7 @@ * * This event message is issued when an enable Table name * command is received, but has an unknown name - * or is marked as #CS_STATE_EMPTY. + * or is marked as #CS_ChecksumState_EMPTY. */ #define CS_ENABLE_TABLES_UNKNOWN_NAME_ERR_EID 77 @@ -1045,7 +1044,7 @@ * * This event message is issued when a disable name * command is received, but has an unknown name - * or is marked as #CS_STATE_EMPTY. + * or is marked as #CS_ChecksumState_EMPTY. */ #define CS_DISABLE_TABLES_UNKNOWN_NAME_ERR_EID 79 @@ -1113,7 +1112,7 @@ * This event message is issued when a report baseline * for the command specified app command has been * received but specified app name cannot be found - * or is marked as #CS_STATE_EMPTY. + * or is marked as #CS_ChecksumState_EMPTY. */ #define CS_BASELINE_INVALID_NAME_APP_ERR_EID 84 @@ -1154,7 +1153,7 @@ * This event message is issued when a recompute baseline * for the command specified app command has been * received but specified app cannot be found in CS - * or is marked as #CS_STATE_EMPTY. + * or is marked as #CS_ChecksumState_EMPTY. */ #define CS_RECOMPUTE_UNKNOWN_NAME_APP_ERR_EID 87 @@ -1193,7 +1192,7 @@ * * This event message is issued when an enable app name * command is received, but has an unknown name - * or is marked as #CS_STATE_EMPTY. + * or is marked as #CS_ChecksumState_EMPTY. */ #define CS_ENABLE_APP_UNKNOWN_NAME_ERR_EID 90 @@ -1218,7 +1217,7 @@ * * This event message is issued when a disable app name * command is received, but has an unknown name - * or is marked as #CS_STATE_EMPTY. + * or is marked as #CS_ChecksumState_EMPTY. */ #define CS_DISABLE_APP_UNKNOWN_NAME_ERR_EID 92 @@ -1663,7 +1662,7 @@ * * This event message is issued when CS successfully enables an entry (specified * by name) in the Tables results table but is unable to find the same entry - * in the definition table (or the entry is marked as #CS_STATE_EMPTY). + * in the definition table (or the entry is marked as #CS_ChecksumState_EMPTY). */ #define CS_ENABLE_TABLE_DEF_NOT_FOUND_DBG_EID 129 @@ -1676,7 +1675,7 @@ * * This event message is issued when CS successfully disables an entry (specified * by name) in the Tables results table but is unable to find the same entry - * in the definition table (or the entry is marked as #CS_STATE_EMPTY). + * in the definition table (or the entry is marked as #CS_ChecksumState_EMPTY). */ #define CS_DISABLE_TABLE_DEF_NOT_FOUND_DBG_EID 130 @@ -1689,7 +1688,7 @@ * * This event message is issued when CS successfully enables an entry (specified * by name) in the Apps results table but is unable to find the same entry - * in the definition table (or the entry is marked as #CS_STATE_EMPTY). + * in the definition table (or the entry is marked as #CS_ChecksumState_EMPTY). */ #define CS_ENABLE_APP_DEF_NOT_FOUND_DBG_EID 131 @@ -1702,7 +1701,7 @@ * * This event message is issued when CS successfully disables an entry (specified * by name) in the Apps results table but is unable to find the same entry - * in the definition table (or the entry is marked as #CS_STATE_EMPTY). + * in the definition table (or the entry is marked as #CS_ChecksumState_EMPTY). */ #define CS_DISABLE_APP_DEF_NOT_FOUND_DBG_EID 132 @@ -1715,7 +1714,7 @@ * * This event message is issued when CS successfully disables an entry (specified * by name) in the Memory results table but identifies the corresponding entry in - * the definitions table to be set to #CS_STATE_EMPTY. + * the definitions table to be set to #CS_ChecksumState_EMPTY. */ #define CS_DISABLE_MEMORY_DEF_EMPTY_DBG_EID 133 @@ -1728,7 +1727,7 @@ * * This event message is issued when CS successfully enables an entry (specified * by name) in the Memory results table but identifies the corresponding entry in - * the definitions table to be set to #CS_STATE_EMPTY. + * the definitions table to be set to #CS_ChecksumState_EMPTY. */ #define CS_ENABLE_MEMORY_DEF_EMPTY_DBG_EID 134 @@ -1741,7 +1740,7 @@ * * This event message is issued when CS successfully disables an entry (specified * by name) in the EEPROM results table but identifies the corresponding entry in - * the definitions table to be set to #CS_STATE_EMPTY. + * the definitions table to be set to #CS_ChecksumState_EMPTY. */ #define CS_DISABLE_EEPROM_DEF_EMPTY_DBG_EID 135 @@ -1754,7 +1753,7 @@ * * This event message is issued when CS successfully enables an entry (specified * by name) in the EEPROM results table but identifies the corresponding entry in - * the definitions table to be set to #CS_STATE_EMPTY. + * the definitions table to be set to #CS_ChecksumState_EMPTY. */ #define CS_ENABLE_EEPROM_DEF_EMPTY_DBG_EID 136 @@ -1779,7 +1778,7 @@ * \par Cause: * * This event message is issued when CS validation for the Tables definition table finds an entry - * that contains a zero-length name field with a state field that is not marked as #CS_STATE_EMPTY. This + * that contains a zero-length name field with a state field that is not marked as #CS_ChecksumState_EMPTY. This * event is only issued if it is the first error found during validation. */ #define CS_VAL_TABLES_DEF_TBL_ZERO_NAME_ERR_EID 138 @@ -1792,9 +1791,9 @@ * \par Cause: * * This event message when CS completes validation of the tables definition table. This message - * reports the number of successful (#CS_STATE_ENABLED or #CS_STATE_DISABLED) entries, the number of + * reports the number of successful (#CS_ChecksumState_ENABLED or #CS_ChecksumState_DISABLED) entries, the number of * bad entries (due to invalid state definitions or duplicate names), and the number of entries - * marked as #CS_STATE_EMPTY. + * marked as #CS_ChecksumState_EMPTY. */ #define CS_VAL_TABLES_INF_EID 139 @@ -1819,7 +1818,7 @@ * \par Cause: * * This event message is issued when CS validation for the Apps definition table finds an entry - * that contains a zero-length name field with a state field that is not marked as #CS_STATE_EMPTY. This + * that contains a zero-length name field with a state field that is not marked as #CS_ChecksumState_EMPTY. This * event is only issued if it is the first error found during validation. */ #define CS_VAL_APP_DEF_TBL_ZERO_NAME_ERR_EID 141 @@ -1832,9 +1831,9 @@ * \par Cause: * * This event message when CS completes validation of the Apps definition table. This message - * reports the number of successful (#CS_STATE_ENABLED or #CS_STATE_DISABLED) entries, the number of + * reports the number of successful (#CS_ChecksumState_ENABLED or #CS_ChecksumState_DISABLED) entries, the number of * bad entries (due to invalid state definitions or duplicate names), and the number of entries - * marked as #CS_STATE_EMPTY. + * marked as #CS_ChecksumState_EMPTY. */ #define CS_VAL_APP_INF_EID 142 @@ -1846,9 +1845,9 @@ * \par Cause: * * This event message when CS completes validation of the Memory definition table. This message - * reports the number of successful (#CS_STATE_ENABLED or #CS_STATE_DISABLED) entries, the number of + * reports the number of successful (#CS_ChecksumState_ENABLED or #CS_ChecksumState_DISABLED) entries, the number of * bad entries (due to invalid state definitions or bad range), and the number of entries - * marked as #CS_STATE_EMPTY. + * marked as #CS_ChecksumState_EMPTY. */ #define CS_VAL_MEMORY_INF_EID 143 @@ -1860,9 +1859,9 @@ * \par Cause: * * This event message when CS completes validation of the EEPROM definition table. This message - * reports the number of successful (#CS_STATE_ENABLED or #CS_STATE_DISABLED) entries, the number of + * reports the number of successful (#CS_ChecksumState_ENABLED or #CS_ChecksumState_DISABLED) entries, the number of * bad entries (due to invalid state definitions or bad range), and the number of entries - * marked as #CS_STATE_EMPTY. + * marked as #CS_ChecksumState_EMPTY. */ #define CS_VAL_EEPROM_INF_EID 144 @@ -1986,6 +1985,18 @@ */ #define CS_VAL_APP_DEF_TBL_LONG_NAME_ERR_EID 154 +/** + * \brief CS Tables Table Validate Failed Illegal State With Long Name Event ID + * + * \par Type: ERROR + * + * \par Cause: + * + * This event message is issued when CS validation for the Table definition table finds an entry + * that contains a non-terminated name field. + */ +#define CS_VAL_TABLES_DEF_TBL_LONG_NAME_ERR_EID 155 + /**@}*/ #endif diff --git a/fsw/inc/cs_msgdefs.h b/fsw/inc/cs_fcncodes.h similarity index 89% rename from fsw/inc/cs_msgdefs.h rename to fsw/inc/cs_fcncodes.h index 11f1cd0..82a4843 100644 --- a/fsw/inc/cs_msgdefs.h +++ b/fsw/inc/cs_fcncodes.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -22,10 +21,10 @@ * Specification for the CFS Checksum command and telemetry * messages. */ -#ifndef CS_MSGDEFS_H -#define CS_MSGDEFS_H +#ifndef CS_FCNCODES_H +#define CS_FCNCODES_H -#include +#include "cs_fcncode_values.h" /** * \defgroup cfscscmdcodes CFS Checksum Command Codes @@ -39,7 +38,7 @@ * Implements the Noop command that insures the CS task is alive * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_NoopCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -61,7 +60,7 @@ * * \sa #CS_RESET_CC */ -#define CS_NOOP_CC 0 +#define CS_NOOP_CC CS_CCVAL(NOOP) /** * \brief Reset Counters @@ -70,7 +69,7 @@ * Resets the CS housekeeping counters * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_ResetCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -93,7 +92,7 @@ * * \sa #CS_NOOP_CC */ -#define CS_RESET_CC 1 +#define CS_RESET_CC CS_CCVAL(RESET) /** * \brief Start One shot calculation @@ -144,7 +143,7 @@ * #CS_RECOMPUTE_BASELINE_TABLE_CC, * #CS_RECOMPUTE_BASELINE_APP_CC */ -#define CS_ONE_SHOT_CC 2 +#define CS_ONE_SHOT_CC CS_CCVAL(ONE_SHOT) /** * \brief Cancel one shot @@ -153,7 +152,7 @@ * Cancels a one shot calculation that is already in progress. * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_CancelOneShotCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -179,7 +178,7 @@ * * \sa #CS_ONE_SHOT_CC */ -#define CS_CANCEL_ONE_SHOT_CC 3 +#define CS_CANCEL_ONE_SHOT_CC CS_CCVAL(CANCEL_ONE_SHOT) /** * \brief Enable Global Checksumming @@ -188,7 +187,7 @@ * Allows CS to continue background checking * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_EnableAllCSCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -196,7 +195,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_ENABLE_ALL_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.ChecksumState set to #CS_STATE_ENABLED + * - #CS_HkPacket_Payload_t.ChecksumState set to #CS_ChecksumState_ENABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -211,7 +210,7 @@ * * \sa #CS_DISABLE_ALL_CS_CC */ -#define CS_ENABLE_ALL_CS_CC 4 +#define CS_ENABLE_ALL_CS_CC CS_CCVAL(ENABLE_ALL_CS) /** * \brief Disable Global Checksumming @@ -220,7 +219,7 @@ * Disables all background checking * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_DisableAllCSCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -228,7 +227,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_DISABLE_ALL_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.ChecksumState set to #CS_STATE_DISABLED + * - #CS_HkPacket_Payload_t.ChecksumState set to #CS_ChecksumState_DISABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -243,7 +242,7 @@ * * \sa #CS_ENABLE_ALL_CS_CC */ -#define CS_DISABLE_ALL_CS_CC 5 +#define CS_DISABLE_ALL_CS_CC CS_CCVAL(DISABLE_ALL_CS) /** * \brief Enable checksumming of cFE core @@ -252,7 +251,7 @@ * Enables background checking on the cFE core code segment * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_EnableCfeCoreCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -260,7 +259,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_ENABLE_CFECORE_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.CfeCoreCSState set to #CS_STATE_ENABLED + * - #CS_HkPacket_Payload_t.CfeCoreCSState set to #CS_ChecksumState_ENABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -275,7 +274,7 @@ * * \sa #CS_DISABLE_CFE_CORE_CC */ -#define CS_ENABLE_CFE_CORE_CC 6 +#define CS_ENABLE_CFE_CORE_CC CS_CCVAL(ENABLE_CFE_CORE) /** * \brief Disable checksumming of cFE core @@ -284,7 +283,7 @@ * Disables background checking on the cFE core code segment * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_DisableCfeCoreCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -292,7 +291,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_DISABLE_CFECORE_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.CfeCoreCSState set to #CS_STATE_DISABLED + * - #CS_HkPacket_Payload_t.CfeCoreCSState set to #CS_ChecksumState_DISABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -307,7 +306,7 @@ * * \sa #CS_ENABLE_CFE_CORE_CC */ -#define CS_DISABLE_CFE_CORE_CC 7 +#define CS_DISABLE_CFE_CORE_CC CS_CCVAL(DISABLE_CFE_CORE) /** * \brief Report Baseline checksum of cFE core @@ -317,7 +316,7 @@ * that has already been calculated. * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_ReportBaselineCfeCoreCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -340,7 +339,7 @@ * None * */ -#define CS_REPORT_BASELINE_CFE_CORE_CC 8 +#define CS_REPORT_BASELINE_CFE_CORE_CC CS_CCVAL(REPORT_BASELINE_CFE_CORE) /** * \brief Recompute Baseline checksum of cFE core @@ -350,7 +349,7 @@ * and use the new value as the baseline. * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_RecomputeBaselineCfeCoreCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -383,7 +382,7 @@ * #CS_RECOMPUTE_BASELINE_TABLE_CC, * #CS_RECOMPUTE_BASELINE_APP_CC */ -#define CS_RECOMPUTE_BASELINE_CFE_CORE_CC 9 +#define CS_RECOMPUTE_BASELINE_CFE_CORE_CC CS_CCVAL(RECOMPUTE_BASELINE_CFE_CORE) /** * \brief Enable checksumming of OS code segment @@ -392,7 +391,7 @@ * Enables background checking on the OS code segment * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_EnableOSCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -408,14 +407,14 @@ * \par Evidence of failure may be found in the following telemetry: * - #CS_HkPacket_Payload_t.CmdErrCounter will increment * - Error specific event message #CS_CMD_LEN_ERR_EID - * - #CS_HkPacket_Payload_t.OSCSState set to #CS_STATE_ENABLED + * - #CS_HkPacket_Payload_t.OSCSState set to #CS_ChecksumState_ENABLED * * \par Criticality * None * * \sa #CS_DISABLE_OS_CC */ -#define CS_ENABLE_OS_CC 10 +#define CS_ENABLE_OS_CC CS_CCVAL(ENABLE_OS) /** * \brief Disable checksumming of OS code segment @@ -424,7 +423,7 @@ * Disables background checking on the OS code segment code segment * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_DisableOSCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -432,7 +431,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_DISABLE_OS_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.OSCSState set to #CS_STATE_DISABLED + * - #CS_HkPacket_Payload_t.OSCSState set to #CS_ChecksumState_DISABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -447,7 +446,7 @@ * * \sa #CS_ENABLE_OS_CC */ -#define CS_DISABLE_OS_CC 11 +#define CS_DISABLE_OS_CC CS_CCVAL(DISABLE_OS) /** * \brief Report Baseline checksum of OS code segment @@ -457,7 +456,7 @@ * that has already been calculated. * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_ReportBaselineOSCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -479,7 +478,7 @@ * \par Criticality * None */ -#define CS_REPORT_BASELINE_OS_CC 12 +#define CS_REPORT_BASELINE_OS_CC CS_CCVAL(REPORT_BASELINE_OS) /** * \brief Recompute Baseline checksum of OS code segment @@ -489,7 +488,7 @@ * and use the new value as the baseline. * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_RecomputeBaselineOSCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -521,7 +520,7 @@ * #CS_RECOMPUTE_BASELINE_TABLE_CC, * #CS_RECOMPUTE_BASELINE_APP_CC */ -#define CS_RECOMPUTE_BASELINE_OS_CC 13 +#define CS_RECOMPUTE_BASELINE_OS_CC CS_CCVAL(RECOMPUTE_BASELINE_OS) /** * \brief Enable checksumming for EEPROM table @@ -530,7 +529,7 @@ * Allow the EEPROM table to checksummed in the background * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_EnableEepromCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -538,7 +537,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_ENABLE_EEPROM_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.EepromCSState set to #CS_STATE_ENABLED + * - #CS_HkPacket_Payload_t.EepromCSState set to #CS_ChecksumState_ENABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -553,7 +552,7 @@ * * \sa #CS_DISABLE_EEPROM_CC */ -#define CS_ENABLE_EEPROM_CC 14 +#define CS_ENABLE_EEPROM_CC CS_CCVAL(ENABLE_EEPROM) /** * \brief Disable checksumming for EEPROM table @@ -562,7 +561,7 @@ * Disable the EEPROM table background checksumming * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_DisableEepromCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -570,7 +569,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_DISABLE_EEPROM_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.EepromCSState set to #CS_STATE_DISABLED + * - #CS_HkPacket_Payload_t.EepromCSState set to #CS_ChecksumState_DISABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -585,7 +584,7 @@ * * \sa #CS_ENABLE_EEPROM_CC */ -#define CS_DISABLE_EEPROM_CC 15 +#define CS_DISABLE_EEPROM_CC CS_CCVAL(DISABLE_EEPROM) /** * \brief Report Baseline checksum of EEPROM Entry @@ -595,7 +594,7 @@ * table entry that has already been calculated. * * \par Command Structure - * #CS_EntryCmd_t + * #CS_ReportBaselineEntryIDEepromCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -620,7 +619,7 @@ * None * */ -#define CS_REPORT_BASELINE_EEPROM_CC 16 +#define CS_REPORT_BASELINE_ENTRY_ID_EEPROM_CC CS_CCVAL(REPORT_BASELINE_ENTRY_ID_EEPROM) /** * \brief Recompute Baseline checksum of EEPROM Entry @@ -631,7 +630,7 @@ * This command spawns a child task to do the recompute. * * \par Command Structure - * #CS_EntryCmd_t + * #CS_RecomputeBaselineEepromCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -668,7 +667,7 @@ * #CS_RECOMPUTE_BASELINE_TABLE_CC, * #CS_RECOMPUTE_BASELINE_APP_CC */ -#define CS_RECOMPUTE_BASELINE_EEPROM_CC 17 +#define CS_RECOMPUTE_BASELINE_EEPROM_CC CS_CCVAL(RECOMPUTE_BASELINE_EEPROM) /** * \brief Enable checksumming for an EEPROM entry @@ -677,7 +676,7 @@ * Allow the EEPROM entry to checksummed in the background * * \par Command Structure - * #CS_EntryCmd_t + * #CS_EnableEntryIDEepromCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -699,9 +698,9 @@ * \par Criticality * None * - * \sa #CS_DISABLE_ENTRY_EEPROM_CC + * \sa #CS_DISABLE_ENTRY_ID_EEPROM_CC */ -#define CS_ENABLE_ENTRY_EEPROM_CC 18 +#define CS_ENABLE_ENTRY_ID_EEPROM_CC CS_CCVAL(ENABLE_ENTRY_ID_EEPROM) /** * \brief Disable checksumming for an EEPROM entry @@ -710,7 +709,7 @@ * Disable the EEPROM entry background checksumming * * \par Command Structure - * #CS_EntryCmd_t + * #CS_DisableEntryIDEepromCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -732,9 +731,9 @@ * \par Criticality * None * - * \sa #CS_ENABLE_ENTRY_EEPROM_CC + * \sa #CS_ENABLE_ENTRY_ID_EEPROM_CC */ -#define CS_DISABLE_ENTRY_EEPROM_CC 19 +#define CS_DISABLE_ENTRY_ID_EEPROM_CC CS_CCVAL(DISABLE_ENTRY_ID_EEPROM) /** * \brief Get the Entry ID for a given EEPROM address @@ -744,7 +743,7 @@ * subsequent commands. * * \par Command Structure - * #CS_GetEntryIDCmd_t + * #CS_GetEntryIDEepromCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -766,7 +765,7 @@ * \par Criticality * None */ -#define CS_GET_ENTRY_ID_EEPROM_CC 20 +#define CS_GET_ENTRY_ID_EEPROM_CC CS_CCVAL(GET_ENTRY_ID_EEPROM) /** * \brief Enable checksumming for Memory table @@ -775,7 +774,7 @@ * Allow the Memory table to checksummed in the background * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_EnableMemoryCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -783,7 +782,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_ENABLE_MEMORY_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.MemoryCSState set to #CS_STATE_ENABLED + * - #CS_HkPacket_Payload_t.MemoryCSState set to #CS_ChecksumState_ENABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -798,7 +797,7 @@ * * \sa #CS_DISABLE_MEMORY_CC */ -#define CS_ENABLE_MEMORY_CC 21 +#define CS_ENABLE_MEMORY_CC CS_CCVAL(ENABLE_MEMORY) /** * \brief Disable checksumming for Memory table @@ -807,7 +806,7 @@ * Disable the Memory table background checksumming * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_DisableMemoryCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -815,7 +814,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_DISABLE_MEMORY_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.MemoryCSState set to #CS_STATE_DISABLED + * - #CS_HkPacket_Payload_t.MemoryCSState set to #CS_ChecksumState_DISABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -830,7 +829,7 @@ * * \sa #CS_ENABLE_MEMORY_CC */ -#define CS_DISABLE_MEMORY_CC 22 +#define CS_DISABLE_MEMORY_CC CS_CCVAL(DISABLE_MEMORY) /** * \brief Report Baseline checksum of Memory Entry @@ -840,7 +839,7 @@ * table entry that has already been calculated. * * \par Command Structure - * #CS_EntryCmd_t + * #CS_ReportBaselineEntryIDMemoryCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -864,7 +863,7 @@ * \par Criticality * None */ -#define CS_REPORT_BASELINE_MEMORY_CC 23 +#define CS_REPORT_BASELINE_ENTRY_ID_MEMORY_CC CS_CCVAL(REPORT_BASELINE_ENTRY_ID_MEMORY) /** * \brief Recompute Baseline checksum of Memory Entry @@ -875,7 +874,7 @@ * This command spawns a child task to do the recompute. * * \par Command Structure - * #CS_EntryCmd_t + * #CS_RecomputeBaselineMemoryCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -912,7 +911,7 @@ * #CS_RECOMPUTE_BASELINE_TABLE_CC, * #CS_RECOMPUTE_BASELINE_APP_CC */ -#define CS_RECOMPUTE_BASELINE_MEMORY_CC 24 +#define CS_RECOMPUTE_BASELINE_MEMORY_CC CS_CCVAL(RECOMPUTE_BASELINE_MEMORY) /** * \brief Enable checksumming for a Memory entry @@ -921,7 +920,7 @@ * Allow the Memory entry to checksummed in the background * * \par Command Structure - * #CS_EntryCmd_t + * #CS_EnableEntryIDMemoryCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -943,9 +942,9 @@ * \par Criticality * None * - * \sa #CS_DISABLE_ENTRY_MEMORY_CC + * \sa #CS_DISABLE_ENTRY_ID_MEMORY_CC */ -#define CS_ENABLE_ENTRY_MEMORY_CC 25 +#define CS_ENABLE_ENTRY_ID_MEMORY_CC CS_CCVAL(ENABLE_ENTRY_ID_MEMORY) /** * \brief Disable checksumming for a Memory entry @@ -954,7 +953,7 @@ * Disable the Memory entry background checksumming * * \par Command Structure - * #CS_EntryCmd_t + * #CS_DisableEntryIDMemoryCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -976,9 +975,9 @@ * \par Criticality * None * - * \sa #CS_ENABLE_ENTRY_MEMORY_CC + * \sa #CS_ENABLE_ENTRY_ID_MEMORY_CC */ -#define CS_DISABLE_ENTRY_MEMORY_CC 26 +#define CS_DISABLE_ENTRY_ID_MEMORY_CC CS_CCVAL(DISABLE_ENTRY_ID_MEMORY) /** * \brief Get the Entry ID for a given Memory address @@ -988,7 +987,7 @@ * subsequent commands. * * \par Command Structure - * #CS_GetEntryIDCmd_t + * #CS_GetEntryIDMemoryCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -1011,7 +1010,7 @@ * None * */ -#define CS_GET_ENTRY_ID_MEMORY_CC 27 +#define CS_GET_ENTRY_ID_MEMORY_CC CS_CCVAL(GET_ENTRY_ID_MEMORY) /** * \brief Enable checksumming for Tables table @@ -1020,7 +1019,7 @@ * Allow the Tables table to checksummed in the background * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_EnableTablesCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -1028,7 +1027,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_ENABLE_TABLES_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.TablesCSState set to #CS_STATE_ENABLED + * - #CS_HkPacket_Payload_t.TablesCSState set to #CS_ChecksumState_ENABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -1043,7 +1042,7 @@ * * \sa #CS_DISABLE_TABLES_CC */ -#define CS_ENABLE_TABLES_CC 28 +#define CS_ENABLE_TABLES_CC CS_CCVAL(ENABLE_TABLES) /** * \brief Disable checksumming for Tables table @@ -1052,7 +1051,7 @@ * Disable the Tables table background checksumming * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_DisableTablesCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -1060,7 +1059,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_DISABLE_TABLES_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.TablesCSState set to #CS_STATE_DISABLED + * - #CS_HkPacket_Payload_t.TablesCSState set to #CS_ChecksumState_DISABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -1075,7 +1074,7 @@ * * \sa #CS_ENABLE_TABLES_CC */ -#define CS_DISABLE_TABLES_CC 29 +#define CS_DISABLE_TABLES_CC CS_CCVAL(DISABLE_TABLES) /** * \brief Report Baseline checksum of a table @@ -1085,15 +1084,15 @@ * table that has already been calculated. * * \par Command Structure - * #CS_TableNameCmd_t + * #CS_ReportBaselineTableCmd_t * * \par Command Verification * Successful execution of this command may be verified with * the following telemetry: * - #CS_HkPacket_Payload_t.CmdCounter will increment - * - The #CS_BASELINE_TABLES_INF_EID informational event message will be + * - The #CS_BASELINE_TABLE_INF_EID informational event message will be * generated when the command is received, or - * - The #CS_NO_BASELINE_TABLES_INF_EID informational event message will be + * - The #CS_NO_BASELINE_TABLE_INF_EID informational event message will be * generated when the command is received * * \par Error Conditions @@ -1109,7 +1108,7 @@ * \par Criticality * None */ -#define CS_REPORT_BASELINE_TABLE_CC 30 +#define CS_REPORT_BASELINE_TABLE_CC CS_CCVAL(REPORT_BASELINE_TABLE) /** * \brief Recompute Baseline checksum of a table @@ -1120,7 +1119,7 @@ * This command spawns a child task to do the recompute. * * \par Command Structure - * #CS_TableNameCmd_t + * #CS_RecomputeBaselineTableCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -1163,7 +1162,7 @@ * #CS_RECOMPUTE_BASELINE_MEMORY_CC, * #CS_RECOMPUTE_BASELINE_APP_CC */ -#define CS_RECOMPUTE_BASELINE_TABLE_CC 31 +#define CS_RECOMPUTE_BASELINE_TABLE_CC CS_CCVAL(RECOMPUTE_BASELINE_TABLE) /** * \brief Enable checksumming for a table @@ -1172,7 +1171,7 @@ * Allow the table to checksummed in the background * * \par Command Structure - * #CS_TableNameCmd_t + * #CS_EnableNameTableCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -1196,7 +1195,7 @@ * * \sa #CS_DISABLE_NAME_TABLE_CC */ -#define CS_ENABLE_NAME_TABLE_CC 32 +#define CS_ENABLE_NAME_TABLE_CC CS_CCVAL(ENABLE_NAME_TABLE) /** * \brief Disable checksumming for a table @@ -1205,7 +1204,7 @@ * Disable background checking of the table * * \par Command Structure - * #CS_TableNameCmd_t + * #CS_DisableNameTableCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -1227,9 +1226,9 @@ * \par Criticality * None * - * \sa #CS_DISABLE_NAME_TABLE_CC + * \sa #CS_ENABLE_NAME_TABLE_CC */ -#define CS_DISABLE_NAME_TABLE_CC 33 +#define CS_DISABLE_NAME_TABLE_CC CS_CCVAL(DISABLE_NAME_TABLE) /** * \brief Enable checksumming for App table @@ -1238,7 +1237,7 @@ * Allow the App table to checksummed in the background * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_EnableAppsCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -1246,7 +1245,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_ENABLE_APP_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.AppCSState set to #CS_STATE_ENABLED + * - #CS_HkPacket_Payload_t.AppCSState set to #CS_ChecksumState_ENABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -1261,7 +1260,7 @@ * * \sa #CS_DISABLE_APPS_CC */ -#define CS_ENABLE_APPS_CC 34 +#define CS_ENABLE_APPS_CC CS_CCVAL(ENABLE_APPS) /** * \brief Disable checksumming for App table @@ -1270,7 +1269,7 @@ * Disable the App table background checksumming * * \par Command Structure - * #CS_NoArgsCmd_t + * #CS_DisableAppsCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -1278,7 +1277,7 @@ * - #CS_HkPacket_Payload_t.CmdCounter will increment * - The #CS_DISABLE_APP_INF_EID informational event message will be * generated when the command is received - * - #CS_HkPacket_Payload_t.AppCSState set to #CS_STATE_DISABLED + * - #CS_HkPacket_Payload_t.AppCSState set to #CS_ChecksumState_DISABLED * * \par Error Conditions * This command may fail for the following reason(s): @@ -1293,7 +1292,7 @@ * * \sa #CS_ENABLE_APPS_CC */ -#define CS_DISABLE_APPS_CC 35 +#define CS_DISABLE_APPS_CC CS_CCVAL(DISABLE_APPS) /** * \brief Report Baseline checksum of an app @@ -1303,7 +1302,7 @@ * app that has already been calculated. * * \par Command Structure - * #CS_AppNameCmd_t + * #CS_ReportBaselineAppCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -1327,7 +1326,7 @@ * \par Criticality * None */ -#define CS_REPORT_BASELINE_APP_CC 36 +#define CS_REPORT_BASELINE_APP_CC CS_CCVAL(REPORT_BASELINE_APP) /** * \brief Recompute Baseline checksum of an app @@ -1338,7 +1337,7 @@ * This command spawns a child task to do the recompute. * * \par Command Structure - * #CS_AppNameCmd_t + * #CS_RecomputeBaselineAppCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -1375,7 +1374,7 @@ * #CS_RECOMPUTE_BASELINE_MEMORY_CC, * #CS_RECOMPUTE_BASELINE_TABLE_CC */ -#define CS_RECOMPUTE_BASELINE_APP_CC 37 +#define CS_RECOMPUTE_BASELINE_APP_CC CS_CCVAL(RECOMPUTE_BASELINE_APP) /** * \brief Enable checksumming for an app @@ -1384,7 +1383,7 @@ * Allow the app to checksummed in the background * * \par Command Structure - * #CS_AppNameCmd_t + * #CS_EnableNameAppCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -1408,7 +1407,7 @@ * * \sa #CS_DISABLE_NAME_APP_CC */ -#define CS_ENABLE_NAME_APP_CC 38 +#define CS_ENABLE_NAME_APP_CC CS_CCVAL(ENABLE_NAME_APP) /** * \brief Disable checksumming for an app @@ -1417,7 +1416,7 @@ * Disable background checking of the app * * \par Command Structure - * #CS_AppNameCmd_t + * #CS_DisableNameAppCmd_t * * \par Command Verification * Successful execution of this command may be verified with @@ -1441,31 +1440,8 @@ * * \sa #CS_DISABLE_NAME_APP_CC */ -#define CS_DISABLE_NAME_APP_CC 39 - -/**\}*/ +#define CS_DISABLE_NAME_APP_CC CS_CCVAL(DISABLE_NAME_APP) -/** - * \name CS Checksum Type Number Definitions - * \{ - */ -#define CS_CFECORE 0 /**< \brief cFE Core checksum */ -#define CS_OSCORE 1 /**< \brief OS Core checksum */ -#define CS_EEPROM_TABLE 2 /**< \brief EEPROM checksum */ -#define CS_MEMORY_TABLE 3 /**< \brief Memory checksum */ -#define CS_TABLES_TABLE 4 /**< \brief Tables checksum */ -#define CS_APP_TABLE 5 /**< \brief App checksum */ -#define CS_NUM_TABLES 6 /**< \brief Number of checksum types*/ -/**\}*/ - -/** - * \name CS Checkum States - * \{ - */ -#define CS_STATE_EMPTY 0x00 /**< \brief Entry unused */ -#define CS_STATE_ENABLED 0x01 /**< \brief Entry or table enabled */ -#define CS_STATE_DISABLED 0x02 /**< \brief Entry or table disabled */ -#define CS_STATE_UNDEFINED 0x03 /**< \brief Entry not found state undefined */ /**\}*/ #ifndef CS_OMIT_DEPRECATED diff --git a/fsw/inc/cs_interface_cfg.h b/fsw/inc/cs_interface_cfg.h new file mode 100644 index 0000000..71e5897 --- /dev/null +++ b/fsw/inc/cs_interface_cfg.h @@ -0,0 +1,104 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Specification for the CFS Checksum macro constants that can + * be configured from one mission to another + */ +#ifndef CS_INTERFACE_CFG_H +#define CS_INTERFACE_CFG_H + +#include "cs_interface_cfg_values.h" + +/** + * \defgroup cfscsmissioncfg CFS Checksum Mission Configuration + * \{ + */ + +/** + * \brief default CRC algorithm + * + * \par Description: + * This parameter is the algorithm used by CS to checksum + * the requested data. + * + * \par Limits: + * This parameter is limited to either #CFE_MISSION_ES_DEFAULT_CRC, + * or #CFE_ES_CrcType_CRC_16 + */ +#define CS_DEFAULT_ALGORITHM CS_INTERFACE_CFGVAL(DEFAULT_ALGORITHM) +#define DEFAULT_CS_INTERFACE_DEFAULT_ALGORITHM CFE_MISSION_ES_DEFAULT_CRC + +/** + * \brief Maximum number of entries in the EEPROM table to checksum + * + * \par Description: + * Maximum number of entries that can be in the table of + * EEPROM areas to checksum. + * + * \par Limits: + * This parameter is limited by the uint16 datatype that defines it. + * This parameter is limited to 65535. + */ +#define CS_MAX_NUM_EEPROM_TABLE_ENTRIES CS_INTERFACE_CFGVAL(MAX_NUM_EEPROM_TABLE_ENTRIES) +#define DEFAULT_CS_INTERFACE_MAX_NUM_EEPROM_TABLE_ENTRIES 16 + +/** + * \brief Maximum number of entries in the Memory table to checksum + * + * \par Description: + * Maximum number of entries that can be in the table of + * Memory areas to checksum. + * + * \par Limits: + * This parameter is limited by the uint16 datatype that defines it. + * This parameter is limited to 65535. + */ +#define CS_MAX_NUM_MEMORY_TABLE_ENTRIES CS_INTERFACE_CFGVAL(MAX_NUM_MEMORY_TABLE_ENTRIES) +#define DEFAULT_CS_INTERFACE_MAX_NUM_MEMORY_TABLE_ENTRIES 16 + +/** + * \brief Maximum number of tables to checksum + * + * \par Description: + * Maximum number of entries in the table of tables to checksum + * + * \par Limits: + * This parameter is limited by the maximum number of tables allowed + * in the system. This parameter is limited to #CFE_PLATFORM_TBL_MAX_NUM_TABLES + */ +#define CS_MAX_NUM_TABLES_TABLE_ENTRIES CS_INTERFACE_CFGVAL(MAX_NUM_TABLES_TABLE_ENTRIES) +#define DEFAULT_CS_INTERFACE_MAX_NUM_TABLES_TABLE_ENTRIES 24 + +/** + * \brief Maximum number of applications to checksum + * + * \par Description: + * Maximum number of entries in the table of applications to checksum + * + * \par Limits: + * This parameter is limited by the maximum number of applications allowed + * in the system. This parameter is limited to #CFE_PLATFORM_ES_MAX_APPLICATIONS + */ +#define CS_MAX_NUM_APP_TABLE_ENTRIES CS_INTERFACE_CFGVAL(MAX_NUM_APP_TABLE_ENTRIES) +#define DEFAULT_CS_INTERFACE_MAX_NUM_APP_TABLE_ENTRIES 24 + +/**\}*/ + +#endif diff --git a/fsw/inc/cs_platform_cfg.h b/fsw/inc/cs_internal_cfg.h similarity index 66% rename from fsw/inc/cs_platform_cfg.h rename to fsw/inc/cs_internal_cfg.h index bbf6518..633ae8c 100644 --- a/fsw/inc/cs_platform_cfg.h +++ b/fsw/inc/cs_internal_cfg.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -22,10 +21,10 @@ * Specification for the CFS Checksum constants that can * be configured from one platform to another */ -#ifndef CS_PLATFORM_CFG_H -#define CS_PLATFORM_CFG_H +#ifndef CS_INTERNAL_CFG_H +#define CS_INTERNAL_CFG_H -#include /* for CFE_ES_DEFAULT_STACK_SIZE */ +#include "cs_internal_cfg_values.h" /** * \defgroup cfscsplatformcfg CFS Checksum Platform Configuration @@ -43,7 +42,8 @@ * The string length (including string terminator) cannot exceed * #OS_MAX_PATH_LEN. (limit is not verified) */ -#define CS_DEF_EEPROM_TABLE_FILENAME "/cf/cs_eepromtbl.tbl" +#define CS_DEF_EEPROM_TABLE_FILENAME CS_INTERNAL_CFGVAL(DEF_EEPROM_TABLE_FILENAME) +#define DEFAULT_CS_INTERNAL_DEF_EEPROM_TABLE_FILENAME "/cf/cs_eepromtbl.tbl" /** * \brief Memory Address File Table -- default table filename @@ -56,7 +56,8 @@ * The string length (including string terminator) cannot exceed * #OS_MAX_PATH_LEN. (limit is not verified) */ -#define CS_DEF_MEMORY_TABLE_FILENAME "/cf/cs_memorytbl.tbl" +#define CS_DEF_MEMORY_TABLE_FILENAME CS_INTERNAL_CFGVAL(DEF_MEMORY_TABLE_FILENAME) +#define DEFAULT_CS_INTERNAL_DEF_MEMORY_TABLE_FILENAME "/cf/cs_memorytbl.tbl" /** * \brief Tables File Table -- default table filename @@ -69,7 +70,8 @@ * The string length (including string terminator) cannot exceed * #OS_MAX_PATH_LEN. (limit is not verified) */ -#define CS_DEF_TABLES_TABLE_FILENAME "/cf/cs_tablestbl.tbl" +#define CS_DEF_TABLES_TABLE_FILENAME CS_INTERNAL_CFGVAL(DEF_TABLES_TABLE_FILENAME) +#define DEFAULT_CS_INTERNAL_DEF_TABLES_TABLE_FILENAME "/cf/cs_tablestbl.tbl" /** * \brief Application File Table -- default table filename @@ -82,7 +84,8 @@ * The string length (including string terminator) cannot exceed * #OS_MAX_PATH_LEN. (limit is not verified) */ -#define CS_DEF_APP_TABLE_FILENAME "/cf/cs_apptbl.tbl" +#define CS_DEF_APP_TABLE_FILENAME CS_INTERNAL_CFGVAL(DEF_APP_TABLE_FILENAME) +#define DEFAULT_CS_INTERNAL_DEF_APP_TABLE_FILENAME "/cf/cs_apptbl.tbl" /** * \brief Application Pipe Depth @@ -97,57 +100,8 @@ * \par Limits: * The value must be greater than zero */ -#define CS_PIPE_DEPTH (3 * CFE_PLATFORM_SB_DEFAULT_MSG_LIMIT) - -/** - * \brief Maximum number of entries in the EEPROM table to checksum - * - * \par Description: - * Maximum number of entries that can be in the table of - * EEPROM areas to checksum. - * - * \par Limits: - * This parameter is limited by the uint16 datatype that defines it. - * This parameter is limited to 65535. - */ -#define CS_MAX_NUM_EEPROM_TABLE_ENTRIES 16 - -/** - * \brief Maximum number of entries in the Memory table to checksum - * - * \par Description: - * Maximum number of entries that can be in the table of - * Memory areas to checksum. - * - * \par Limits: - * This parameter is limited by the uint16 datatype that defines it. - * This parameter is limited to 65535. - */ -#define CS_MAX_NUM_MEMORY_TABLE_ENTRIES 16 - -/** - * \brief Maximum number of tables to checksum - * - * \par Description: - * Maximum number of entries in the table of tables to checksum - * - * \par Limits: - * This parameter is limited by the maximum number of tables allowed - * in the system. This parameter is limited to #CFE_PLATFORM_TBL_MAX_NUM_TABLES - */ -#define CS_MAX_NUM_TABLES_TABLE_ENTRIES 24 - -/** - * \brief Maximum number of applications to checksum - * - * \par Description: - * Maximum number of entries in the table of applications to checksum - * - * \par Limits: - * This parameter is limited by the maximum number of applications allowed - * in the system. This parameter is limited to #CFE_PLATFORM_ES_MAX_APPLICATIONS - */ -#define CS_MAX_NUM_APP_TABLE_ENTRIES 24 +#define CS_PIPE_DEPTH CS_INTERNAL_CFGVAL(PIPE_DEPTH) +#define DEFAULT_CS_INTERNAL_PIPE_DEPTH (3 * CFE_PLATFORM_SB_DEFAULT_MSG_LIMIT) /** * \brief Default number of bytes to checksum per cycle @@ -161,7 +115,8 @@ * range is 0 to 0xFFFFFFFF. Note that "0" is a valid value, and will * result in a checksum of 0. */ -#define CS_DEFAULT_BYTES_PER_CYCLE (1024 * 16) +#define CS_DEFAULT_BYTES_PER_CYCLE CS_INTERNAL_CFGVAL(DEFAULT_BYTES_PER_CYCLE) +#define DEFAULT_CS_INTERNAL_DEFAULT_BYTES_PER_CYCLE (1024 * 16) /** * \brief CS Child Task Priority @@ -173,7 +128,8 @@ * \par Limits: * Valid range for a child task is 1 to 255 */ -#define CS_CHILD_TASK_PRIORITY 200 +#define CS_CHILD_TASK_PRIORITY CS_INTERNAL_CFGVAL(CHILD_TASK_PRIORITY) +#define DEFAULT_CS_INTERNAL_CHILD_TASK_PRIORITY 200 /** * \brief Delay between checksumming cycles for child task @@ -189,7 +145,8 @@ * CS does not place limits on this parameter. It is intended to * be configurable to prevent the child task from hogging the CPU */ -#define CS_CHILD_TASK_DELAY 1000 +#define CS_CHILD_TASK_DELAY CS_INTERNAL_CFGVAL(CHILD_TASK_DELAY) +#define DEFAULT_CS_INTERNAL_CHILD_TASK_DELAY 1000 /** * \brief Timeout for waiting for other apps to start @@ -206,7 +163,8 @@ * CS does not place limits on this parameter. It is intended to * be configurable to allow enough time for all apps to start. */ -#define CS_STARTUP_TIMEOUT 60000 +#define CS_STARTUP_TIMEOUT CS_INTERNAL_CFGVAL(STARTUP_TIMEOUT) +#define DEFAULT_CS_INTERNAL_STARTUP_TIMEOUT 60000 /** * \brief Desired state of the checksumming of OS code segment at power on @@ -216,9 +174,10 @@ * OS code segment should be in at power on * * \par Limits: - * This can either be CS_STATE_ENABLED or CS_STATE_DISABLED + * This can either be CS_ChecksumState_ENABLED or CS_ChecksumState_DISABLED */ -#define CS_OSCS_CHECKSUM_STATE CS_STATE_ENABLED +#define CS_OSCS_CHECKSUM_STATE CS_INTERNAL_CFGVAL(OSCS_CHECKSUM_STATE) +#define DEFAULT_CS_INTERNAL_OSCS_CHECKSUM_STATE CS_ChecksumState_ENABLED /** * \brief Desired state of the checksumming of CFE core checksum at power on @@ -228,9 +187,10 @@ * CFE core should be in at power on * * \par Limits: - * This can either be CS_STATE_ENABLED or CS_STATE_DISABLED + * This can either be CS_ChecksumState_ENABLED or CS_ChecksumState_DISABLED */ -#define CS_CFECORE_CHECKSUM_STATE CS_STATE_ENABLED +#define CS_CFECORE_CHECKSUM_STATE CS_INTERNAL_CFGVAL(CFECORE_CHECKSUM_STATE) +#define DEFAULT_CS_INTERNAL_CFECORE_CHECKSUM_STATE CS_ChecksumState_ENABLED /** * \brief Desired state of the EEPROM table at power on @@ -240,9 +200,10 @@ * be in at power on * * \par Limits: - * This can either be CS_STATE_ENABLED or CS_STATE_DISABLED + * This can either be CS_ChecksumState_ENABLED or CS_ChecksumState_DISABLED */ -#define CS_EEPROM_TBL_POWERON_STATE CS_STATE_ENABLED +#define CS_EEPROM_TBL_POWERON_STATE CS_INTERNAL_CFGVAL(EEPROM_TBL_POWERON_STATE) +#define DEFAULT_CS_INTERNAL_EEPROM_TBL_POWERON_STATE CS_ChecksumState_ENABLED /** * \brief Desired state of the Memory table at power on @@ -252,9 +213,10 @@ * be in at power on * * \par Limits: - * This can either be CS_STATE_ENABLED or CS_STATE_DISABLED + * This can either be CS_ChecksumState_ENABLED or CS_ChecksumState_DISABLED */ -#define CS_MEMORY_TBL_POWERON_STATE CS_STATE_ENABLED +#define CS_MEMORY_TBL_POWERON_STATE CS_INTERNAL_CFGVAL(MEMORY_TBL_POWERON_STATE) +#define DEFAULT_CS_INTERNAL_MEMORY_TBL_POWERON_STATE CS_ChecksumState_ENABLED /** * \brief Desired state of the Applications table at power on @@ -264,9 +226,10 @@ * be in at power on * * \par Limits: - * This can either be CS_STATE_ENABLED or CS_STATE_DISABLED + * This can either be CS_ChecksumState_ENABLED or CS_ChecksumState_DISABLED */ -#define CS_APPS_TBL_POWERON_STATE CS_STATE_ENABLED +#define CS_APPS_TBL_POWERON_STATE CS_INTERNAL_CFGVAL(APPS_TBL_POWERON_STATE) +#define DEFAULT_CS_INTERNAL_APPS_TBL_POWERON_STATE CS_ChecksumState_ENABLED /** * \brief Desired state of the Tables table at power on @@ -276,9 +239,10 @@ * be in at power on * * \par Limits: - * This can either be CS_STATE_ENABLED or CS_STATE_DISABLED + * This can either be CS_ChecksumState_ENABLED or CS_ChecksumState_DISABLED */ -#define CS_TABLES_TBL_POWERON_STATE CS_STATE_ENABLED +#define CS_TABLES_TBL_POWERON_STATE CS_INTERNAL_CFGVAL(TABLES_TBL_POWERON_STATE) +#define DEFAULT_CS_INTERNAL_TABLES_TBL_POWERON_STATE CS_ChecksumState_ENABLED /** * \brief Whether to preserve checksum states on processor reset @@ -290,7 +254,8 @@ * \par Limits: * None */ -#define CS_PRESERVE_STATES_ON_PROCESSOR_RESET true +#define CS_PRESERVE_STATES_ON_PROCESSOR_RESET CS_INTERNAL_CFGVAL(PRESERVE_STATES_ON_PROCESSOR_RESET) +#define DEFAULT_CS_INTERNAL_PRESERVE_STATES_ON_PROCESSOR_RESET true /** * \brief Name of the Critical Data Store Used for CS @@ -304,7 +269,8 @@ * \par Limits: * Must be a unique string with regards to CDS */ -#define CS_CDS_NAME "CS_CDS" +#define CS_CDS_NAME CS_INTERNAL_CFGVAL(CDS_NAME) +#define DEFAULT_CS_INTERNAL_CDS_NAME "CS_CDS" /** * \brief Mission specific version number for CS application @@ -320,7 +286,8 @@ * Must be defined as a numeric value that is greater than * or equal to zero. */ -#define CS_MISSION_REV 0 +#define CS_MISSION_REV CS_INTERNAL_CFGVAL(MISSION_REV) +#define DEFAULT_CS_INTERNAL_MISSION_REV 0 /**\}*/ diff --git a/fsw/inc/cs_msg.h b/fsw/inc/cs_msg.h deleted file mode 100644 index 8fecf28..0000000 --- a/fsw/inc/cs_msg.h +++ /dev/null @@ -1,203 +0,0 @@ -/************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” - * - * Copyright (c) 2021 United States Government as represented by the - * Administrator of the National Aeronautics and Space Administration. - * All Rights Reserved. - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may - * not use this file except in compliance with the License. You may obtain - * a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - ************************************************************************/ - -/** - * @file - * Specification for the CFS Checksum command and telemetry - * messages. - */ -#ifndef CS_MSG_H -#define CS_MSG_H - -#include - -/** - * \defgroup cfscstlm CFS Checksum Telemetry - * \{ - */ - -/** - * \brief Housekeeping Payload Structure - */ -typedef struct -{ - uint8 CmdCounter; /**< \brief CS Application Command Counter */ - uint8 CmdErrCounter; /**< \brief CS Application Command Error Counter */ - uint8 ChecksumState; /**< \brief CS Application global checksum state */ - uint8 EepromCSState; /**< \brief CS EEPROM table checksum state */ - uint8 MemoryCSState; /**< \brief CS Memory table checksum state */ - uint8 AppCSState; /**< \brief CS App table checksum state */ - uint8 TablesCSState; /**< \brief CS Tables table checksum state */ - uint8 OSCSState; /**< \brief OS code segment checksum state */ - uint8 CfeCoreCSState; /**< \brief cFE Core code segment checksum stat e*/ - uint8 RecomputeInProgress; /**< \brief CS "Recompute In Progress" flag */ - uint8 OneShotInProgress; /**< \brief CS "OneShot In Progress" flag */ - uint8 Filler8; /**< \brief 8 bit padding */ - uint16 EepromCSErrCounter; /**< \brief EEPROM miscompare counter */ - uint16 MemoryCSErrCounter; /**< \brief Memory miscompare counter */ - uint16 AppCSErrCounter; /**< \brief App miscompare counter */ - uint16 TablesCSErrCounter; /**< \brief Tables miscompare counter */ - uint16 CfeCoreCSErrCounter; /**< \brief cFE core miscompare counter */ - uint16 OSCSErrCounter; /**< \brief OS code segment miscopmare counter */ - uint16 CurrentCSTable; /**< \brief Current table being checksummed */ - uint16 CurrentEntryInTable; /**< \brief Current entry ID in table being checksummed */ - uint32 EepromBaseline; /**< \brief Baseline checksum for all of EEPROM */ - uint32 OSBaseline; /**< \brief Baseline checksum for the OS code segment */ - uint32 CfeCoreBaseline; /**< \brief Basline checksum for the cFE core */ - cpuaddr LastOneShotAddress; /**< \brief Address used in last one shot checksum command */ - uint32 LastOneShotSize; /**< \brief Size used in the last one shot checksum command */ - uint32 LastOneShotMaxBytesPerCycle; /**< \brief Max bytes per cycle for last one shot checksum command */ - uint32 LastOneShotChecksum; /**< \brief Checksum of the last one shot checksum command */ - uint32 PassCounter; /**< \brief Number of times CS has passed through all of its tables */ -} CS_HkPacket_Payload_t; - -/** - * \brief Housekeeping Packet Structure - */ -typedef struct -{ - CFE_MSG_TelemetryHeader_t TelemetryHeader; /**< \brief cFE SB Tlm Msg Hdr */ - CS_HkPacket_Payload_t Payload; /**< \brief CS HK Payload */ -} CS_HkPacket_t; - -/**\}*/ - -/** - * \defgroup cfscscmdstructs CFS Checksum Command Structures - * \{ - */ - -/** - * \brief Get entry ID command payload - */ -typedef struct -{ - cpuaddr Address; /**< \brief Address to get the ID for */ -} CS_GetEntryIDCmd_Payload_t; - -/** - * \brief Payload for commands using Memory or EEPROM tables - */ -typedef struct -{ - uint32 EntryID; /**< \brief EntryID to perform a command on */ -} CS_EntryCmd_Payload_t; - -/** - * \brief Payload for commanding by table name - */ -typedef struct -{ - char Name[CFE_TBL_MAX_FULL_NAME_LEN]; /**< \brief Table name to perform a command on */ -} CS_TableNameCmd_Payload_t; - -/** - * \brief Payload for commanding by app name - */ -typedef struct -{ - char Name[OS_MAX_API_NAME]; /**< \brief App name to perform a command on */ -} CS_AppNameCmd_Payload_t; - -/** - * \brief Payload for sending one shot calculation - */ -typedef struct -{ - cpuaddr Address; /**< \brief Address to start checksum */ - uint32 Size; /**< \brief Number of bytes to checksum */ - uint32 MaxBytesPerCycle; /**< \brief Max Number of bytes to compute per cycle. Value of Zero to use platform config - value */ -} CS_OneShotCmd_Payload_t; - -/** - * \brief No arguments command data type - * - * For command details see #CS_NOOP_CC #CS_RESET_CC, #CS_ENABLE_ALL_CS_CC, - * #CS_DISABLE_ALL_CS_CC, #CS_ENABLE_CFE_CORE_CC, #CS_DISABLE_CFE_CORE_CC, #CS_ENABLE_OS_CC, - * #CS_DISABLE_OS_CC, #CS_ENABLE_EEPROM_CC, #CS_DISABLE_EEPROM_CC, #CS_ENABLE_MEMORY_CC, - * #CS_DISABLE_MEMORY_CC, #CS_ENABLE_TABLES_CC, #CS_DISABLE_TABLES_CC - * #CS_ENABLE_APPS_CC, #CS_DISABLE_APPS_CC, #CS_CANCEL_ONE_SHOT_CC - */ -typedef struct -{ - CFE_MSG_CommandHeader_t CommandHeader; -} CS_NoArgsCmd_t; - -/** - * \brief Get entry ID command - * - * For command details see CS_GET_ENTRY_ID_EEPROM_CC, #CS_GET_ENTRY_ID_MEMORY_CC - */ -typedef struct -{ - CFE_MSG_CommandHeader_t CommandHeader; - CS_GetEntryIDCmd_Payload_t Payload; -} CS_GetEntryIDCmd_t; - -/** - * \brief Command type for commands using Memory or EEPROM tables - * - * For command details see #CS_ENABLE_ENTRY_EEPROM_CC, #CS_DISABLE_ENTRY_EEPROM_CC, - * #CS_ENABLE_ENTRY_MEMORY_CC, #CS_DISABLE_ENTRY_MEMORY_CC - */ -typedef struct -{ - CFE_MSG_CommandHeader_t CommandHeader; - CS_EntryCmd_Payload_t Payload; -} CS_EntryCmd_t; - -/** - * \brief Command type for commanding by table name - * - * For command details see #CS_ENABLE_NAME_TABLE_CC, #CS_DISABLE_NAME_TABLE_CC, - * #CS_RECOMPUTE_BASELINE_TABLE_CC, #CS_REPORT_BASELINE_TABLE_CC - */ -typedef struct -{ - CFE_MSG_CommandHeader_t CommandHeader; - CS_TableNameCmd_Payload_t Payload; -} CS_TableNameCmd_t; - -/** - * \brief Command type for commanding by app name - * - * For command details see e #CS_ENABLE_NAME_APP_CC, #CS_DISABLE_NAME_APP_CC, - * #CS_RECOMPUTE_BASELINE_APP_CC, #CS_REPORT_BASELINE_APP_CC - */ -typedef struct -{ - CFE_MSG_CommandHeader_t CommandHeader; - CS_AppNameCmd_Payload_t Payload; -} CS_AppNameCmd_t; - -/** - * \brief Command type for sending one shot calculation - * - * For command details see #CS_ONE_SHOT_CC - */ -typedef struct -{ - CFE_MSG_CommandHeader_t CommandHeader; - CS_OneShotCmd_Payload_t Payload; -} CS_OneShotCmd_t; - -/**\}*/ - -#endif diff --git a/fsw/inc/cs_perfids.h b/fsw/inc/cs_perfids.h index 6af488c..6c26f0b 100644 --- a/fsw/inc/cs_perfids.h +++ b/fsw/inc/cs_perfids.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * diff --git a/fsw/inc/cs_tbldefs.h b/fsw/inc/cs_tbldefs.h deleted file mode 100644 index 7191112..0000000 --- a/fsw/inc/cs_tbldefs.h +++ /dev/null @@ -1,143 +0,0 @@ -/************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” - * - * Copyright (c) 2021 United States Government as represented by the - * Administrator of the National Aeronautics and Space Administration. - * All Rights Reserved. - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may - * not use this file except in compliance with the License. You may obtain - * a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - ************************************************************************/ - -/** - * @file - * Specification for the CFS Checksum tables. - */ -#ifndef CS_TBLDEFS_H -#define CS_TBLDEFS_H - -/************************************************************************** - ** - ** Include section - ** - **************************************************************************/ -#include - -/************************************************************************** - ** - ** Macro definitions - ** - **************************************************************************/ - -/** - * \brief table names for definition tables - * \{ - */ -#define CS_DEF_EEPROM_TABLE_NAME "DefEepromTbl" -#define CS_DEF_MEMORY_TABLE_NAME "DefMemoryTbl" -#define CS_DEF_TABLES_TABLE_NAME "DefTablesTbl" -#define CS_DEF_APP_TABLE_NAME "DefAppTbl" -/**\}*/ - -/** - * \brief names for the results tables - * \{ - */ -#define CS_RESULTS_EEPROM_TABLE_NAME "ResEepromTbl" -#define CS_RESULTS_MEMORY_TABLE_NAME "ResMemoryTbl" -#define CS_RESULTS_TABLES_TABLE_NAME "ResTablesTbl" -#define CS_RESULTS_APP_TABLE_NAME "ResAppTbl" -/**\}*/ - -/************************************************************************** - ** - ** Type definitions - ** - **************************************************************************/ - -/** - * \brief Data structure for the EEPROM or Memory definition table - */ -typedef struct -{ - cpuaddr StartAddress; /**< \brief The Start address to Checksum */ - uint16 State; /**< \brief Uses the CS_STATE_... defines from above */ - uint16 Filler16; /** <\brief Padding */ - uint32 NumBytesToChecksum; /**< \brief The number of Bytes to Checksum */ -} CS_Def_EepromMemory_Table_Entry_t; - -/** - * \brief Data structure for the Eeporom or Memory results table - */ -typedef struct -{ - cpuaddr StartAddress; /**< \brief The Start address to Checksum */ - uint16 State; /**< \brief Uses the CS_STATE_... defines from above */ - uint16 ComputedYet; /**< \brief Have we computed an Integrity value yet */ - uint32 NumBytesToChecksum; /**< \brief The number of Bytes to Checksum */ - uint32 ComparisonValue; /**< \brief The Memory Integrity Value */ - uint32 ByteOffset; /**< \brief Where a previous unfinished calc left off */ - uint32 TempChecksumValue; /**< \brief The unfinished caluculation */ - uint32 Filler32; /**< \brief Padding */ -} CS_Res_EepromMemory_Table_Entry_t; - -/** - * \brief Data structure for the Tables definition table - */ -typedef struct -{ - uint16 State; /**< \brief Uses the CS_STATE_... defines from above */ - char Name[CFE_TBL_MAX_FULL_NAME_LEN]; /**< \brief name of the table */ -} CS_Def_Tables_Table_Entry_t; - -/** - * \brief Data structure for the App definition table - */ -typedef struct -{ - uint16 State; /**< \brief Uses the CS_STATE_... defines from above */ - char Name[OS_MAX_API_NAME]; /**< \brief name of the app */ -} CS_Def_App_Table_Entry_t; - -/** - * \brief Data structure for the Tables result table - */ -typedef struct -{ - cpuaddr StartAddress; /**< \brief The Start address to Checksum */ - uint16 State; /**< \brief Uses the CS_STATE_... defines from above */ - uint16 ComputedYet; /**< \brief Have we computed an Integrity value yet */ - uint32 NumBytesToChecksum; /**< \brief The number of Bytes to Checksum */ - uint32 ComparisonValue; /**< \brief The Memory Integrity Value */ - uint32 ByteOffset; /**< \brief Where a previous unfinished calc left off */ - uint32 TempChecksumValue; /**< \brief The unfinished caluculation */ - CFE_TBL_Handle_t TblHandle; /**< \brief handle recieved from CFE_TBL */ - bool IsCSOwner; /**< \brief Is CS the original owner of this table */ - bool Filler8; /**< \brief Padding */ - char Name[CFE_TBL_MAX_FULL_NAME_LEN]; /**< \brief name of the table */ -} CS_Res_Tables_Table_Entry_t; - -/** - * \brief Data structure for the app result table - */ -typedef struct -{ - cpuaddr StartAddress; /**< \brief The Start address to Checksum */ - uint16 State; /**< \brief Uses the CS_STATE_... defines from above */ - uint16 ComputedYet; /**< \brief Have we computed an Integrity value yet */ - uint32 NumBytesToChecksum; /**< \brief The number of Bytes to Checksum */ - uint32 ComparisonValue; /**< \brief The Memory Integrity Value */ - uint32 ByteOffset; /**< \brief Where a previous unfinished calc left off */ - uint32 TempChecksumValue; /**< \brief The unfinished caluculation */ - char Name[OS_MAX_API_NAME]; /**< \brief name of the app */ -} CS_Res_App_Table_Entry_t; - -#endif diff --git a/fsw/inc/cs_topicids.h b/fsw/inc/cs_topicids.h new file mode 100644 index 0000000..e53304f --- /dev/null +++ b/fsw/inc/cs_topicids.h @@ -0,0 +1,52 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Specification for the CFS Checksum constants for message IDs + */ +#ifndef CS_TOPICIDS_H +#define CS_TOPICIDS_H + +#include "cs_topicid_values.h" + +/** + * \defgroup cfscscmdtid CFS Checksum Command Topic IDs + * \{ + */ + +#define CFE_MISSION_CS_CMD_TOPICID CFE_MISSION_CS_TIDVAL(CMD) +#define DEFAULT_CFE_MISSION_CS_CMD_TOPICID 0x9F /**< \brief CS Command Topic ID */ +#define CFE_MISSION_CS_SEND_HK_TOPICID CFE_MISSION_CS_TIDVAL(SEND_HK) +#define DEFAULT_CFE_MISSION_CS_SEND_HK_TOPICID 0xA0 /**< \brief CS Housekeeping Request Topic ID */ +#define CFE_MISSION_CS_BACKGROUND_CYCLE_TOPICID CFE_MISSION_CS_TIDVAL(BACKGROUND_CYCLE) +#define DEFAULT_CFE_MISSION_CS_BACKGROUND_CYCLE_TOPICID 0xA1 /**< \brief CS Background Cycle Topic ID */ + +/**\}*/ + +/** + * \defgroup cfscstlmtid CFS Checksum Telemetry Topic IDs + * \{ + */ + +#define CFE_MISSION_CS_HK_TLM_TOPICID CFE_MISSION_CS_TIDVAL(HK_TLM) +#define DEFAULT_CFE_MISSION_CS_HK_TLM_TOPICID 0xA4 /**< \brief CS Housekeeping Telemetry Topic ID */ + +/**\}*/ + +#endif diff --git a/fsw/src/cs_app.c b/fsw/src/cs_app.c index 00af2a9..6cb3fed 100644 --- a/fsw/src/cs_app.c +++ b/fsw/src/cs_app.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -27,7 +26,7 @@ #include "cs_app.h" #include "cs_platform_cfg.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_utils.h" #include "cs_compute.h" #include "cs_eeprom_cmds.h" @@ -36,6 +35,7 @@ #include "cs_app_cmds.h" #include "cs_cmds.h" #include "cs_init.h" +#include "cs_dispatch.h" /************************************************************************* ** @@ -199,7 +199,7 @@ CFE_Status_t CS_AppInit(void) /* Initial settings for the CS Application */ /* the rest of the tables are initialized in CS_TableInit */ - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_ENABLED; CS_AppData.HkPacket.Payload.RecomputeInProgress = false; CS_AppData.HkPacket.Payload.OneShotInProgress = false; @@ -214,396 +214,6 @@ CFE_Status_t CS_AppInit(void) return Result; } -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -/* */ -/* CS's command pipe processing */ -/* */ -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -CFE_Status_t CS_AppPipe(const CFE_SB_Buffer_t *BufPtr) -{ - CFE_SB_MsgId_t MessageID = CFE_SB_INVALID_MSG_ID; - CFE_Status_t Result = CFE_SUCCESS; - - CFE_MSG_GetMsgId(&BufPtr->Msg, &MessageID); - - switch (CFE_SB_MsgIdToValue(MessageID)) - { - /* Housekeeping telemetry request */ - case CS_SEND_HK_MID: - CS_HousekeepingCmd((CS_NoArgsCmd_t *)BufPtr); - - /* update each table if there is no recompute happening on that table */ - Result = CS_HandleRoutineTableUpdates(); - - break; - - case CS_BACKGROUND_CYCLE_MID: - CS_BackgroundCheckCycle((CS_NoArgsCmd_t *)BufPtr); - break; - /* All CS Commands */ - case CS_CMD_MID: - CS_ProcessCmd(BufPtr); - break; - - default: - CFE_EVS_SendEvent(CS_MID_ERR_EID, CFE_EVS_EventType_ERROR, "Invalid command pipe message ID: 0x%08lX", - (unsigned long)CFE_SB_MsgIdToValue(MessageID)); - - CS_AppData.HkPacket.Payload.CmdErrCounter++; - break; - } - - return Result; -} - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -/* */ -/* CS application -- command packet processor */ -/* */ -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ - -void CS_ProcessCmd(const CFE_SB_Buffer_t *BufPtr) -{ - CFE_SB_MsgId_t MessageID = CFE_SB_INVALID_MSG_ID; - uint16 CommandCode = 0; - - CFE_MSG_GetMsgId(&BufPtr->Msg, &MessageID); - - CFE_MSG_GetFcnCode(&BufPtr->Msg, &CommandCode); - - switch (CommandCode) - { - /* All CS Commands */ - case CS_NOOP_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_NoopCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_RESET_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_ResetCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_ONE_SHOT_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_OneShotCmd_t))) - { - CS_OneShotCmd((CS_OneShotCmd_t *)BufPtr); - } - break; - - case CS_CANCEL_ONE_SHOT_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_CancelOneShotCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_ENABLE_ALL_CS_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_EnableAllCSCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_DISABLE_ALL_CS_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_DisableAllCSCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - /* cFE core Commands */ - case CS_ENABLE_CFE_CORE_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_EnableCfeCoreCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_DISABLE_CFE_CORE_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_DisableCfeCoreCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_REPORT_BASELINE_CFE_CORE_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_ReportBaselineCfeCoreCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_RECOMPUTE_BASELINE_CFE_CORE_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_RecomputeBaselineCfeCoreCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - /* OS Commands*/ - case CS_ENABLE_OS_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_EnableOSCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_DISABLE_OS_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_DisableOSCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_REPORT_BASELINE_OS_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_ReportBaselineOSCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_RECOMPUTE_BASELINE_OS_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_RecomputeBaselineOSCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - /* EEPROM Commands */ - case CS_ENABLE_EEPROM_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_EnableEepromCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_DISABLE_EEPROM_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_DisableEepromCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_REPORT_BASELINE_EEPROM_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) - { - CS_ReportBaselineEntryIDEepromCmd((CS_EntryCmd_t *)BufPtr); - } - break; - - case CS_RECOMPUTE_BASELINE_EEPROM_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) - { - CS_RecomputeBaselineEepromCmd((CS_EntryCmd_t *)BufPtr); - } - break; - - case CS_ENABLE_ENTRY_EEPROM_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) - { - CS_EnableEntryIDEepromCmd((CS_EntryCmd_t *)BufPtr); - } - break; - - case CS_DISABLE_ENTRY_EEPROM_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) - { - CS_DisableEntryIDEepromCmd((CS_EntryCmd_t *)BufPtr); - } - break; - - case CS_GET_ENTRY_ID_EEPROM_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_GetEntryIDCmd_t))) - { - CS_GetEntryIDEepromCmd((CS_GetEntryIDCmd_t *)BufPtr); - } - break; - - /* Memory Commands */ - case CS_ENABLE_MEMORY_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_EnableMemoryCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_DISABLE_MEMORY_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_DisableMemoryCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_REPORT_BASELINE_MEMORY_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) - { - CS_ReportBaselineEntryIDMemoryCmd((CS_EntryCmd_t *)BufPtr); - } - break; - - case CS_RECOMPUTE_BASELINE_MEMORY_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) - { - CS_RecomputeBaselineMemoryCmd((CS_EntryCmd_t *)BufPtr); - } - break; - - case CS_ENABLE_ENTRY_MEMORY_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) - { - CS_EnableEntryIDMemoryCmd((CS_EntryCmd_t *)BufPtr); - } - break; - - case CS_DISABLE_ENTRY_MEMORY_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EntryCmd_t))) - { - CS_DisableEntryIDMemoryCmd((CS_EntryCmd_t *)BufPtr); - } - break; - - case CS_GET_ENTRY_ID_MEMORY_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_GetEntryIDCmd_t))) - { - CS_GetEntryIDMemoryCmd((CS_GetEntryIDCmd_t *)BufPtr); - } - break; - - /* Tables Commands */ - case CS_ENABLE_TABLES_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_EnableTablesCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_DISABLE_TABLES_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_DisableTablesCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_REPORT_BASELINE_TABLE_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_TableNameCmd_t))) - { - CS_ReportBaselineTablesCmd((CS_TableNameCmd_t *)BufPtr); - } - break; - - case CS_RECOMPUTE_BASELINE_TABLE_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_TableNameCmd_t))) - { - CS_RecomputeBaselineTablesCmd((CS_TableNameCmd_t *)BufPtr); - } - break; - - case CS_ENABLE_NAME_TABLE_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_TableNameCmd_t))) - { - CS_EnableNameTablesCmd((CS_TableNameCmd_t *)BufPtr); - } - break; - - case CS_DISABLE_NAME_TABLE_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_TableNameCmd_t))) - { - CS_DisableNameTablesCmd((CS_TableNameCmd_t *)BufPtr); - } - break; - - /* App Commands */ - case CS_ENABLE_APPS_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_EnableAppCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_DISABLE_APPS_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoArgsCmd_t))) - { - CS_DisableAppCmd((CS_NoArgsCmd_t *)BufPtr); - } - break; - - case CS_REPORT_BASELINE_APP_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_AppNameCmd_t))) - { - CS_ReportBaselineAppCmd((CS_AppNameCmd_t *)BufPtr); - } - break; - - case CS_RECOMPUTE_BASELINE_APP_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_AppNameCmd_t))) - { - CS_RecomputeBaselineAppCmd((CS_AppNameCmd_t *)BufPtr); - } - break; - - case CS_ENABLE_NAME_APP_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_AppNameCmd_t))) - { - CS_EnableNameAppCmd((CS_AppNameCmd_t *)BufPtr); - } - break; - - case CS_DISABLE_NAME_APP_CC: - if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_AppNameCmd_t))) - { - CS_DisableNameAppCmd((CS_AppNameCmd_t *)BufPtr); - } - break; - - default: - CFE_EVS_SendEvent(CS_CC_ERR_EID, CFE_EVS_EventType_ERROR, - "Invalid ground command code: ID = 0x%08lX, CC = %d", - (unsigned long)CFE_SB_MsgIdToValue(MessageID), CommandCode); - - CS_AppData.HkPacket.Payload.CmdErrCounter++; - break; - } /* end switch */ -} - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -/* */ -/* CS Housekeeping command */ -/* */ -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_HousekeepingCmd(const CS_NoArgsCmd_t *CmdPtr) -{ - /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - CFE_SB_MsgId_t MessageID = CFE_SB_INVALID_MSG_ID; - CFE_MSG_FcnCode_t CommandCode = 0; - size_t ActualLength = 0; - - CFE_MSG_GetSize(CFE_MSG_PTR(CmdPtr->CommandHeader), &ActualLength); - - /* Verify the command packet length */ - if (ExpectedLength != ActualLength) - { - CFE_MSG_GetMsgId(CFE_MSG_PTR(CmdPtr->CommandHeader), &MessageID); - CFE_MSG_GetFcnCode(CFE_MSG_PTR(CmdPtr->CommandHeader), &CommandCode); - - CFE_EVS_SendEvent(CS_CMD_LEN_ERR_EID, CFE_EVS_EventType_ERROR, - "Invalid msg length: ID = 0x%08lX, CC = %d, Len = %lu, Expected = %lu", - (unsigned long)CFE_SB_MsgIdToValue(MessageID), CommandCode, (unsigned long)ActualLength, - (unsigned long)ExpectedLength); - } - else - { - /* Send housekeeping telemetry packet */ - CFE_SB_TimeStampMsg(CFE_MSG_PTR(CS_AppData.HkPacket.TelemetryHeader)); - CFE_SB_TransmitMsg(CFE_MSG_PTR(CS_AppData.HkPacket.TelemetryHeader), true); - } -} - #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ diff --git a/fsw/src/cs_app.h b/fsw/src/cs_app.h index fb67768..0e0e1b5 100644 --- a/fsw/src/cs_app.h +++ b/fsw/src/cs_app.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -32,9 +31,8 @@ **************************************************************************/ #include "cfe.h" -#include "cs_tbldefs.h" +#include "cs_tbl.h" #include "cs_msg.h" -#include "cs_msgdefs.h" #include "cs_platform_cfg.h" #include "cs_mission_cfg.h" #include "cs_msgids.h" @@ -62,8 +60,7 @@ * \name CS Command Pipe Parameters * \{ */ -#define CS_CMD_PIPE_NAME "CS_CMD_PIPE" -#define CS_CMD_PIPE_NAME_LEN 16 +#define CS_CMD_PIPE_NAME "CS_CMD_PIPE" /**\}*/ /** @@ -101,14 +98,11 @@ typedef struct { CS_HkPacket_t HkPacket; /**< \brief Housekeeping telemetry packet */ - char PipeName[CS_CMD_PIPE_NAME_LEN]; /**< \brief Command pipe name */ - uint16 PipeDepth; /**< \brief Command pipe depth */ + CS_ChecksumType_Enum_t ChildTaskTable; /**< \brief Table for the child task to process */ + uint16 ChildTaskEntryID; /**< \brief Entry in table for child task to process */ + CFE_ES_TaskId_t ChildTaskID; /**< \brief Task ID for the child task */ - uint16 ChildTaskTable; /**< \brief Table for the child task to process */ - uint16 ChildTaskEntryID; /**< \brief Entry in table for child task to process */ - CFE_ES_TaskId_t ChildTaskID; /**< \brief Task ID for the child task */ - - uint32 MaxBytesPerCycle; /**< \brief Max number of bytes to process in a cycle */ + size_t MaxBytesPerCycle; /**< \brief Max number of bytes to process in a cycle */ uint32 RunStatus; /**< \brief Application run status */ @@ -122,29 +116,7 @@ typedef struct CFE_SB_PipeId_t CmdPipe; /**< \brief Command pipe ID */ - CFE_TBL_Handle_t DefEepromTableHandle; /**< \brief Handle to the EEPROM definition table */ - CFE_TBL_Handle_t ResEepromTableHandle; /**< \brief Handle to the EEPROM results table */ - - CFE_TBL_Handle_t DefMemoryTableHandle; /**< \brief Handle to the Memory definition table */ - CFE_TBL_Handle_t ResMemoryTableHandle; /**< \brief Handle to the Memory results table */ - - CFE_TBL_Handle_t DefTablesTableHandle; /**< \brief Handle to the Tables definition table */ - CFE_TBL_Handle_t ResTablesTableHandle; /**< \brief Handle to the Tables results table */ - - CFE_TBL_Handle_t DefAppTableHandle; /**< \brief Handle to the Apps definition table */ - CFE_TBL_Handle_t ResAppTableHandle; /**< \brief Hanlde to the Apps results table */ - - CS_Def_EepromMemory_Table_Entry_t *DefEepromTblPtr; /**< \brief Pointer to the EEPROM definition table */ - CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr; /**< \brief Pointer to the EEPROM results table */ - - CS_Def_EepromMemory_Table_Entry_t *DefMemoryTblPtr; /**< \brief Pointer to the Memory definition table */ - CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr; /**< \brief Pointer to the Memory results table */ - - CS_Def_Tables_Table_Entry_t *DefTablesTblPtr; /**< \brief Pointer to the Tables definition table */ - CS_Res_Tables_Table_Entry_t *ResTablesTblPtr; /**< \brief Pointer to the Tables results table */ - - CS_Def_App_Table_Entry_t *DefAppTblPtr; /**< \brief Pointer to the Apps definition table */ - CS_Res_App_Table_Entry_t *ResAppTblPtr; /**< \brief Pointer to the Apps results table */ + CS_TableWrapper_t Tbl[CS_NUM_TABLES]; CS_Res_EepromMemory_Table_Entry_t OSCodeSeg; /**< \brief OS code segment 'table' */ CS_Res_EepromMemory_Table_Entry_t CfeCoreCodeSeg; /**< \brief cFE core code segment 'table' */ @@ -161,11 +133,6 @@ typedef struct /* The following pointers locate the results for CS tables that get checksummed because they are listed in the CS * Tables table */ - CS_Res_Tables_Table_Entry_t *EepResTablesTblPtr; /**< \brief CS results entry for the CS eeprom */ - CS_Res_Tables_Table_Entry_t *MemResTablesTblPtr; /**< \brief CS results entry for the CS memory */ - CS_Res_Tables_Table_Entry_t *AppResTablesTblPtr; /**< \brief CS results entry for the CS apps */ - CS_Res_Tables_Table_Entry_t *TblResTablesTblPtr; /**< \brief CS results table entry for the CS tables */ - #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) CFE_ES_CDSHandle_t DataStoreHandle; /**< \brief Handle to critical data store created by CS */ #endif @@ -188,6 +155,192 @@ extern CS_AppData_t CS_AppData; ** **************************************************************************/ +/** + * \brief Method to get the table ID from the wrapper pointer + * + * \returns ID of table + */ +static inline CS_ChecksumType_Enum_t CS_GetTableId(const CS_TableWrapper_t *tw) +{ + return (tw - CS_AppData.Tbl); +} + +/** + * \brief Checks if the table wrapper refers to the given table ID + * \param tw Pointer to table wrapper struct + * \param TableId Identifier of table to check if match to + * \retval true if match + * \retval false if not a match + */ +static inline bool CS_CheckTableId(const CS_TableWrapper_t *tw, CS_ChecksumType_Enum_t TableId) +{ + return (tw == &CS_AppData.Tbl[TableId]); +} + +/** + * \brief Gets the definition table handle for the given table ID + * \param TableId Identifier of table + * \returns Definition table handle + */ +static inline CFE_TBL_Handle_t CS_GetDefHandle(CS_ChecksumType_Enum_t TableId) +{ + return CS_AppData.Tbl[TableId].DefHandle; +} + +/** + * \brief Gets the result table handle for the given table ID + * \param TableId Identifier of table + * \returns Result table handle + */ +static inline CFE_TBL_Handle_t CS_GetResHandle(CS_ChecksumType_Enum_t TableId) +{ + return CS_AppData.Tbl[TableId].ResHandle; +} + +/** + * \brief Gets the definition table name handle for the given table ID + * \param TableId Identifier of table + * \returns Pointer to definition table name + * \retval NULL if no name defined + */ +static inline const char *CS_GetDefName(CS_ChecksumType_Enum_t TableId) +{ + return CS_AppData.Tbl[TableId].DefTableName; +} + +/** + * \brief Gets the result table name handle for the given table ID + * \param TableId Identifier of table + * \returns Pointer to result table name + * \retval NULL if no name defined + */ +static inline const char *CS_GetResName(CS_ChecksumType_Enum_t TableId) +{ + return CS_AppData.Tbl[TableId].ResTableName; +} + +/** + * \brief Gets the definition table pointer for the given table ID + * \param TableId Identifier of table + * \returns Pointer to definition data + * \retval NULL if no definition table registered or loaded + */ +static inline const void *CS_GetDefAddr(CS_ChecksumType_Enum_t TableId) +{ + return CS_AppData.Tbl[TableId].DefAddr; +} + +/** + * \brief Gets the result table pointer for the given table ID + * \param TableId Identifier of table + * \returns Pointer to result data + * \retval NULL if no result table registered + */ +static inline void *CS_GetResAddr(CS_ChecksumType_Enum_t TableId) +{ + return CS_AppData.Tbl[TableId].ResAddr; +} + +/** + * \brief Gets the result table pointer for OSAL code segment + * \returns Pointer to OSAL segment result data + * \retval NULL if no OSAL segment result registered + */ +static inline CS_Res_EepromMemory_Table_Entry_t *CS_GetOSCodeSegResTable(void) +{ + return (CS_Res_EepromMemory_Table_Entry_t *)CS_GetResAddr(CS_ChecksumType_OSCORE); +} + +/** + * \brief Gets the result table pointer for CFE core code segment + * \returns Pointer to CFE core segment result data + * \retval NULL if no CFE core segment result registered + */ +static inline CS_Res_EepromMemory_Table_Entry_t *CS_GetCfeCoreCodeSegResTable(void) +{ + return (CS_Res_EepromMemory_Table_Entry_t *)CS_GetResAddr(CS_ChecksumType_CFECORE); +} + +/** + * \brief Gets the definition table pointer for EEPROM checksums + * \returns Pointer to EEPROM checksum definition data + * \retval NULL if no EEPROM checksum definition registered + */ +static inline CS_Def_EepromMemory_Table_Entry_t *CS_GetEepromDefTable(void) +{ + return (CS_Def_EepromMemory_Table_Entry_t *)CS_GetDefAddr(CS_ChecksumType_EEPROM_TABLE); +} + +/** + * \brief Gets the result table pointer for EEPROM checksums + * \returns Pointer to EEPROM checksum result data + * \retval NULL if no EEPROM checksum result registered + */ +static inline CS_Res_EepromMemory_Table_Entry_t *CS_GetEepromResTable(void) +{ + return (CS_Res_EepromMemory_Table_Entry_t *)CS_GetResAddr(CS_ChecksumType_EEPROM_TABLE); +} + +/** + * \brief Gets the definition table pointer for Memory checksums + * \returns Pointer to Memory checksum definition data + * \retval NULL if no Memory checksum definition registered + */ +static inline CS_Def_EepromMemory_Table_Entry_t *CS_GetMemoryDefTable(void) +{ + return (CS_Def_EepromMemory_Table_Entry_t *)CS_GetDefAddr(CS_ChecksumType_MEMORY_TABLE); +} + +/** + * \brief Gets the result table pointer for Memory checksums + * \returns Pointer to Memory checksum result data + * \retval NULL if no Memory checksum result registered + */ +static inline CS_Res_EepromMemory_Table_Entry_t *CS_GetMemoryResTable(void) +{ + return (CS_Res_EepromMemory_Table_Entry_t *)CS_GetResAddr(CS_ChecksumType_MEMORY_TABLE); +} + +/** + * \brief Gets the definition table pointer for Table checksums + * \returns Pointer to Table checksum definition data + * \retval NULL if no Table checksum definition registered + */ +static inline CS_Def_Tables_Table_Entry_t *CS_GetTablesDefTable(void) +{ + return (CS_Def_Tables_Table_Entry_t *)CS_GetDefAddr(CS_ChecksumType_TABLES_TABLE); +} + +/** + * \brief Gets the result table pointer for Table checksums + * \returns Pointer to Table checksum result data + * \retval NULL if no Table checksum result registered + */ +static inline CS_Res_Tables_Table_Entry_t *CS_GetTablesResTable(void) +{ + return (CS_Res_Tables_Table_Entry_t *)CS_GetResAddr(CS_ChecksumType_TABLES_TABLE); +} + +/** + * \brief Gets the definition table pointer for App checksums + * \returns Pointer to App checksum definition data + * \retval NULL if no App checksum definition registered + */ +static inline CS_Def_App_Table_Entry_t *CS_GetAppDefTable(void) +{ + return (CS_Def_App_Table_Entry_t *)CS_GetDefAddr(CS_ChecksumType_APP_TABLE); +} + +/** + * \brief Gets the result table pointer for App checksums + * \returns Pointer to App checksum result data + * \retval NULL if no App checksum result registered + */ +static inline CS_Res_App_Table_Entry_t *CS_GetAppResTable(void) +{ + return (CS_Res_App_Table_Entry_t *)CS_GetResAddr(CS_ChecksumType_APP_TABLE); +} + /** * \brief CFS Checksum (CS) application entry point * @@ -228,52 +381,6 @@ void CS_UpdateCDS(void); */ CFE_Status_t CS_AppInit(void); -/** - * \brief Process a command pipe message - * - * \par Description - * Processes a single software bus command pipe message. Checks - * the message and command IDs and calls the appropriate routine - * to handle the command. - * - * \par Assumptions, External Events, and Notes: - * None - * - * \param [in] BufPtr A #CFE_SB_Buffer_t* pointer that - * references the software bus message. The - * calling function verifies that BufPtr is - * non-null. - * - * \return Execution status, see \ref CFEReturnCodes - * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS - */ -CFE_Status_t CS_AppPipe(const CFE_SB_Buffer_t *BufPtr); - -/** - * \brief Process housekeeping request - * - * \par Description - * Processes an on-board housekeeping request message. - * - * \par Assumptions, External Events, and Notes: - * This command does not affect the command execution counter - * - * \param[in] CmdPtr Command pointer, verified non-null in CS_AppMain - */ -void CS_HousekeepingCmd(const CS_NoArgsCmd_t *CmdPtr); - -/** - * \brief Command packet processor - * - * \par Description - * Processes all CS commands - * - * \param [in] BufPtr A CFE_SB_Buffer_t* pointer that - * references the software bus pointer. The - * BufPtr is verified non-null in CS_AppMain. - */ -void CS_ProcessCmd(const CFE_SB_Buffer_t *BufPtr); - /** * \brief Restore tables states from CDS if enabled * diff --git a/fsw/src/cs_app_cmds.c b/fsw/src/cs_app_cmds.c index 8854dd5..ec1188a 100644 --- a/fsw/src/cs_app_cmds.c +++ b/fsw/src/cs_app_cmds.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -29,7 +28,7 @@ **************************************************************************/ #include "cfe.h" #include "cs_app.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_utils.h" #include "cs_compute.h" #include "cs_app_cmds.h" @@ -44,20 +43,22 @@ /* CS Disable background checking of App command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_DisableAppCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableAppsCmd(const CS_DisableAppsCmd_t *CmdPtr) { - if (CS_CheckRecomputeOneshot() == false) - { - CS_AppData.HkPacket.Payload.AppCSState = CS_STATE_DISABLED; - CS_ZeroAppTempValues(); + if (CS_CheckRecomputeOneshot() == false) + { + CS_AppData.HkPacket.Payload.AppCSState = CS_ChecksumState_DISABLED; + CS_ZeroAppTempValues(); #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) - CS_UpdateCDS(); + CS_UpdateCDS(); #endif - CFE_EVS_SendEvent(CS_DISABLE_APP_INF_EID, CFE_EVS_EventType_INFORMATION, "Checksumming of App is Disabled"); - CS_AppData.HkPacket.Payload.CmdCounter++; - } + CFE_EVS_SendEvent(CS_DISABLE_APP_INF_EID, CFE_EVS_EventType_INFORMATION, "Checksumming of App is Disabled"); + CS_AppData.HkPacket.Payload.CmdCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -65,19 +66,21 @@ void CS_DisableAppCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Enable background checking of App command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_EnableAppCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableAppsCmd(const CS_EnableAppsCmd_t *CmdPtr) { - if (CS_CheckRecomputeOneshot() == false) - { - CS_AppData.HkPacket.Payload.AppCSState = CS_STATE_ENABLED; + if (CS_CheckRecomputeOneshot() == false) + { + CS_AppData.HkPacket.Payload.AppCSState = CS_ChecksumState_ENABLED; #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) - CS_UpdateCDS(); + CS_UpdateCDS(); #endif - CFE_EVS_SendEvent(CS_ENABLE_APP_INF_EID, CFE_EVS_EventType_INFORMATION, "Checksumming of App is Enabled"); - CS_AppData.HkPacket.Payload.CmdCounter++; - } + CFE_EVS_SendEvent(CS_ENABLE_APP_INF_EID, CFE_EVS_EventType_INFORMATION, "Checksumming of App is Enabled"); + CS_AppData.HkPacket.Payload.CmdCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -85,37 +88,39 @@ void CS_EnableAppCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Report the baseline checksum of an entry in the App table */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_ReportBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) +CFE_Status_t CS_ReportBaselineAppCmd(const CS_ReportBaselineAppCmd_t *CmdPtr) { /* command verification variables */ CS_Res_App_Table_Entry_t *ResultsEntry; uint32 Baseline; char Name[OS_MAX_API_NAME]; - strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); - Name[sizeof(Name) - 1] = '\0'; + strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); + Name[sizeof(Name) - 1] = '\0'; - if (CS_GetAppResTblEntryByName(&ResultsEntry, Name)) + if (CS_GetAppResTblEntryByName(&ResultsEntry, Name)) + { + if (ResultsEntry->ComputedYet == true) { - if (ResultsEntry->ComputedYet == true) - { - Baseline = ResultsEntry->ComparisonValue; - CFE_EVS_SendEvent(CS_BASELINE_APP_INF_EID, CFE_EVS_EventType_INFORMATION, - "Report baseline of app %s is 0x%08X", Name, (unsigned int)Baseline); - } - else - { - CFE_EVS_SendEvent(CS_NO_BASELINE_APP_INF_EID, CFE_EVS_EventType_INFORMATION, - "Report baseline of app %s has not been computed yet", Name); - } - CS_AppData.HkPacket.Payload.CmdCounter++; + Baseline = ResultsEntry->ComparisonValue; + CFE_EVS_SendEvent(CS_BASELINE_APP_INF_EID, CFE_EVS_EventType_INFORMATION, + "Report baseline of app %s is 0x%08X", Name, (unsigned int)Baseline); } else { - CFE_EVS_SendEvent(CS_BASELINE_INVALID_NAME_APP_ERR_EID, CFE_EVS_EventType_ERROR, - "App report baseline failed, app %s not found", Name); - CS_AppData.HkPacket.Payload.CmdErrCounter++; + CFE_EVS_SendEvent(CS_NO_BASELINE_APP_INF_EID, CFE_EVS_EventType_INFORMATION, + "Report baseline of app %s has not been computed yet", Name); } + CS_AppData.HkPacket.Payload.CmdCounter++; + } + else + { + CFE_EVS_SendEvent(CS_BASELINE_INVALID_NAME_APP_ERR_EID, CFE_EVS_EventType_ERROR, + "App report baseline failed, app %s not found", Name); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -123,7 +128,7 @@ void CS_ReportBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) /* CS Recompute the baseline of an entry in the App table cmd */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_RecomputeBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) +CFE_Status_t CS_RecomputeBaselineAppCmd(const CS_RecomputeBaselineAppCmd_t *CmdPtr) { /* command verification variables */ CFE_ES_TaskId_t ChildTaskID; @@ -131,53 +136,56 @@ void CS_RecomputeBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) CS_Res_App_Table_Entry_t *ResultsEntry; char Name[OS_MAX_API_NAME]; - if (CS_AppData.HkPacket.Payload.RecomputeInProgress == false && CS_AppData.HkPacket.Payload.OneShotInProgress == false) + if (CS_AppData.HkPacket.Payload.RecomputeInProgress == false && + CS_AppData.HkPacket.Payload.OneShotInProgress == false) + { + strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); + Name[sizeof(Name) - 1] = '\0'; + + /* make sure the entry is a valid number and is defined in the table */ + if (CS_GetAppResTblEntryByName(&ResultsEntry, Name)) { - strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); - Name[sizeof(Name) - 1] = '\0'; + /* There is no child task running right now, we can use it*/ + CS_AppData.HkPacket.Payload.RecomputeInProgress = true; + + /* fill in child task variables */ + CS_AppData.ChildTaskTable = CS_ChecksumType_APP_TABLE; - /* make sure the entry is a valid number and is defined in the table */ - if (CS_GetAppResTblEntryByName(&ResultsEntry, Name)) + CS_AppData.RecomputeAppEntryPtr = ResultsEntry; + + Status = CFE_ES_CreateChildTask(&ChildTaskID, CS_RECOMP_APP_TASK_NAME, CS_RecomputeAppChildTask, NULL, + CFE_PLATFORM_ES_DEFAULT_STACK_SIZE, CS_CHILD_TASK_PRIORITY, 0); + if (Status == CFE_SUCCESS) { - /* There is no child task running right now, we can use it*/ - CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - - /* fill in child task variables */ - CS_AppData.ChildTaskTable = CS_APP_TABLE; - - CS_AppData.RecomputeAppEntryPtr = ResultsEntry; - - Status = CFE_ES_CreateChildTask(&ChildTaskID, CS_RECOMP_APP_TASK_NAME, CS_RecomputeAppChildTask, NULL, - CFE_PLATFORM_ES_DEFAULT_STACK_SIZE, CS_CHILD_TASK_PRIORITY, 0); - if (Status == CFE_SUCCESS) - { - CFE_EVS_SendEvent(CS_RECOMPUTE_APP_STARTED_DBG_EID, CFE_EVS_EventType_DEBUG, - "Recompute baseline of app %s started", Name); - CS_AppData.HkPacket.Payload.CmdCounter++; - } - else /* child task creation failed */ - { - CFE_EVS_SendEvent(CS_RECOMPUTE_APP_CREATE_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, - "Recompute baseline of app %s failed, CFE_ES_CreateChildTask returned: 0x%08X", - Name, (unsigned int)Status); - CS_AppData.HkPacket.Payload.CmdErrCounter++; - CS_AppData.HkPacket.Payload.RecomputeInProgress = false; - } + CFE_EVS_SendEvent(CS_RECOMPUTE_APP_STARTED_DBG_EID, CFE_EVS_EventType_DEBUG, + "Recompute baseline of app %s started", Name); + CS_AppData.HkPacket.Payload.CmdCounter++; } - else + else /* child task creation failed */ { - CFE_EVS_SendEvent(CS_RECOMPUTE_UNKNOWN_NAME_APP_ERR_EID, CFE_EVS_EventType_ERROR, - "App recompute baseline failed, app %s not found", Name); + CFE_EVS_SendEvent(CS_RECOMPUTE_APP_CREATE_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, + "Recompute baseline of app %s failed, CFE_ES_CreateChildTask returned: 0x%08X", Name, + (unsigned int)Status); CS_AppData.HkPacket.Payload.CmdErrCounter++; + CS_AppData.HkPacket.Payload.RecomputeInProgress = false; } } else { - /*send event that we can't start another task right now */ - CFE_EVS_SendEvent(CS_RECOMPUTE_APP_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, - "App recompute baseline for app %s failed: child task in use", Name); + CFE_EVS_SendEvent(CS_RECOMPUTE_UNKNOWN_NAME_APP_ERR_EID, CFE_EVS_EventType_ERROR, + "App recompute baseline failed, app %s not found", Name); CS_AppData.HkPacket.Payload.CmdErrCounter++; } + } + else + { + /*send event that we can't start another task right now */ + CFE_EVS_SendEvent(CS_RECOMPUTE_APP_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, + "App recompute baseline for app %s failed: child task in use", Name); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -185,49 +193,50 @@ void CS_RecomputeBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) /* CS Disable a specific entry in the App table command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_DisableNameAppCmd(const CS_AppNameCmd_t *CmdPtr) +CFE_Status_t CS_DisableNameAppCmd(const CS_DisableNameAppCmd_t *CmdPtr) { /* command verification variables */ CS_Res_App_Table_Entry_t *ResultsEntry; CS_Def_App_Table_Entry_t *DefinitionEntry; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_APP_TABLE]; char Name[OS_MAX_API_NAME]; - if (CS_CheckRecomputeOneshot() == false) + if (CS_CheckRecomputeOneshot() == false) + { + strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); + Name[sizeof(Name) - 1] = '\0'; + + if (CS_GetAppResTblEntryByName(&ResultsEntry, Name)) { - strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); - Name[sizeof(Name) - 1] = '\0'; + ResultsEntry->State = CS_ChecksumState_DISABLED; + ResultsEntry->TempChecksumValue = 0; + ResultsEntry->ByteOffset = 0; - if (CS_GetAppResTblEntryByName(&ResultsEntry, Name)) - { - ResultsEntry->State = CS_STATE_DISABLED; - ResultsEntry->TempChecksumValue = 0; - ResultsEntry->ByteOffset = 0; - - CFE_EVS_SendEvent(CS_DISABLE_APP_NAME_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of app %s is Disabled", Name); - - if (CS_GetAppDefTblEntryByName(&DefinitionEntry, Name)) - { - DefinitionEntry->State = CS_STATE_DISABLED; - CS_ResetTablesTblResultEntry(CS_AppData.AppResTablesTblPtr); - CFE_TBL_Modified(CS_AppData.DefAppTableHandle); - } - else - { - CFE_EVS_SendEvent(CS_DISABLE_APP_DEF_NOT_FOUND_DBG_EID, CFE_EVS_EventType_DEBUG, - "CS unable to update apps definition table for entry %s", Name); - } + CFE_EVS_SendEvent(CS_DISABLE_APP_NAME_INF_EID, CFE_EVS_EventType_INFORMATION, + "Checksumming of app %s is Disabled", Name); - CS_AppData.HkPacket.Payload.CmdCounter++; + if (CS_GetAppDefTblEntryByName(&DefinitionEntry, Name)) + { + CS_SetDefEntryState(tw, DefinitionEntry, CS_ChecksumState_DISABLED); } - else { - CFE_EVS_SendEvent(CS_DISABLE_APP_UNKNOWN_NAME_ERR_EID, CFE_EVS_EventType_ERROR, - "App disable app command failed, app %s not found", Name); - CS_AppData.HkPacket.Payload.CmdErrCounter++; + CFE_EVS_SendEvent(CS_DISABLE_APP_DEF_NOT_FOUND_DBG_EID, CFE_EVS_EventType_DEBUG, + "CS unable to update apps definition table for entry %s", Name); } - } /* end InProgress if */ + + CS_AppData.HkPacket.Payload.CmdCounter++; + } + + else + { + CFE_EVS_SendEvent(CS_DISABLE_APP_UNKNOWN_NAME_ERR_EID, CFE_EVS_EventType_ERROR, + "App disable app command failed, app %s not found", Name); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + } /* end InProgress if */ + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -235,44 +244,45 @@ void CS_DisableNameAppCmd(const CS_AppNameCmd_t *CmdPtr) /* CS Enable a specific entry in the App table command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_EnableNameAppCmd(const CS_AppNameCmd_t *CmdPtr) +CFE_Status_t CS_EnableNameAppCmd(const CS_EnableNameAppCmd_t *CmdPtr) { /* command verification variables */ CS_Res_App_Table_Entry_t *ResultsEntry; CS_Def_App_Table_Entry_t *DefinitionEntry; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_APP_TABLE]; char Name[OS_MAX_API_NAME]; - if (CS_CheckRecomputeOneshot() == false) + if (CS_CheckRecomputeOneshot() == false) + { + strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); + Name[sizeof(Name) - 1] = '\0'; + + if (CS_GetAppResTblEntryByName(&ResultsEntry, Name)) { - strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); - Name[sizeof(Name) - 1] = '\0'; + ResultsEntry->State = CS_ChecksumState_ENABLED; - if (CS_GetAppResTblEntryByName(&ResultsEntry, Name)) - { - ResultsEntry->State = CS_STATE_ENABLED; - - CFE_EVS_SendEvent(CS_ENABLE_APP_NAME_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of app %s is Enabled", Name); - - if (CS_GetAppDefTblEntryByName(&DefinitionEntry, Name)) - { - DefinitionEntry->State = CS_STATE_ENABLED; - CS_ResetTablesTblResultEntry(CS_AppData.AppResTablesTblPtr); - CFE_TBL_Modified(CS_AppData.DefAppTableHandle); - } - else - { - CFE_EVS_SendEvent(CS_ENABLE_APP_DEF_NOT_FOUND_DBG_EID, CFE_EVS_EventType_DEBUG, - "CS unable to update apps definition table for entry %s", Name); - } + CFE_EVS_SendEvent(CS_ENABLE_APP_NAME_INF_EID, CFE_EVS_EventType_INFORMATION, + "Checksumming of app %s is Enabled", Name); - CS_AppData.HkPacket.Payload.CmdCounter++; + if (CS_GetAppDefTblEntryByName(&DefinitionEntry, Name)) + { + CS_SetDefEntryState(tw, DefinitionEntry, CS_ChecksumState_ENABLED); } else { - CFE_EVS_SendEvent(CS_ENABLE_APP_UNKNOWN_NAME_ERR_EID, CFE_EVS_EventType_ERROR, - "App enable app command failed, app %s not found", Name); - CS_AppData.HkPacket.Payload.CmdErrCounter++; + CFE_EVS_SendEvent(CS_ENABLE_APP_DEF_NOT_FOUND_DBG_EID, CFE_EVS_EventType_DEBUG, + "CS unable to update apps definition table for entry %s", Name); } - } /* end InProgress if */ + + CS_AppData.HkPacket.Payload.CmdCounter++; + } + else + { + CFE_EVS_SendEvent(CS_ENABLE_APP_UNKNOWN_NAME_ERR_EID, CFE_EVS_EventType_ERROR, + "App enable app command failed, app %s not found", Name); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + } /* end InProgress if */ + + return CFE_SUCCESS; } diff --git a/fsw/src/cs_app_cmds.h b/fsw/src/cs_app_cmds.h index 9355e02..3a8b4c7 100644 --- a/fsw/src/cs_app_cmds.h +++ b/fsw/src/cs_app_cmds.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -49,7 +48,7 @@ * * \sa #CS_DISABLE_APPS_CC */ -void CS_DisableAppCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_DisableAppsCmd(const CS_DisableAppsCmd_t *CmdPtr); /** * \brief Process an enable background checking for the App @@ -68,7 +67,7 @@ void CS_DisableAppCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_ENABLE_APPS_CC */ -void CS_EnableAppCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_EnableAppsCmd(const CS_EnableAppsCmd_t *CmdPtr); /** * \brief Process a report baseline of an App command @@ -84,7 +83,7 @@ void CS_EnableAppCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_REPORT_BASELINE_APP_CC */ -void CS_ReportBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr); +CFE_Status_t CS_ReportBaselineAppCmd(const CS_ReportBaselineAppCmd_t *CmdPtr); /** * \brief Process a recopmute baseline of an app command @@ -100,7 +99,7 @@ void CS_ReportBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr); * * \sa #CS_RECOMPUTE_BASELINE_APP_CC */ -void CS_RecomputeBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr); +CFE_Status_t CS_RecomputeBaselineAppCmd(const CS_RecomputeBaselineAppCmd_t *CmdPtr); /** * \brief Process a disable background checking for an App @@ -123,7 +122,7 @@ void CS_RecomputeBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr); * * \sa #CS_DISABLE_NAME_APP_CC */ -void CS_DisableNameAppCmd(const CS_AppNameCmd_t *CmdPtr); +CFE_Status_t CS_DisableNameAppCmd(const CS_DisableNameAppCmd_t *CmdPtr); /** * \brief Process an enable background checking for an App @@ -146,6 +145,6 @@ void CS_DisableNameAppCmd(const CS_AppNameCmd_t *CmdPtr); * * \sa #CS_ENABLE_NAME_APP_CC */ -void CS_EnableNameAppCmd(const CS_AppNameCmd_t *CmdPtr); +CFE_Status_t CS_EnableNameAppCmd(const CS_EnableNameAppCmd_t *CmdPtr); #endif diff --git a/fsw/src/cs_cmds.c b/fsw/src/cs_cmds.c index 146dfae..2434b98 100644 --- a/fsw/src/cs_cmds.c +++ b/fsw/src/cs_cmds.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -30,7 +29,7 @@ **************************************************************************/ #include "cfe.h" #include "cs_app.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_cmds.h" #include "cs_utils.h" #include "cs_compute.h" @@ -41,17 +40,36 @@ ** **************************************************************************/ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +/* */ +/* CS Housekeeping command */ +/* */ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +CFE_Status_t CS_SendHkCmd(const CS_SendHkCmd_t *CmdPtr) +{ + /* Send housekeeping telemetry packet */ + CFE_SB_TimeStampMsg(CFE_MSG_PTR(CS_AppData.HkPacket.TelemetryHeader)); + CFE_SB_TransmitMsg(CFE_MSG_PTR(CS_AppData.HkPacket.TelemetryHeader), true); + + /* update each table if there is no recompute happening on that table */ + CS_HandleRoutineTableUpdates(); + + return CFE_SUCCESS; +} + /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* CS no operation command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_NoopCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_NoopCmd(const CS_NoopCmd_t *CmdPtr) { CS_AppData.HkPacket.Payload.CmdCounter++; CFE_EVS_SendEvent(CS_NOOP_INF_EID, CFE_EVS_EventType_INFORMATION, "No-op command. Version %d.%d.%d.%d", CS_MAJOR_VERSION, CS_MINOR_VERSION, CS_REVISION, CS_MISSION_REV); + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -59,7 +77,7 @@ void CS_NoopCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Reset Application counters command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_ResetCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_ResetCmd(const CS_ResetCmd_t *CmdPtr) { CS_AppData.HkPacket.Payload.CmdCounter = 0; CS_AppData.HkPacket.Payload.CmdErrCounter = 0; @@ -73,6 +91,8 @@ void CS_ResetCmd(const CS_NoArgsCmd_t *CmdPtr) CS_AppData.HkPacket.Payload.PassCounter = 0; CFE_EVS_SendEvent(CS_RESET_INF_EID, CFE_EVS_EventType_DEBUG, "Reset Counters command recieved"); + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -80,108 +100,86 @@ void CS_ResetCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS's background checksumming cycle */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_BackgroundCheckCycle(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_BackgroundCheckCycleCmd(const CS_BackgroundCheckCycleCmd_t *CmdPtr) { /* command verification variables */ - size_t ExpectedLength = sizeof(CS_NoArgsCmd_t); - bool DoneWithCycle = false; - bool EndOfList = false; - CFE_SB_MsgId_t MessageID = CFE_SB_INVALID_MSG_ID; - CFE_MSG_FcnCode_t CommandCode = 0; - size_t ActualLength = 0; - - CFE_MSG_GetSize(CFE_MSG_PTR(CmdPtr->CommandHeader), &ActualLength); + bool DoneWithCycle = false; + bool EndOfList = false; - /* Verify the command packet length */ - if (ExpectedLength != ActualLength) + if (CS_AppData.HkPacket.Payload.ChecksumState == CS_ChecksumState_ENABLED) { - CFE_MSG_GetMsgId(CFE_MSG_PTR(CmdPtr->CommandHeader), &MessageID); - CFE_MSG_GetFcnCode(CFE_MSG_PTR(CmdPtr->CommandHeader), &CommandCode); + DoneWithCycle = false; + EndOfList = false; - CFE_EVS_SendEvent(CS_CMD_LEN_ERR_EID, CFE_EVS_EventType_ERROR, - "Invalid msg length: ID = 0x%08lX, CC = %d, Len = %lu, Expected = %lu", - (unsigned long)CFE_SB_MsgIdToValue(MessageID), CommandCode, (unsigned long)ActualLength, - (unsigned long)ExpectedLength); - } - else - { - if (CS_AppData.HkPacket.Payload.ChecksumState == CS_STATE_ENABLED) + /* Skip this background cycle if there's a recompute or one shot in + * progress */ + if (CS_AppData.HkPacket.Payload.RecomputeInProgress == true || + CS_AppData.HkPacket.Payload.OneShotInProgress == true) { - DoneWithCycle = false; - EndOfList = false; + CFE_EVS_SendEvent(CS_BKGND_COMPUTE_PROG_INF_EID, CFE_EVS_EventType_INFORMATION, + "Skipping background cycle. Recompute or oneshot in progress."); + DoneWithCycle = true; + } + + /* We check for end-of-list because we don't necessarily know the + order in which the table entries are defined, and we don't + want to keep looping through the list */ - /* Skip this background cycle if there's a recompute or one shot in - * progress */ - if (CS_AppData.HkPacket.Payload.RecomputeInProgress == true || - CS_AppData.HkPacket.Payload.OneShotInProgress == true) + while ((DoneWithCycle != true) && (EndOfList != true)) + { + /* We need to check the current table value here because + it is updated (and possibly reset to zero) inside each + function called */ + if (CS_AppData.HkPacket.Payload.CurrentCSTable >= (CS_NUM_TABLES - 1)) { - CFE_EVS_SendEvent(CS_BKGND_COMPUTE_PROG_INF_EID, CFE_EVS_EventType_INFORMATION, - "Skipping background cycle. Recompute or oneshot in progress."); - DoneWithCycle = true; + EndOfList = true; } - /* We check for end-of-list because we don't necessarily know the - order in which the table entries are defined, and we don't - want to keep looping through the list */ - - while ((DoneWithCycle != true) && (EndOfList != true)) + /* Call the appropriate background function based on the current table + value. The value is updated inside each function */ + switch (CS_AppData.HkPacket.Payload.CurrentCSTable) { - /* We need to check the current table value here because - it is updated (and possibly reset to zero) inside each - function called */ - if (CS_AppData.HkPacket.Payload.CurrentCSTable >= (CS_NUM_TABLES - 1)) - { - EndOfList = true; - } - - /* Call the appropriate background function based on the current table - value. The value is updated inside each function */ - switch (CS_AppData.HkPacket.Payload.CurrentCSTable) - { - case (CS_CFECORE): - DoneWithCycle = CS_BackgroundCfeCore(); - break; - - case (CS_OSCORE): - - DoneWithCycle = CS_BackgroundOS(); - break; - - case (CS_EEPROM_TABLE): - DoneWithCycle = CS_BackgroundEeprom(); - break; - - case (CS_MEMORY_TABLE): - DoneWithCycle = CS_BackgroundMemory(); - break; - - case (CS_TABLES_TABLE): - DoneWithCycle = CS_BackgroundTables(); - break; - - case (CS_APP_TABLE): - - DoneWithCycle = CS_BackgroundApp(); - break; - - /* default case in case CS_AppData.HkPacket.Payload.CurrentCSTable is some random bad value */ - default: - - /* We are at the end of the line */ - CS_AppData.HkPacket.Payload.CurrentCSTable = 0; - CS_AppData.HkPacket.Payload.CurrentEntryInTable = 0; - CS_AppData.HkPacket.Payload.PassCounter++; - DoneWithCycle = true; - break; - - } /* end switch */ - } /* end while */ - } - else - { - /* CS is disabled, Application-wide */ - } + case (CS_ChecksumType_CFECORE): + DoneWithCycle = CS_BackgroundCfeCore(); + break; + + case (CS_ChecksumType_OSCORE): + + DoneWithCycle = CS_BackgroundOS(); + break; + + case (CS_ChecksumType_EEPROM_TABLE): + DoneWithCycle = CS_BackgroundEeprom(); + break; + + case (CS_ChecksumType_MEMORY_TABLE): + DoneWithCycle = CS_BackgroundMemory(); + break; + + case (CS_ChecksumType_TABLES_TABLE): + DoneWithCycle = CS_BackgroundTables(); + break; + + case (CS_ChecksumType_APP_TABLE): + + DoneWithCycle = CS_BackgroundApp(); + break; + + /* default case in case CS_AppData.HkPacket.Payload.CurrentCSTable is some random bad value */ + default: + + /* We are at the end of the line */ + CS_AppData.HkPacket.Payload.CurrentCSTable = 0; + CS_AppData.HkPacket.Payload.CurrentEntryInTable = 0; + CS_AppData.HkPacket.Payload.PassCounter++; + DoneWithCycle = true; + break; + + } /* end switch */ + } /* end while */ } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -189,9 +187,9 @@ void CS_BackgroundCheckCycle(const CS_NoArgsCmd_t *CmdPtr) /* CS Disable all background checksumming command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_DisableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableAllCSCmd(const CS_DisableAllCSCmd_t *CmdPtr) { - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_DISABLED; /* zero out the temp values in all the tables so that when the checksums are re-enabled, @@ -206,6 +204,8 @@ void CS_DisableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) CS_AppData.HkPacket.Payload.CmdCounter++; CFE_EVS_SendEvent(CS_DISABLE_ALL_INF_EID, CFE_EVS_EventType_INFORMATION, "Background Checksumming Disabled"); + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -213,13 +213,15 @@ void CS_DisableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Enable all background checksumming command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_EnableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableAllCSCmd(const CS_EnableAllCSCmd_t *CmdPtr) { - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_ENABLED; CS_AppData.HkPacket.Payload.CmdCounter++; CFE_EVS_SendEvent(CS_ENABLE_ALL_INF_EID, CFE_EVS_EventType_INFORMATION, "Background Checksumming Enabled"); + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -227,9 +229,9 @@ void CS_EnableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Disable background checking of the cFE core command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_DisableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableCfeCoreCmd(const CS_DisableCfeCoreCmd_t *CmdPtr) { - CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_ChecksumState_DISABLED; CS_ZeroCfeCoreTempValues(); #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) @@ -240,6 +242,8 @@ void CS_DisableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) "Checksumming of cFE Core is Disabled"); CS_AppData.HkPacket.Payload.CmdCounter++; + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -247,9 +251,9 @@ void CS_DisableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Enable background checking of the cFE core command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_EnableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableCfeCoreCmd(const CS_EnableCfeCoreCmd_t *CmdPtr) { - CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_ChecksumState_ENABLED; #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) CS_UpdateCDS(); @@ -258,6 +262,8 @@ void CS_EnableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) CFE_EVS_SendEvent(CS_ENABLE_CFECORE_INF_EID, CFE_EVS_EventType_INFORMATION, "Checksumming of cFE Core is Enabled"); CS_AppData.HkPacket.Payload.CmdCounter++; + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -265,9 +271,9 @@ void CS_EnableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Disable background checking of the OS code segment command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_DisableOSCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableOSCmd(const CS_DisableOSCmd_t *CmdPtr) { - CS_AppData.HkPacket.Payload.OSCSState = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.OSCSState = CS_ChecksumState_DISABLED; CS_ZeroOSTempValues(); #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) @@ -278,6 +284,8 @@ void CS_DisableOSCmd(const CS_NoArgsCmd_t *CmdPtr) "Checksumming of OS code segment is Disabled"); CS_AppData.HkPacket.Payload.CmdCounter++; + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -285,9 +293,9 @@ void CS_DisableOSCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Enable background checking of the OS code segment command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_EnableOSCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableOSCmd(const CS_EnableOSCmd_t *CmdPtr) { - CS_AppData.HkPacket.Payload.OSCSState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.OSCSState = CS_ChecksumState_ENABLED; #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) CS_UpdateCDS(); @@ -297,6 +305,8 @@ void CS_EnableOSCmd(const CS_NoArgsCmd_t *CmdPtr) "Checksumming of OS code segment is Enabled"); CS_AppData.HkPacket.Payload.CmdCounter++; + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -304,12 +314,14 @@ void CS_EnableOSCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Report the baseline checksum for the cFE core command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_ReportBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_ReportBaselineCfeCoreCmd(const CS_ReportBaselineCfeCoreCmd_t *CmdPtr) { - if (CS_AppData.CfeCoreCodeSeg.ComputedYet == true) + CS_Res_EepromMemory_Table_Entry_t *CfeCoreCodeSeg = CS_GetCfeCoreCodeSegResTable(); + + if (CfeCoreCodeSeg->ComputedYet == true) { CFE_EVS_SendEvent(CS_BASELINE_CFECORE_INF_EID, CFE_EVS_EventType_INFORMATION, "Baseline of cFE Core is 0x%08X", - (unsigned int)CS_AppData.CfeCoreCodeSeg.ComparisonValue); + (unsigned int)CfeCoreCodeSeg->ComparisonValue); } else { @@ -317,6 +329,8 @@ void CS_ReportBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) "Baseline of cFE Core has not been computed yet"); } CS_AppData.HkPacket.Payload.CmdCounter++; + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -324,12 +338,14 @@ void CS_ReportBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Report the baseline checksum for the OS code segment command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_ReportBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_ReportBaselineOSCmd(const CS_ReportBaselineOSCmd_t *CmdPtr) { - if (CS_AppData.OSCodeSeg.ComputedYet == true) + CS_Res_EepromMemory_Table_Entry_t *OSCodeSeg = CS_GetOSCodeSegResTable(); + + if (OSCodeSeg->ComputedYet == true) { CFE_EVS_SendEvent(CS_BASELINE_OS_INF_EID, CFE_EVS_EventType_INFORMATION, - "Baseline of OS code segment is 0x%08X", (unsigned int)CS_AppData.OSCodeSeg.ComparisonValue); + "Baseline of OS code segment is 0x%08X", (unsigned int)OSCodeSeg->ComparisonValue); } else { @@ -337,6 +353,8 @@ void CS_ReportBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) "Baseline of OS code segment has not been computed yet"); } CS_AppData.HkPacket.Payload.CmdCounter++; + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -344,7 +362,7 @@ void CS_ReportBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Recompute the baseline checksum for the cFE core command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_RecomputeBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_RecomputeBaselineCfeCoreCmd(const CS_RecomputeBaselineCfeCoreCmd_t *CmdPtr) { /* command verification variables */ CFE_ES_TaskId_t ChildTaskID; @@ -357,9 +375,9 @@ void CS_RecomputeBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) CS_AppData.HkPacket.Payload.RecomputeInProgress = true; /* fill in child task variables */ - CS_AppData.ChildTaskTable = CS_CFECORE; + CS_AppData.ChildTaskTable = CS_ChecksumType_CFECORE; CS_AppData.ChildTaskEntryID = 0; - CS_AppData.RecomputeEepromMemoryEntryPtr = &CS_AppData.CfeCoreCodeSeg; + CS_AppData.RecomputeEepromMemoryEntryPtr = CS_GetCfeCoreCodeSegResTable(); Status = CFE_ES_CreateChildTask(&ChildTaskID, CS_RECOMP_CFECORE_TASK_NAME, CS_RecomputeEepromMemoryChildTask, NULL, CFE_PLATFORM_ES_DEFAULT_STACK_SIZE, CS_CHILD_TASK_PRIORITY, 0); @@ -386,6 +404,8 @@ void CS_RecomputeBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) "Recompute cFE core failed: child task in use"); CS_AppData.HkPacket.Payload.CmdErrCounter++; } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -393,7 +413,7 @@ void CS_RecomputeBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Recompute the baseline checksum for the OS code seg command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_RecomputeBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_RecomputeBaselineOSCmd(const CS_RecomputeBaselineOSCmd_t *CmdPtr) { /* command verification variables */ CFE_ES_TaskId_t ChildTaskID; @@ -406,9 +426,9 @@ void CS_RecomputeBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) CS_AppData.HkPacket.Payload.RecomputeInProgress = true; /* fill in child task variables */ - CS_AppData.ChildTaskTable = CS_OSCORE; + CS_AppData.ChildTaskTable = CS_ChecksumType_OSCORE; CS_AppData.ChildTaskEntryID = 0; - CS_AppData.RecomputeEepromMemoryEntryPtr = &CS_AppData.OSCodeSeg; + CS_AppData.RecomputeEepromMemoryEntryPtr = CS_GetOSCodeSegResTable(); Status = CFE_ES_CreateChildTask(&ChildTaskID, CS_RECOMP_OS_TASK_NAME, CS_RecomputeEepromMemoryChildTask, NULL, CFE_PLATFORM_ES_DEFAULT_STACK_SIZE, CS_CHILD_TASK_PRIORITY, 0); @@ -434,6 +454,8 @@ void CS_RecomputeBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) "Recompute OS code segment failed: child task in use"); CS_AppData.HkPacket.Payload.CmdErrCounter++; } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -441,7 +463,7 @@ void CS_RecomputeBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Compute the OneShot checksum command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr) +CFE_Status_t CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr) { /* command verification variables */ CFE_ES_TaskId_t ChildTaskID; @@ -510,6 +532,8 @@ void CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr) CS_AppData.HkPacket.Payload.CmdErrCounter++; } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -517,7 +541,7 @@ void CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr) /* CS Cancel the OneShot checksum command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_CancelOneShotCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_CancelOneShotCmd(const CS_CancelOneShotCmd_t *CmdPtr) { /* command verification variables */ CFE_Status_t Status; @@ -551,4 +575,6 @@ void CS_CancelOneShotCmd(const CS_NoArgsCmd_t *CmdPtr) "Cancel OneShot checksum failed. No OneShot active"); CS_AppData.HkPacket.Payload.CmdErrCounter++; } + + return CFE_SUCCESS; } diff --git a/fsw/src/cs_cmds.h b/fsw/src/cs_cmds.h index 391a494..db294c2 100644 --- a/fsw/src/cs_cmds.h +++ b/fsw/src/cs_cmds.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -32,6 +31,19 @@ #include "cfe.h" #include "cs_msg.h" +/** + * \brief Process housekeeping request + * + * \par Description + * Processes an on-board housekeeping request message. + * + * \par Assumptions, External Events, and Notes: + * This command does not affect the command execution counter + * + * \param[in] CmdPtr Command pointer, verified non-null in CS_AppMain + */ +CFE_Status_t CS_SendHkCmd(const CS_SendHkCmd_t *CmdPtr); + /** * \brief Process noop command * @@ -45,7 +57,7 @@ * * \sa #CS_NOOP_CC */ -void CS_NoopCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_NoopCmd(const CS_NoopCmd_t *CmdPtr); /** * \brief Process reset counters command @@ -63,7 +75,7 @@ void CS_NoopCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_RESET_CC */ -void CS_ResetCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_ResetCmd(const CS_ResetCmd_t *CmdPtr); /** * \brief process a background checking cycle @@ -77,7 +89,7 @@ void CS_ResetCmd(const CS_NoArgsCmd_t *CmdPtr); * * \param[in] CmdPtr Command pointer, verified non-null in CS_AppMain */ -void CS_BackgroundCheckCycle(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_BackgroundCheckCycleCmd(const CS_BackgroundCheckCycleCmd_t *CmdPtr); /** * \brief Process a disable overall background checking command @@ -91,7 +103,7 @@ void CS_BackgroundCheckCycle(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_DISABLE_ALL_CS_CC */ -void CS_DisableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_DisableAllCSCmd(const CS_DisableAllCSCmd_t *CmdPtr); /** * \brief Process an enable overall background checking command @@ -106,7 +118,7 @@ void CS_DisableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_ENABLE_ALL_CS_CC */ -void CS_EnableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_EnableAllCSCmd(const CS_EnableAllCSCmd_t *CmdPtr); /** * \brief Process a disable background checking for the cFE core @@ -125,7 +137,7 @@ void CS_EnableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_DISABLE_CFE_CORE_CC */ -void CS_DisableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_DisableCfeCoreCmd(const CS_DisableCfeCoreCmd_t *CmdPtr); /** * \brief Process an enable background checking for the cFE core code @@ -144,7 +156,7 @@ void CS_DisableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_ENABLE_CFE_CORE_CC */ -void CS_EnableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_EnableCfeCoreCmd(const CS_EnableCfeCoreCmd_t *CmdPtr); /** * \brief Process a disable background checking for the OS code @@ -163,7 +175,7 @@ void CS_EnableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_DISABLE_OS_CC */ -void CS_DisableOSCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_DisableOSCmd(const CS_DisableOSCmd_t *CmdPtr); /** * \brief Process an enable background checking for the OS code @@ -182,7 +194,7 @@ void CS_DisableOSCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_ENABLE_OS_CC */ -void CS_EnableOSCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_EnableOSCmd(const CS_EnableOSCmd_t *CmdPtr); /** * \brief Process a report baseline of the cFE Core command @@ -198,7 +210,7 @@ void CS_EnableOSCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_REPORT_BASELINE_CFE_CORE_CC */ -void CS_ReportBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_ReportBaselineCfeCoreCmd(const CS_ReportBaselineCfeCoreCmd_t *CmdPtr); /** * \brief Process a report baseline of the OS command @@ -214,7 +226,7 @@ void CS_ReportBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_REPORT_BASELINE_OS_CC */ -void CS_ReportBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_ReportBaselineOSCmd(const CS_ReportBaselineOSCmd_t *CmdPtr); /** * \brief Process a recopmute baseline of the cFE core code segment command @@ -230,7 +242,7 @@ void CS_ReportBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_RECOMPUTE_BASELINE_CFE_CORE_CC */ -void CS_RecomputeBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_RecomputeBaselineCfeCoreCmd(const CS_RecomputeBaselineCfeCoreCmd_t *CmdPtr); /** * \brief Process a recopmute baseline of the OS command @@ -246,7 +258,7 @@ void CS_RecomputeBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_RECOMPUTE_BASELINE_OS_CC */ -void CS_RecomputeBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_RecomputeBaselineOSCmd(const CS_RecomputeBaselineOSCmd_t *CmdPtr); /** * \brief Process a start a one shot checksum command @@ -261,7 +273,7 @@ void CS_RecomputeBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_ONE_SHOT_CC */ -void CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr); +CFE_Status_t CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr); /** * \brief Process a cancel one shot checksum command @@ -276,6 +288,6 @@ void CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr); * * \sa #CS_CANCEL_ONE_SHOT_CC */ -void CS_CancelOneShotCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_CancelOneShotCmd(const CS_CancelOneShotCmd_t *CmdPtr); #endif diff --git a/fsw/src/cs_compute.c b/fsw/src/cs_compute.c index dd435c8..677be8c 100644 --- a/fsw/src/cs_compute.c +++ b/fsw/src/cs_compute.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -30,400 +29,480 @@ #include "cfe.h" #include "cs_app.h" #include -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_compute.h" #include "cs_utils.h" + +/* + * Local helper structure to keep state of checksum calculation + * This allows the checksum calculation to be consolidated into a + * common helper function for memory, apps, and tables. + */ +typedef struct CS_LocalChecksumState +{ + const uint8 *BufferAddr; + size_t TotalSize; + size_t CurrOffset; + uint32 ResultBuffer; +} CS_LocalChecksumState_t; + /************************************************************************** ** ** Functions ** **************************************************************************/ -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -/* */ -/* CS function that computes the checksum for EEPROM, Memory, OS */ -/* and cFE core code segments */ -/* */ -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -CFE_Status_t CS_ComputeEepromMemory(CS_Res_EepromMemory_Table_Entry_t *ResultsEntry, uint32 *ComputedCSValue, - bool *DoneWithEntry) +/*---------------------------------------------------------------- + * + * Local helper function + * + *-----------------------------------------------------------------*/ +static inline bool CS_IsChecksumComplete(const CS_LocalChecksumState_t *State) { - uint32 OffsetIntoCurrEntry = 0; - cpuaddr FirstAddrThisCycle = 0; - uint32 NumBytesThisCycle = 0; - int32 NumBytesRemainingCycles = 0; - uint32 NewChecksumValue = 0; - CFE_Status_t Status = CFE_SUCCESS; - *DoneWithEntry = false; + return (State->CurrOffset >= State->TotalSize); +} - /* By the time we get here, we know we have an enabled entry */ +/*---------------------------------------------------------------- + * + * Local helper function + * + *-----------------------------------------------------------------*/ +void CS_DoChecksumChunk(CS_LocalChecksumState_t *State) +{ + size_t NumBytesThisCycle; + uint32 NewChecksumValue; - OffsetIntoCurrEntry = ResultsEntry->ByteOffset; - FirstAddrThisCycle = ResultsEntry->StartAddress + OffsetIntoCurrEntry; - NumBytesRemainingCycles = ResultsEntry->NumBytesToChecksum - OffsetIntoCurrEntry; + if (State->CurrOffset >= State->TotalSize) + { + /* Start again at beginning */ + State->CurrOffset = 0; + State->ResultBuffer = 0; + } - NumBytesThisCycle = ((CS_AppData.MaxBytesPerCycle < NumBytesRemainingCycles) ? CS_AppData.MaxBytesPerCycle - : NumBytesRemainingCycles); + NumBytesThisCycle = State->TotalSize - State->CurrOffset; - NewChecksumValue = CFE_ES_CalculateCRC((void *)(FirstAddrThisCycle), NumBytesThisCycle, - ResultsEntry->TempChecksumValue, CS_DEFAULT_ALGORITHM); + /* Limit to the configured max */ + if (NumBytesThisCycle > CS_AppData.MaxBytesPerCycle) + { + NumBytesThisCycle = CS_AppData.MaxBytesPerCycle; + } - NumBytesRemainingCycles -= NumBytesThisCycle; + NewChecksumValue = CFE_ES_CalculateCRC(State->BufferAddr + State->CurrOffset, NumBytesThisCycle, + State->ResultBuffer, CS_DEFAULT_ALGORITHM); - if (NumBytesRemainingCycles <= 0) - { - /* We are finished CS'ing all of the parts for this Entry */ - *DoneWithEntry = true; + /* Export all data */ + State->CurrOffset = State->CurrOffset + NumBytesThisCycle; + State->ResultBuffer = NewChecksumValue; +} - if (ResultsEntry->ComputedYet == true) - { - /* This is NOT the first time through this Entry. - We have already computed a CS value for this Entry */ +/*---------------------------------------------------------------- + * + * Local helper function + * + *-----------------------------------------------------------------*/ +CFE_Status_t CS_CheckOrUpdateReference(CS_LocalChecksumState_t *State, uint16 *RefValid, uint32 *CompareBuffer) +{ + CFE_Status_t Status; + + Status = CFE_SUCCESS; - if (NewChecksumValue != ResultsEntry->ComparisonValue) + if (CS_IsChecksumComplete(State)) + { + if (*RefValid) + { + /* Comparison value was computed before, so check against it */ + if (*CompareBuffer != State->ResultBuffer) { - /* If the just-computed value differ from the saved value */ + /* Not Matching is an error */ Status = CS_ERROR; } - else - { - /* The checksum passes the test. */ - } } else { - /* This is the first time through this Entry */ - ResultsEntry->ComputedYet = true; - ResultsEntry->ComparisonValue = NewChecksumValue; + /* First time, so update the reference value for future use */ + *CompareBuffer = State->ResultBuffer; + *RefValid = true; } + } + + return Status; +} + +/*---------------------------------------------------------------- + * + * Local helper function + * + *-----------------------------------------------------------------*/ +CFE_Status_t CS_GetTableAddr(CS_LocalChecksumState_t *State, CFE_TBL_Handle_t LocalHandle) +{ + CFE_Status_t Status; + void * Addr; + + Status = CFE_TBL_GetAddress(&Addr, LocalHandle); - *ComputedCSValue = NewChecksumValue; - ResultsEntry->ByteOffset = 0; - ResultsEntry->TempChecksumValue = 0; + if (Status >= CFE_SUCCESS) + { + State->BufferAddr = Addr; } else { - /* We not finished this Entry. Will try to finish during next wakeup */ - ResultsEntry->ByteOffset += NumBytesThisCycle; - ResultsEntry->TempChecksumValue = NewChecksumValue; + State->BufferAddr = NULL; } return Status; } -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -/* */ -/* CS function that computes the checksum for Tables */ -/* */ -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -CFE_Status_t CS_ComputeTables(CS_Res_Tables_Table_Entry_t *ResultsEntry, uint32 *ComputedCSValue, bool *DoneWithEntry) +/*---------------------------------------------------------------- + * + * Local helper function + * + *-----------------------------------------------------------------*/ +void CS_ReleaseTableAddr(CFE_TBL_HandleId_t LocalId, const char *Name) { - uint32 OffsetIntoCurrEntry = 0; - cpuaddr FirstAddrThisCycle = 0; - uint32 NumBytesThisCycle = 0; - int32 NumBytesRemainingCycles = 0; - uint32 NewChecksumValue = 0; - CFE_Status_t Status = CFE_SUCCESS; - CFE_Status_t Result = CFE_SUCCESS; - CFE_Status_t ResultShare = 0; - CFE_Status_t ResultGetInfo = 0; - CFE_Status_t ResultGetAddress = 0; - - /* variables to get the table address */ - CFE_TBL_Handle_t LocalTblHandle = CFE_TBL_BAD_TABLE_HANDLE; - cpuaddr LocalAddress = 0; - CFE_TBL_Info_t TblInfo; + CFE_Status_t Result; + CFE_TBL_Handle_t LocalHandle; - /* By the time we get here, we know we have an enabled entry */ + LocalHandle = CFE_TBL_HandleFromID(LocalId); - /* set the done flag to false originally */ - *DoneWithEntry = false; + Result = CFE_TBL_ReleaseAddress(LocalHandle); + if (Result != CFE_SUCCESS) + { + CFE_EVS_SendEvent(CS_COMPUTE_TABLES_RELEASE_ERR_EID, CFE_EVS_EventType_ERROR, + "CS Tables: Could not release addresss for table %s, returned: 0x%08X", Name, + (unsigned int)Result); + } +} - /* Handshake with Table Services to get address and size of table */ +/*---------------------------------------------------------------- + * + * Local helper function + * + *-----------------------------------------------------------------*/ +CFE_Status_t CS_RefreshTableSize(CS_LocalChecksumState_t *State, const char *Name) +{ + CFE_TBL_Info_t TblInfo; + CFE_Status_t Result; - /* if we already have a table handle for this table, don't get a new one */ - if (ResultsEntry->TblHandle == CFE_TBL_BAD_TABLE_HANDLE) + /* First do GetInfo, this looks up the table by name */ + Result = CFE_TBL_GetInfo(&TblInfo, Name); + if (Result >= CFE_SUCCESS) { - ResultShare = CFE_TBL_Share(&LocalTblHandle, ResultsEntry->Name); - Result = ResultShare; - - if (Result == CFE_SUCCESS) - { - ResultsEntry->TblHandle = LocalTblHandle; - } + State->TotalSize = TblInfo.Size; + Result = CFE_SUCCESS; } else { - LocalTblHandle = ResultsEntry->TblHandle; + State->TotalSize = 0; + Result = CS_ERR_NOT_FOUND; } - if (Result == CFE_SUCCESS) - { - ResultGetInfo = CFE_TBL_GetInfo(&TblInfo, ResultsEntry->Name); + return Result; +} + +/*---------------------------------------------------------------- + * + * Local helper function + * + *-----------------------------------------------------------------*/ +CFE_Status_t CS_RefreshTableHandleAndAddress(CS_LocalChecksumState_t *State, CFE_TBL_Handle_t *LocalHandle, + const char *Name) +{ + CFE_Status_t Result; - /* We want to try to get the address even if the GetInfo fails. This - provides the CFE_TBL_UNREGISTERED if the table has gone away */ - ResultGetAddress = CFE_TBL_GetAddress((void *)&LocalAddress, LocalTblHandle); - Result = ResultGetAddress; + /* This means our local handle went stale, unregister it before getting a new one */ + if (CFE_TBL_HANDLE_IS_VALID(*LocalHandle)) + { + CFE_TBL_Unregister(*LocalHandle); } - /* if the table was never loaded, release the address to prevent the table from being - locked by CS, which would prevent the owner app from updating it*/ - if (ResultGetAddress == CFE_TBL_ERR_NEVER_LOADED) + Result = CFE_TBL_Share(LocalHandle, Name); + if (Result < CFE_SUCCESS) { - CFE_TBL_ReleaseAddress(LocalTblHandle); + *LocalHandle = CFE_TBL_BAD_TABLE_HANDLE; + } + else + { + /* Try getting an address again, we still do not have one */ + Result = CS_GetTableAddr(State, *LocalHandle); } - /* The table has dissapeared since the last time CS looked. - We are checking to see if the table came back */ - if (Result == CFE_TBL_ERR_UNREGISTERED) + if (Result >= CFE_SUCCESS) { - /* unregister the old handle */ - CFE_TBL_Unregister(LocalTblHandle); + Result = CFE_SUCCESS; + } - /* reset the stored data in the results table since the - table went away */ - ResultsEntry->TblHandle = CFE_TBL_BAD_TABLE_HANDLE; - CS_ResetTablesTblResultEntry(ResultsEntry); - ResultsEntry->ComparisonValue = 0; - ResultsEntry->StartAddress = 0; - ResultsEntry->NumBytesToChecksum = 0; + return Result; +} - /* Maybe the table came back, try and reshare it */ - Result = CS_AttemptTableReshare(ResultsEntry, &LocalTblHandle, &TblInfo, &LocalAddress, &ResultGetInfo); +/*---------------------------------------------------------------- + * + * Local helper function + * + *-----------------------------------------------------------------*/ +CFE_Status_t CS_RefreshTableData(CS_LocalChecksumState_t *State, CFE_TBL_HandleId_t *LocalId, const char *Name) +{ + CFE_Status_t Status; + CFE_TBL_Handle_t LocalHandle; + + Status = CFE_SUCCESS; + + /* Always refresh the address (we do not hold it between cycles, but we do cache it) */ + /* Notably if this returns CFE_SUCCESS then it means there are no known changes + * since the last time we checked this table. */ + if (State->TotalSize != 0) + { + LocalHandle = CFE_TBL_HandleFromID(*LocalId); + Status = CS_GetTableAddr(State, LocalHandle); + } + else + { + LocalHandle = CFE_TBL_BAD_TABLE_HANDLE; } - if (Result == CFE_SUCCESS || Result == CFE_TBL_INFO_UPDATED) + /* NOTE: This intentionally is bypassed only in plain CFE_SUCCESS, meaning that info + * codes like CFE_TBL_INFO_UPDATED will also trigger refreshing the size info + * The intent is to save the cost of refreshing the size info if the value we have + * is still valid. */ + if (Status != CFE_SUCCESS || State->TotalSize == 0) { - /* push in the get data from the table info */ - if (ResultGetInfo == CFE_SUCCESS) - { - ResultsEntry->NumBytesToChecksum = TblInfo.Size; - } - ResultsEntry->StartAddress = LocalAddress; + Status = CS_RefreshTableSize(State, Name); + } - /* if the table has been updated since the last time we - looked at it, we need to start over again. We can also - use the new value as a baseline checksum */ - if (Result == CFE_TBL_INFO_UPDATED) - { - CS_ResetTablesTblResultEntry(ResultsEntry); - } + /* Check if the table handle needs a refresh */ + if (Status == CFE_SUCCESS && State->BufferAddr == NULL) + { + Status = CS_RefreshTableHandleAndAddress(State, &LocalHandle, Name); + } - OffsetIntoCurrEntry = ResultsEntry->ByteOffset; - FirstAddrThisCycle = ResultsEntry->StartAddress + OffsetIntoCurrEntry; - NumBytesRemainingCycles = ResultsEntry->NumBytesToChecksum - OffsetIntoCurrEntry; + if (Status == CFE_SUCCESS) + { + *LocalId = CFE_TBL_HandleToID(LocalHandle); + } + else + { + *LocalId = CFE_TBL_HANDLEID_UNDEFINED; + } - NumBytesThisCycle = ((CS_AppData.MaxBytesPerCycle < NumBytesRemainingCycles) ? CS_AppData.MaxBytesPerCycle - : NumBytesRemainingCycles); + return Status; +} - NewChecksumValue = CFE_ES_CalculateCRC((void *)(FirstAddrThisCycle), NumBytesThisCycle, - ResultsEntry->TempChecksumValue, CS_DEFAULT_ALGORITHM); +/*---------------------------------------------------------------- + * + * Local helper function + * + *-----------------------------------------------------------------*/ +CFE_Status_t CS_RefreshAppSizeAndAddr(CS_LocalChecksumState_t *State, const char *AppName) +{ + CFE_ResourceId_t ResourceID; + CFE_ES_AppInfo_t AppInfo; + CFE_Status_t Result; - NumBytesRemainingCycles -= NumBytesThisCycle; + AppInfo.AddressesAreValid = false; + ResourceID = CFE_RESOURCEID_UNDEFINED; - /* Have we finished all of the parts for this Entry */ - if (NumBytesRemainingCycles <= 0) - { - /* Start over if an update occurred after we started the last part */ - CFE_TBL_ReleaseAddress(LocalTblHandle); - Result = CFE_TBL_GetAddress((void *)&LocalAddress, LocalTblHandle); - if (Result == CFE_TBL_INFO_UPDATED) - { - *ComputedCSValue = 0; - ResultsEntry->ComputedYet = false; - ResultsEntry->ComparisonValue = 0; - ResultsEntry->ByteOffset = 0; - ResultsEntry->TempChecksumValue = 0; - } - else - { - /* No last second updates, post the result for this table */ - *DoneWithEntry = true; - - if (ResultsEntry->ComputedYet == true) - { - /* This is NOT the first time through this Entry. - We have already computed a CS value for this Entry */ - if (NewChecksumValue != ResultsEntry->ComparisonValue) - { - /* If the just-computed value differ from the saved value */ - Status = CS_ERROR; - } - else - { - /* The checksum passes the test. */ - } - } - else - { - /* This is the first time through this Entry */ - ResultsEntry->ComputedYet = true; - ResultsEntry->ComparisonValue = NewChecksumValue; - } - - *ComputedCSValue = NewChecksumValue; - ResultsEntry->ByteOffset = 0; - ResultsEntry->TempChecksumValue = 0; - } - } - else - { - /* We have not finished this Entry. Will try to finish during next wakeup */ - ResultsEntry->ByteOffset += NumBytesThisCycle; - ResultsEntry->TempChecksumValue = NewChecksumValue; - *ComputedCSValue = NewChecksumValue; - } + Result = CFE_ES_GetAppIDByName((CFE_ES_AppId_t *)&ResourceID, AppName); + if (Result == CFE_ES_ERR_NAME_NOT_FOUND) + { + /* Also check for a matching library name */ + Result = CFE_ES_GetLibIDByName((CFE_ES_LibId_t *)&ResourceID, AppName); + } - /* We are done with the table for this cycle, so we need to release the address */ + if (Result == CFE_SUCCESS) + { + /* We got a valid ResourceID, so get the Resource info */ + Result = CFE_ES_GetModuleInfo(&AppInfo, ResourceID); - Result = CFE_TBL_ReleaseAddress(LocalTblHandle); - if (Result != CFE_SUCCESS) + /* We got a valid ResourceID and good App info, so check the for valid addresses */ + if (Result == CFE_SUCCESS && !AppInfo.AddressesAreValid) { - CFE_EVS_SendEvent(CS_COMPUTE_TABLES_RELEASE_ERR_EID, CFE_EVS_EventType_ERROR, - "CS Tables: Could not release addresss for table %s, returned: 0x%08X", - ResultsEntry->Name, (unsigned int)Result); + CFE_EVS_SendEvent(CS_COMPUTE_APP_PLATFORM_DBG_EID, CFE_EVS_EventType_DEBUG, + "CS cannot get a valid address for %s, due to the platform", AppName); + + Result = CS_ERROR; } + } - } /* end if tabled was success or updated */ + if (Result == CFE_SUCCESS) + { + /* Push in the data from the module info */ + State->TotalSize = CFE_ES_MEMOFFSET_TO_SIZET(AppInfo.CodeSize); + State->BufferAddr = CFE_ES_MEMADDRESS_TO_PTR(AppInfo.CodeAddress); + State->CurrOffset = 0; + } else { - CFE_EVS_SendEvent(CS_COMPUTE_TABLES_ERR_EID, CFE_EVS_EventType_ERROR, - "CS Tables: Problem Getting table %s info Share: 0x%08X, GetInfo: 0x%08X, GetAddress: 0x%08X", - ResultsEntry->Name, (unsigned int)ResultShare, (unsigned int)ResultGetInfo, - (unsigned int)ResultGetAddress); + /* Something failed -- either invalid ResourceID, bad App info, or invalid addresses, so notify ground */ + CFE_EVS_SendEvent(CS_COMPUTE_APP_ERR_EID, CFE_EVS_EventType_ERROR, + "CS Apps: Problems getting module %s info, Result: 0x%08X, AddressValid: %d", AppName, + (unsigned int)Result, (unsigned int)AppInfo.AddressesAreValid); - Status = CS_ERR_NOT_FOUND; + Result = CS_ERR_NOT_FOUND; } - return Status; + return Result; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ -/* CS function that computes the checksum for Apps */ +/* CS function that computes the checksum for EEPROM, Memory, OS */ +/* and cFE core code segments */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -CFE_Status_t CS_ComputeApp(CS_Res_App_Table_Entry_t *ResultsEntry, uint32 *ComputedCSValue, bool *DoneWithEntry) +CFE_Status_t CS_ComputeEepromMemory(CS_Res_EepromMemory_Table_Entry_t *ResultsEntry, uint32 *ComputedCSValue, + bool *DoneWithEntry) { - uint32 OffsetIntoCurrEntry = 0; - cpuaddr FirstAddrThisCycle = 0; - uint32 NumBytesThisCycle = 0; - int32 NumBytesRemainingCycles = 0; - uint32 NewChecksumValue = 0; - CFE_Status_t Status = CFE_SUCCESS; - CFE_Status_t ResultGetResourceID = CS_ERROR; - CFE_Status_t ResultGetResourceInfo = CS_ERROR; - bool ResultAddressValid = false; - - /* variables to get applications address */ - CFE_ResourceId_t ResourceID = CFE_RESOURCEID_UNDEFINED; - CFE_ES_AppInfo_t AppInfo; + CFE_Status_t Status; + CS_LocalChecksumState_t State; - /* By the time we get here, we know we have an enabled entry */ + Status = CFE_SUCCESS; + + memset(&State, 0, sizeof(State)); - /* set the done flag to false originally */ - *DoneWithEntry = false; + State.BufferAddr = CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry->StartAddress); + State.TotalSize = ResultsEntry->NumBytesToChecksum; + State.CurrOffset = ResultsEntry->ByteOffset; - ResultGetResourceID = CFE_ES_GetAppIDByName((CFE_ES_AppId_t *)&ResourceID, ResultsEntry->Name); - if (ResultGetResourceID == CFE_ES_ERR_NAME_NOT_FOUND) + if (!CS_IsChecksumComplete(&State)) { - /* Also check for a matching library name */ - ResultGetResourceID = CFE_ES_GetLibIDByName((CFE_ES_LibId_t *)&ResourceID, ResultsEntry->Name); + /* resume where left off */ + State.ResultBuffer = ResultsEntry->TempChecksumValue; } - if (ResultGetResourceID == CFE_SUCCESS) - { - /* We got a valid ResourceID, so get the Resource info */ + CS_DoChecksumChunk(&State); - ResultGetResourceInfo = CFE_ES_GetModuleInfo(&AppInfo, ResourceID); - } + /* Export all values to resume next time */ + ResultsEntry->TempChecksumValue = State.ResultBuffer; + ResultsEntry->StartAddress = (cpuaddr)State.BufferAddr; + ResultsEntry->ByteOffset = State.CurrOffset; + ResultsEntry->NumBytesToChecksum = State.TotalSize; - if (ResultGetResourceInfo == CFE_SUCCESS) + /* mirror the value to the supplied register */ + *ComputedCSValue = State.ResultBuffer; + + /* Check against the previous value, if applicable */ + Status = CS_CheckOrUpdateReference(&State, &ResultsEntry->ComputedYet, &ResultsEntry->ComparisonValue); + + *DoneWithEntry = CS_IsChecksumComplete(&State); + + return Status; +} + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +/* */ +/* CS function that computes the checksum for Tables */ +/* */ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +CFE_Status_t CS_ComputeTables(CS_Res_Tables_Table_Entry_t *ResultsEntry, uint32 *ComputedCSValue, bool *DoneWithEntry) +{ + CFE_Status_t Status; + CS_LocalChecksumState_t State; + + memset(&State, 0, sizeof(State)); + + /* For tables, This size will be nonzero if we have been here before */ + /* Note we do NOT used the cached address, only the cached size. The address + * needs to come from tbl services every cycle, since it can be updated */ + State.TotalSize = ResultsEntry->NumBytesToChecksum; + + /* By the time we get here, we know we have an enabled entry */ + Status = CS_RefreshTableData(&State, &ResultsEntry->TblHandleID, ResultsEntry->Name); + + if (Status != CFE_SUCCESS || State.BufferAddr == NULL) { - /* We got a valid ResourceID and good App info, so check the for valid addresses */ + CFE_EVS_SendEvent(CS_COMPUTE_TABLES_ERR_EID, CFE_EVS_EventType_ERROR, + "CS Tables: Problem Getting table %s: Status=0x%08X", ResultsEntry->Name, + (unsigned int)Status); - if (AppInfo.AddressesAreValid == false) - { - CFE_EVS_SendEvent(CS_COMPUTE_APP_PLATFORM_DBG_EID, CFE_EVS_EventType_DEBUG, - "CS cannot get a valid address for %s, due to the platform", ResultsEntry->Name); - ResultGetResourceInfo = CS_ERROR; - } - else + memset(&State, 0, sizeof(State)); + + /* pass generic error to the caller, since the underlying one was logged already */ + Status = CS_ERR_NOT_FOUND; + } + else + { + /* If the address and size has NOT changed since our last visit, resume checksumming */ + if (ResultsEntry->StartAddress == (cpuaddr)State.BufferAddr && + ResultsEntry->NumBytesToChecksum == State.TotalSize) { - /* Push in the data from the module info */ - ResultsEntry->NumBytesToChecksum = AppInfo.CodeSize; - ResultsEntry->StartAddress = AppInfo.CodeAddress; - ResultAddressValid = true; + State.CurrOffset = ResultsEntry->ByteOffset; + State.ResultBuffer = ResultsEntry->TempChecksumValue; } + + CS_DoChecksumChunk(&State); + + /* mirror the value to the supplied register */ + *ComputedCSValue = State.ResultBuffer; + + /* Check against the previous value, if applicable */ + Status = CS_CheckOrUpdateReference(&State, &ResultsEntry->ComputedYet, &ResultsEntry->ComparisonValue); } - if (ResultGetResourceInfo == CFE_SUCCESS) + /* If we got a table address, we need to release it (always) */ + if (State.BufferAddr != NULL) { - /* We got valid ResourceID, good info, and valid addresses, so run the checksum */ + /* We are done with the table for this cycle, so we need to release the address */ + CS_ReleaseTableAddr(ResultsEntry->TblHandleID, ResultsEntry->Name); + } - OffsetIntoCurrEntry = ResultsEntry->ByteOffset; - FirstAddrThisCycle = ResultsEntry->StartAddress + OffsetIntoCurrEntry; - NumBytesRemainingCycles = ResultsEntry->NumBytesToChecksum - OffsetIntoCurrEntry; + /* Export all values to resume next time */ + ResultsEntry->TempChecksumValue = State.ResultBuffer; + ResultsEntry->StartAddress = (cpuaddr)State.BufferAddr; + ResultsEntry->ByteOffset = State.CurrOffset; + ResultsEntry->NumBytesToChecksum = State.TotalSize; - NumBytesThisCycle = ((CS_AppData.MaxBytesPerCycle < NumBytesRemainingCycles) ? CS_AppData.MaxBytesPerCycle - : NumBytesRemainingCycles); + *DoneWithEntry = CS_IsChecksumComplete(&State); - NewChecksumValue = CFE_ES_CalculateCRC((void *)(FirstAddrThisCycle), NumBytesThisCycle, - ResultsEntry->TempChecksumValue, CS_DEFAULT_ALGORITHM); + return Status; +} - NumBytesRemainingCycles -= NumBytesThisCycle; +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +/* */ +/* CS function that computes the checksum for Apps */ +/* */ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +CFE_Status_t CS_ComputeApp(CS_Res_App_Table_Entry_t *ResultsEntry, uint32 *ComputedCSValue, bool *DoneWithEntry) +{ + CFE_Status_t Status; + CS_LocalChecksumState_t State; - if (NumBytesRemainingCycles <= 0) - { - /* We are finished CS'ing all of the parts for this Entry */ - *DoneWithEntry = true; + Status = CFE_SUCCESS; - if (ResultsEntry->ComputedYet == true) - { - /* This is NOT the first time through this Entry. - We have already computed a CS value for this Entry */ - if (NewChecksumValue != ResultsEntry->ComparisonValue) - { - /* If the just-computed value differ from the saved value */ - Status = CS_ERROR; - } - else - { - /* The checksum passes the test. */ - } - } - else - { - /* This is the first time through this Entry */ - ResultsEntry->ComputedYet = true; - ResultsEntry->ComparisonValue = NewChecksumValue; - } + memset(&State, 0, sizeof(State)); - *ComputedCSValue = NewChecksumValue; - ResultsEntry->ByteOffset = 0; - ResultsEntry->TempChecksumValue = 0; - } - else - { - /* We have not finished this Entry. Will try to finish during next wakeup */ - ResultsEntry->ByteOffset += NumBytesThisCycle; - ResultsEntry->TempChecksumValue = NewChecksumValue; - *ComputedCSValue = NewChecksumValue; - } - } /* end if got module id ok */ + State.BufferAddr = CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry->StartAddress); + State.TotalSize = ResultsEntry->NumBytesToChecksum; + State.CurrOffset = ResultsEntry->ByteOffset; + + if (State.BufferAddr == NULL || CS_IsChecksumComplete(&State)) + { + Status = CS_RefreshAppSizeAndAddr(&State, ResultsEntry->Name); + } else { - /* Something failed -- either invalid ResourceID, bad App info, or invalid addresses, so notify ground */ - CFE_EVS_SendEvent( - CS_COMPUTE_APP_ERR_EID, CFE_EVS_EventType_ERROR, - "CS Apps: Problems getting module %s info, GetResourceID: 0x%08X, GetModuleInfo: 0x%08X, AddressValid: %d", - ResultsEntry->Name, (unsigned int)ResultGetResourceID, (unsigned int)ResultGetResourceInfo, - (unsigned int)ResultAddressValid); - - Status = CS_ERR_NOT_FOUND; + /* Already got address and size, resume where left off */ + State.ResultBuffer = ResultsEntry->TempChecksumValue; + Status = CFE_SUCCESS; } + if (Status == CFE_SUCCESS) + { + CS_DoChecksumChunk(&State); + + /* Export all values to resume next time */ + ResultsEntry->TempChecksumValue = State.ResultBuffer; + ResultsEntry->StartAddress = (cpuaddr)State.BufferAddr; + ResultsEntry->ByteOffset = State.CurrOffset; + ResultsEntry->NumBytesToChecksum = State.TotalSize; + + /* mirror the value to the supplied register */ + *ComputedCSValue = State.ResultBuffer; + + /* Check against the previous value, if applicable */ + Status = CS_CheckOrUpdateReference(&State, &ResultsEntry->ComputedYet, &ResultsEntry->ComparisonValue); + } /* end if got module id ok */ + + *DoneWithEntry = CS_IsChecksumComplete(&State); + return Status; } @@ -434,28 +513,23 @@ CFE_Status_t CS_ComputeApp(CS_Res_App_Table_Entry_t *ResultsEntry, uint32 *Compu /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_RecomputeEepromMemoryChildTask(void) { - uint32 NewChecksumValue = 0; - CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; - uint16 Table = 0; - uint16 EntryID = 0; - uint16 PreviousState = CS_STATE_EMPTY; - bool DoneWithEntry = false; - uint16 PreviousDefState = CS_STATE_EMPTY; - bool DefEntryFound = false; - uint16 DefEntryID = 0; - CS_Def_EepromMemory_Table_Entry_t *DefTblPtr = NULL; - uint16 MaxDefEntries = 0; - CFE_TBL_Handle_t DefTblHandle = CFE_TBL_BAD_TABLE_HANDLE; - CS_Res_Tables_Table_Entry_t * TablesTblResultEntry = NULL; - - Table = CS_AppData.ChildTaskTable; + uint32 NewChecksumValue = 0; + CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; + uint16 EntryID = 0; + CS_ChecksumState_Enum_t PreviousState = CS_ChecksumState_EMPTY; + bool DoneWithEntry = false; + CS_ChecksumState_Enum_t PreviousDefState = CS_ChecksumState_EMPTY; + CS_Def_EepromMemory_Table_Entry_t *DefEntry = NULL; + CS_TableWrapper_t * tw; + + tw = &CS_AppData.Tbl[CS_AppData.ChildTaskTable]; EntryID = CS_AppData.ChildTaskEntryID; ResultsEntry = CS_AppData.RecomputeEepromMemoryEntryPtr; /* we want to make sure that the entry isn't being checksummed in the background at the same time we are recomputing */ PreviousState = ResultsEntry->State; - ResultsEntry->State = CS_STATE_DISABLED; + ResultsEntry->State = CS_ChecksumState_DISABLED; /* Set entry as if this is the first time we are computing the checksum, since we want the entry to take on the new value */ @@ -466,38 +540,18 @@ void CS_RecomputeEepromMemoryChildTask(void) /* Update the definition table entry as well. We need to determine which memory type is being updated as well as which entry in the table is being updated. */ - if ((Table != CS_OSCORE) && (Table != CS_CFECORE)) + if (CS_CheckTableId(tw, CS_ChecksumType_EEPROM_TABLE) || CS_CheckTableId(tw, CS_ChecksumType_MEMORY_TABLE)) { - if (Table == CS_EEPROM_TABLE) - { - DefTblPtr = CS_AppData.DefEepromTblPtr; - MaxDefEntries = CS_MAX_NUM_EEPROM_TABLE_ENTRIES; - DefTblHandle = CS_AppData.DefEepromTableHandle; - TablesTblResultEntry = CS_AppData.EepResTablesTblPtr; - } - else - { - DefTblPtr = CS_AppData.DefMemoryTblPtr; - MaxDefEntries = CS_MAX_NUM_MEMORY_TABLE_ENTRIES; - DefTblHandle = CS_AppData.DefMemoryTableHandle; - TablesTblResultEntry = CS_AppData.MemResTablesTblPtr; - } + DefEntry = CS_GetDefEntryAddr(tw, EntryID); + } - if (EntryID < MaxDefEntries) - { - /* This assumes that the definition table entries are in the same order as the - results table entries, which should be a safe assumption. */ - if ((ResultsEntry->StartAddress == DefTblPtr[EntryID].StartAddress) && - (DefTblPtr[EntryID].State != CS_STATE_EMPTY)) - { - DefEntryFound = true; - PreviousDefState = DefTblPtr[EntryID].State; - DefTblPtr[EntryID].State = CS_STATE_DISABLED; - DefEntryID = EntryID; - CS_ResetTablesTblResultEntry(TablesTblResultEntry); - CFE_TBL_Modified(DefTblHandle); - } - } + if (DefEntry != NULL && ResultsEntry->StartAddress == DefEntry->StartAddress) + { + PreviousDefState = CS_SetDefEntryState(tw, DefEntry, CS_ChecksumState_DISABLED); + } + else + { + DefEntry = NULL; } while (!DoneWithEntry) @@ -509,35 +563,24 @@ void CS_RecomputeEepromMemoryChildTask(void) /* The new checksum value is stored in the table by the above functions */ - /* reset the entry's variables for a newly computed value */ - ResultsEntry->TempChecksumValue = 0; - ResultsEntry->ByteOffset = 0; - ResultsEntry->ComputedYet = true; - /* restore the entry's previous state */ ResultsEntry->State = PreviousState; /* Restore the definition table if we found one earlier */ - if (DefEntryFound) + if (DefEntry != NULL) { - DefTblPtr[DefEntryID].State = PreviousDefState; - CS_ResetTablesTblResultEntry(TablesTblResultEntry); - CFE_TBL_Modified(DefTblHandle); + CS_SetDefEntryState(tw, DefEntry, PreviousDefState); } /* Update reported value in HK TLM, if applicable */ - if (Table == CS_CFECORE) + if (tw->BaselineValue) { - CS_AppData.HkPacket.Payload.CfeCoreBaseline = NewChecksumValue; - } - if (Table == CS_OSCORE) - { - CS_AppData.HkPacket.Payload.OSBaseline = NewChecksumValue; + *tw->BaselineValue = NewChecksumValue; } /* send event message */ CFE_EVS_SendEvent(CS_RECOMPUTE_FINISH_EEPROM_MEMORY_INF_EID, CFE_EVS_EventType_INFORMATION, - "%s entry %d recompute finished. New baseline is 0X%08X", CS_GetTableTypeAsString(Table), EntryID, + "%s entry %d recompute finished. New baseline is 0X%08X", CS_GetTableTypeAsString(tw), EntryID, (unsigned int)NewChecksumValue); CS_AppData.HkPacket.Payload.RecomputeInProgress = false; @@ -553,15 +596,13 @@ void CS_RecomputeAppChildTask(void) { uint32 NewChecksumValue = 0; CS_Res_App_Table_Entry_t *ResultsEntry = NULL; - uint16 PreviousState = CS_STATE_EMPTY; + CS_ChecksumState_Enum_t PreviousState = CS_ChecksumState_EMPTY; bool DoneWithEntry = false; CFE_Status_t Status = CS_ERROR; - uint16 PreviousDefState = CS_STATE_EMPTY; - bool DefEntryFound = false; - uint16 DefEntryID = 0; - CS_Def_App_Table_Entry_t *DefTblPtr = NULL; - uint16 MaxDefEntries = 0; - CFE_TBL_Handle_t DefTblHandle = CFE_TBL_BAD_TABLE_HANDLE; + CS_ChecksumState_Enum_t PreviousDefState = CS_ChecksumState_EMPTY; + CS_Def_App_Table_Entry_t *DefTblEntry = NULL; + + CS_TableWrapper_t *tw = &CS_AppData.Tbl[CS_ChecksumType_APP_TABLE]; /* Get the variables to use from the global data */ ResultsEntry = CS_AppData.RecomputeAppEntryPtr; @@ -570,7 +611,7 @@ void CS_RecomputeAppChildTask(void) background at the same time we are recomputing */ PreviousState = ResultsEntry->State; - ResultsEntry->State = CS_STATE_DISABLED; + ResultsEntry->State = CS_ChecksumState_DISABLED; /* Set entry as if this is the first time we are computing the checksum, since we want the entry to take on the new value */ @@ -581,27 +622,12 @@ void CS_RecomputeAppChildTask(void) /* Update the definition table entry as well. We need to determine which memory type is being updated as well as which entry in the table is being updated. */ - DefTblPtr = CS_AppData.DefAppTblPtr; - MaxDefEntries = CS_MAX_NUM_APP_TABLE_ENTRIES; - DefTblHandle = CS_AppData.DefAppTableHandle; - DefEntryID = 0; + CS_GetAppDefTblEntryByName(&DefTblEntry, ResultsEntry->Name); - while ((!DefEntryFound) && (DefEntryID < MaxDefEntries)) + if (DefTblEntry != NULL) { - if ((strncmp(ResultsEntry->Name, DefTblPtr[DefEntryID].Name, OS_MAX_API_NAME) == 0) && - (DefTblPtr[DefEntryID].State != CS_STATE_EMPTY)) - { - DefEntryFound = true; - PreviousDefState = DefTblPtr[DefEntryID].State; - DefTblPtr[DefEntryID].State = CS_STATE_DISABLED; - CS_ResetTablesTblResultEntry(CS_AppData.AppResTablesTblPtr); - CFE_TBL_Modified(DefTblHandle); - } - else - { - DefEntryID++; - } + PreviousDefState = CS_SetDefEntryState(tw, DefTblEntry, CS_ChecksumState_DISABLED); } while (!DoneWithEntry) @@ -621,11 +647,9 @@ void CS_RecomputeAppChildTask(void) ResultsEntry->State = PreviousState; /* Restore the definition table if we found one earlier */ - if (DefEntryFound) + if (DefTblEntry != NULL) { - DefTblPtr[DefEntryID].State = PreviousDefState; - CS_ResetTablesTblResultEntry(CS_AppData.AppResTablesTblPtr); - CFE_TBL_Modified(DefTblHandle); + CS_SetDefEntryState(tw, DefTblEntry, PreviousDefState); } if (Status == CS_ERR_NOT_FOUND) @@ -635,11 +659,6 @@ void CS_RecomputeAppChildTask(void) } else { - /* reset the entry's variables for a newly computed value */ - ResultsEntry->TempChecksumValue = 0; - ResultsEntry->ByteOffset = 0; - ResultsEntry->ComputedYet = true; - /* send event message */ CFE_EVS_SendEvent(CS_RECOMPUTE_FINISH_APP_INF_EID, CFE_EVS_EventType_INFORMATION, "App %s recompute finished. New baseline is 0x%08X", ResultsEntry->Name, @@ -659,15 +678,13 @@ void CS_RecomputeTablesChildTask(void) { uint32 NewChecksumValue = 0; CS_Res_Tables_Table_Entry_t *ResultsEntry = NULL; - uint16 PreviousState = CS_STATE_EMPTY; + CS_ChecksumState_Enum_t PreviousState = CS_ChecksumState_EMPTY; bool DoneWithEntry = false; CFE_Status_t Status = CS_ERROR; - uint16 PreviousDefState = CS_STATE_EMPTY; - bool DefEntryFound = false; - uint16 DefEntryID = 0; - CS_Def_Tables_Table_Entry_t *DefTblPtr = NULL; - uint16 MaxDefEntries = 0; - CFE_TBL_Handle_t DefTblHandle = CFE_TBL_BAD_TABLE_HANDLE; + CS_ChecksumState_Enum_t PreviousDefState = CS_ChecksumState_EMPTY; + CS_Def_Tables_Table_Entry_t *DefTblEntry = NULL; + + CS_TableWrapper_t *tw = &CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE]; /* Get the variables to use from the global data */ ResultsEntry = CS_AppData.RecomputeTablesEntryPtr; @@ -676,7 +693,7 @@ void CS_RecomputeTablesChildTask(void) background at the same time we are recomputing */ PreviousState = ResultsEntry->State; - ResultsEntry->State = CS_STATE_DISABLED; + ResultsEntry->State = CS_ChecksumState_DISABLED; /* Set entry as if this is the first time we are computing the checksum, since we want the entry to take on the new value */ @@ -687,27 +704,10 @@ void CS_RecomputeTablesChildTask(void) /* Update the definition table entry as well. We need to determine which memory type is being updated as well as which entry in the table is being updated. */ - DefTblPtr = CS_AppData.DefTablesTblPtr; - MaxDefEntries = CS_MAX_NUM_TABLES_TABLE_ENTRIES; - DefTblHandle = CS_AppData.DefTablesTableHandle; - - DefEntryID = 0; - - while ((!DefEntryFound) && (DefEntryID < MaxDefEntries)) + CS_GetTableDefTblEntryByName(&DefTblEntry, ResultsEntry->Name); + if (DefTblEntry != NULL) { - if ((strncmp(ResultsEntry->Name, DefTblPtr[DefEntryID].Name, CFE_TBL_MAX_FULL_NAME_LEN) == 0) && - (DefTblPtr[DefEntryID].State != CS_STATE_EMPTY)) - { - DefEntryFound = true; - PreviousDefState = DefTblPtr[DefEntryID].State; - DefTblPtr[DefEntryID].State = CS_STATE_DISABLED; - CS_ResetTablesTblResultEntry(CS_AppData.TblResTablesTblPtr); - CFE_TBL_Modified(DefTblHandle); - } - else - { - DefEntryID++; - } + PreviousDefState = CS_SetDefEntryState(tw, DefTblEntry, CS_ChecksumState_DISABLED); } while (!DoneWithEntry) @@ -730,11 +730,6 @@ void CS_RecomputeTablesChildTask(void) } else { - /* reset the entry's variables for a newly computed value */ - ResultsEntry->TempChecksumValue = 0; - ResultsEntry->ByteOffset = 0; - ResultsEntry->ComputedYet = true; - /* send event message */ CFE_EVS_SendEvent(CS_RECOMPUTE_FINISH_TABLES_INF_EID, CFE_EVS_EventType_INFORMATION, "Table %s recompute finished. New baseline is 0x%08X", ResultsEntry->Name, @@ -745,11 +740,9 @@ void CS_RecomputeTablesChildTask(void) ResultsEntry->State = PreviousState; /* Restore the definition table if we found one earlier */ - if (DefEntryFound) + if (DefTblEntry != NULL) { - DefTblPtr[DefEntryID].State = PreviousDefState; - CS_ResetTablesTblResultEntry(CS_AppData.TblResTablesTblPtr); - CFE_TBL_Modified(DefTblHandle); + CS_SetDefEntryState(tw, DefTblEntry, PreviousDefState); } CS_AppData.HkPacket.Payload.RecomputeInProgress = false; @@ -764,10 +757,10 @@ void CS_RecomputeTablesChildTask(void) void CS_OneShotChildTask(void) { uint32 NewChecksumValue = 0; - uint32 NumBytesRemainingCycles = 0; - uint32 NumBytesThisCycle = 0; + size_t NumBytesRemainingCycles = 0; + size_t NumBytesThisCycle = 0; cpuaddr FirstAddrThisCycle = 0; - uint32 MaxBytesPerCycle = 0; + size_t MaxBytesPerCycle = 0; NewChecksumValue = 0; NumBytesRemainingCycles = CS_AppData.HkPacket.Payload.LastOneShotSize; diff --git a/fsw/src/cs_compute.h b/fsw/src/cs_compute.h index 2e33273..db8ebdf 100644 --- a/fsw/src/cs_compute.h +++ b/fsw/src/cs_compute.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -30,7 +29,7 @@ ** **************************************************************************/ #include "cfe.h" -#include "cs_tbldefs.h" +#include "cs_tbl.h" /** * \brief Computes checksums on EEPROM or Memory types diff --git a/fsw/src/cs_dispatch.c b/fsw/src/cs_dispatch.c new file mode 100644 index 0000000..fc30a31 --- /dev/null +++ b/fsw/src/cs_dispatch.c @@ -0,0 +1,435 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * CFS Checksum (CS) Application provides the service of background + * checksumming user-defined objects in the CFS + */ +#include +#include "cfe.h" +#include "cs_app.h" + +#include "cs_platform_cfg.h" +#include "cs_eventids.h" +#include "cs_eeprom_cmds.h" +#include "cs_table_cmds.h" +#include "cs_memory_cmds.h" +#include "cs_app_cmds.h" +#include "cs_cmds.h" +#include "cs_dispatch.h" +#include "cs_utils.h" + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +/* */ +/* CS Verify the length of the command */ +/* */ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +bool CS_VerifyCmdLength(const CFE_MSG_Message_t *msg, size_t ExpectedLength) +{ + CFE_SB_MsgId_t MessageID = CFE_SB_INVALID_MSG_ID; + CFE_MSG_FcnCode_t CommandCode = 0; + bool Result = true; + size_t ActualLength = 0; + + CFE_MSG_GetSize(msg, &ActualLength); + + /* Verify the command packet length */ + if (ExpectedLength != ActualLength) + { + CFE_MSG_GetMsgId(msg, &MessageID); + CFE_MSG_GetFcnCode(msg, &CommandCode); + + CFE_EVS_SendEvent(CS_CMD_LEN_ERR_EID, CFE_EVS_EventType_ERROR, + "Invalid msg length: ID = 0x%08lX, CC = %d, Len = %lu, Expected = %lu", + (unsigned long)CFE_SB_MsgIdToValue(MessageID), CommandCode, (unsigned long)ActualLength, + (unsigned long)ExpectedLength); + Result = false; + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + return Result; +} + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +/* */ +/* CS's command pipe processing */ +/* */ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +CFE_Status_t CS_AppPipe(const CFE_SB_Buffer_t *BufPtr) +{ + static CFE_SB_MsgId_t CMD_MID = CFE_SB_MSGID_RESERVED; + static CFE_SB_MsgId_t BACKGROUND_CYCLE_MID = CFE_SB_MSGID_RESERVED; + static CFE_SB_MsgId_t SEND_HK_MID = CFE_SB_MSGID_RESERVED; + + CFE_SB_MsgId_t MessageID = CFE_SB_INVALID_MSG_ID; + + /* cache the local MID Values here, this avoids repeat lookups */ + if (!CFE_SB_IsValidMsgId(CMD_MID)) + { + CMD_MID = CFE_SB_ValueToMsgId(CS_CMD_MID); + SEND_HK_MID = CFE_SB_ValueToMsgId(CS_SEND_HK_MID); + BACKGROUND_CYCLE_MID = CFE_SB_ValueToMsgId(CS_BACKGROUND_CYCLE_MID); + } + + CFE_MSG_GetMsgId(&BufPtr->Msg, &MessageID); + + /* Process all SB messages */ + if (CFE_SB_MsgId_Equal(MessageID, SEND_HK_MID)) + { + /* Housekeeping telemetry request */ + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_SendHkCmd_t))) + { + CS_SendHkCmd((const CS_SendHkCmd_t *)BufPtr); + } + } + else if (CFE_SB_MsgId_Equal(MessageID, BACKGROUND_CYCLE_MID)) + { + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_BackgroundCheckCycleCmd_t))) + { + CS_BackgroundCheckCycleCmd((const CS_BackgroundCheckCycleCmd_t *)BufPtr); + } + } + else if (CFE_SB_MsgId_Equal(MessageID, CMD_MID)) + { + /* All CS Commands */ + CS_ProcessCmd(BufPtr); + } + else + { + /* Unknown command */ + CFE_EVS_SendEvent(CS_MID_ERR_EID, CFE_EVS_EventType_ERROR, "Invalid command pipe message ID: 0x%08lX", + (unsigned long)CFE_SB_MsgIdToValue(MessageID)); + + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + + return CFE_SUCCESS; +} + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +/* */ +/* CS application -- command packet processor */ +/* */ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +void CS_ProcessCmd(const CFE_SB_Buffer_t *BufPtr) +{ + CFE_SB_MsgId_t MessageID = CFE_SB_INVALID_MSG_ID; + uint16 CommandCode = 0; + + CFE_MSG_GetFcnCode(&BufPtr->Msg, &CommandCode); + + switch (CommandCode) + { + /* All CS Commands */ + case CS_NOOP_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_NoopCmd_t))) + { + CS_NoopCmd((const CS_NoopCmd_t *)BufPtr); + } + break; + + case CS_RESET_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_ResetCmd_t))) + { + CS_ResetCmd((const CS_ResetCmd_t *)BufPtr); + } + break; + + case CS_ONE_SHOT_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_OneShotCmd_t))) + { + CS_OneShotCmd((const CS_OneShotCmd_t *)BufPtr); + } + break; + + case CS_CANCEL_ONE_SHOT_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_CancelOneShotCmd_t))) + { + CS_CancelOneShotCmd((const CS_CancelOneShotCmd_t *)BufPtr); + } + break; + + case CS_ENABLE_ALL_CS_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EnableAllCSCmd_t))) + { + CS_EnableAllCSCmd((const CS_EnableAllCSCmd_t *)BufPtr); + } + break; + + case CS_DISABLE_ALL_CS_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_DisableAllCSCmd_t))) + { + CS_DisableAllCSCmd((const CS_DisableAllCSCmd_t *)BufPtr); + } + break; + + /* cFE core Commands */ + case CS_ENABLE_CFE_CORE_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EnableCfeCoreCmd_t))) + { + CS_EnableCfeCoreCmd((const CS_EnableCfeCoreCmd_t *)BufPtr); + } + break; + + case CS_DISABLE_CFE_CORE_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_DisableCfeCoreCmd_t))) + { + CS_DisableCfeCoreCmd((const CS_DisableCfeCoreCmd_t *)BufPtr); + } + break; + + case CS_REPORT_BASELINE_CFE_CORE_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_ReportBaselineCfeCoreCmd_t))) + { + CS_ReportBaselineCfeCoreCmd((const CS_ReportBaselineCfeCoreCmd_t *)BufPtr); + } + break; + + case CS_RECOMPUTE_BASELINE_CFE_CORE_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_RecomputeBaselineCfeCoreCmd_t))) + { + CS_RecomputeBaselineCfeCoreCmd((const CS_RecomputeBaselineCfeCoreCmd_t *)BufPtr); + } + break; + + /* OS Commands*/ + case CS_ENABLE_OS_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EnableOSCmd_t))) + { + CS_EnableOSCmd((const CS_EnableOSCmd_t *)BufPtr); + } + break; + + case CS_DISABLE_OS_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_DisableOSCmd_t))) + { + CS_DisableOSCmd((const CS_DisableOSCmd_t *)BufPtr); + } + break; + + case CS_REPORT_BASELINE_OS_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_ReportBaselineOSCmd_t))) + { + CS_ReportBaselineOSCmd((const CS_ReportBaselineOSCmd_t *)BufPtr); + } + break; + + case CS_RECOMPUTE_BASELINE_OS_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_RecomputeBaselineOSCmd_t))) + { + CS_RecomputeBaselineOSCmd((const CS_RecomputeBaselineOSCmd_t *)BufPtr); + } + break; + + /* EEPROM Commands */ + case CS_ENABLE_EEPROM_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EnableEepromCmd_t))) + { + CS_EnableEepromCmd((const CS_EnableEepromCmd_t *)BufPtr); + } + break; + + case CS_DISABLE_EEPROM_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_DisableEepromCmd_t))) + { + CS_DisableEepromCmd((const CS_DisableEepromCmd_t *)BufPtr); + } + break; + + case CS_REPORT_BASELINE_ENTRY_ID_EEPROM_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_ReportBaselineEntryIDEepromCmd_t))) + { + CS_ReportBaselineEntryIDEepromCmd((const CS_ReportBaselineEntryIDEepromCmd_t *)BufPtr); + } + break; + + case CS_RECOMPUTE_BASELINE_EEPROM_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_RecomputeBaselineEepromCmd_t))) + { + CS_RecomputeBaselineEepromCmd((const CS_RecomputeBaselineEepromCmd_t *)BufPtr); + } + break; + + case CS_ENABLE_ENTRY_ID_EEPROM_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EnableEntryIDEepromCmd_t))) + { + CS_EnableEntryIDEepromCmd((const CS_EnableEntryIDEepromCmd_t *)BufPtr); + } + break; + + case CS_DISABLE_ENTRY_ID_EEPROM_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_DisableEntryIDEepromCmd_t))) + { + CS_DisableEntryIDEepromCmd((const CS_DisableEntryIDEepromCmd_t *)BufPtr); + } + break; + + case CS_GET_ENTRY_ID_EEPROM_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_GetEntryIDEepromCmd_t))) + { + CS_GetEntryIDEepromCmd((const CS_GetEntryIDEepromCmd_t *)BufPtr); + } + break; + + /* Memory Commands */ + case CS_ENABLE_MEMORY_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EnableMemoryCmd_t))) + { + CS_EnableMemoryCmd((const CS_EnableMemoryCmd_t *)BufPtr); + } + break; + + case CS_DISABLE_MEMORY_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_DisableMemoryCmd_t))) + { + CS_DisableMemoryCmd((const CS_DisableMemoryCmd_t *)BufPtr); + } + break; + + case CS_REPORT_BASELINE_ENTRY_ID_MEMORY_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_ReportBaselineEntryIDMemoryCmd_t))) + { + CS_ReportBaselineEntryIDMemoryCmd((const CS_ReportBaselineEntryIDMemoryCmd_t *)BufPtr); + } + break; + + case CS_RECOMPUTE_BASELINE_MEMORY_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_RecomputeBaselineMemoryCmd_t))) + { + CS_RecomputeBaselineMemoryCmd((const CS_RecomputeBaselineMemoryCmd_t *)BufPtr); + } + break; + + case CS_ENABLE_ENTRY_ID_MEMORY_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EnableEntryIDMemoryCmd_t))) + { + CS_EnableEntryIDMemoryCmd((const CS_EnableEntryIDMemoryCmd_t *)BufPtr); + } + break; + + case CS_DISABLE_ENTRY_ID_MEMORY_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_DisableEntryIDMemoryCmd_t))) + { + CS_DisableEntryIDMemoryCmd((const CS_DisableEntryIDMemoryCmd_t *)BufPtr); + } + break; + + case CS_GET_ENTRY_ID_MEMORY_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_GetEntryIDMemoryCmd_t))) + { + CS_GetEntryIDMemoryCmd((const CS_GetEntryIDMemoryCmd_t *)BufPtr); + } + break; + + /* Tables Commands */ + case CS_ENABLE_TABLES_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EnableTablesCmd_t))) + { + CS_EnableTablesCmd((const CS_EnableTablesCmd_t *)BufPtr); + } + break; + + case CS_DISABLE_TABLES_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_DisableTablesCmd_t))) + { + CS_DisableTablesCmd((const CS_DisableTablesCmd_t *)BufPtr); + } + break; + + case CS_REPORT_BASELINE_TABLE_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_ReportBaselineTableCmd_t))) + { + CS_ReportBaselineTableCmd((const CS_ReportBaselineTableCmd_t *)BufPtr); + } + break; + + case CS_RECOMPUTE_BASELINE_TABLE_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_RecomputeBaselineTableCmd_t))) + { + CS_RecomputeBaselineTableCmd((const CS_RecomputeBaselineTableCmd_t *)BufPtr); + } + break; + + case CS_ENABLE_NAME_TABLE_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EnableNameTableCmd_t))) + { + CS_EnableNameTableCmd((const CS_EnableNameTableCmd_t *)BufPtr); + } + break; + + case CS_DISABLE_NAME_TABLE_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_DisableNameTableCmd_t))) + { + CS_DisableNameTableCmd((const CS_DisableNameTableCmd_t *)BufPtr); + } + break; + + /* App Commands */ + case CS_ENABLE_APPS_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EnableAppsCmd_t))) + { + CS_EnableAppsCmd((const CS_EnableAppsCmd_t *)BufPtr); + } + break; + + case CS_DISABLE_APPS_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_DisableAppsCmd_t))) + { + CS_DisableAppsCmd((const CS_DisableAppsCmd_t *)BufPtr); + } + break; + + case CS_REPORT_BASELINE_APP_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_ReportBaselineAppCmd_t))) + { + CS_ReportBaselineAppCmd((const CS_ReportBaselineAppCmd_t *)BufPtr); + } + break; + + case CS_RECOMPUTE_BASELINE_APP_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_RecomputeBaselineAppCmd_t))) + { + CS_RecomputeBaselineAppCmd((const CS_RecomputeBaselineAppCmd_t *)BufPtr); + } + break; + + case CS_ENABLE_NAME_APP_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_EnableNameAppCmd_t))) + { + CS_EnableNameAppCmd((const CS_EnableNameAppCmd_t *)BufPtr); + } + break; + + case CS_DISABLE_NAME_APP_CC: + if (CS_VerifyCmdLength(&BufPtr->Msg, sizeof(CS_DisableNameAppCmd_t))) + { + CS_DisableNameAppCmd((const CS_DisableNameAppCmd_t *)BufPtr); + } + break; + + default: + CFE_MSG_GetMsgId(&BufPtr->Msg, &MessageID); + CFE_EVS_SendEvent(CS_CC_ERR_EID, CFE_EVS_EventType_ERROR, + "Invalid ground command code: ID = 0x%08lX, CC = %d", + (unsigned long)CFE_SB_MsgIdToValue(MessageID), CommandCode); + + CS_AppData.HkPacket.Payload.CmdErrCounter++; + break; + } /* end switch */ +} diff --git a/fsw/src/cs_dispatch.h b/fsw/src/cs_dispatch.h new file mode 100644 index 0000000..e131acd --- /dev/null +++ b/fsw/src/cs_dispatch.h @@ -0,0 +1,68 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * Unit specification for the Core Flight System (CFS) + * Checksum (CS) Application. + */ +#ifndef CS_DISPATCH_H +#define CS_DISPATCH_H + +#include "cfe_sb_api_typedefs.h" + +/************************************************************************** +** +** Include section +** +**************************************************************************/ + +/** + * \brief Process a command pipe message + * + * \par Description + * Processes a single software bus command pipe message. Checks + * the message and command IDs and calls the appropriate routine + * to handle the command. + * + * \par Assumptions, External Events, and Notes: + * None + * + * \param [in] BufPtr A #CFE_SB_Buffer_t* pointer that + * references the software bus message. The + * calling function verifies that BufPtr is + * non-null. + * + * \return Execution status, see \ref CFEReturnCodes + * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + */ +CFE_Status_t CS_AppPipe(const CFE_SB_Buffer_t *BufPtr); + +/** + * \brief Command packet processor + * + * \par Description + * Processes all CS commands + * + * \param [in] BufPtr A CFE_SB_Buffer_t* pointer that + * references the software bus pointer. The + * BufPtr is verified non-null in CS_AppMain. + */ +void CS_ProcessCmd(const CFE_SB_Buffer_t *BufPtr); + +#endif diff --git a/fsw/src/cs_eds_dispatch.c b/fsw/src/cs_eds_dispatch.c new file mode 100644 index 0000000..aa485ce --- /dev/null +++ b/fsw/src/cs_eds_dispatch.c @@ -0,0 +1,135 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * CFS Checksum (CS) Application provides the service of background + * checksumming user-defined objects in the CFS + */ +#include "cfe.h" + +#include "cs_app.h" +#include "cs_platform_cfg.h" +#include "cs_eventids.h" +#include "cs_eeprom_cmds.h" +#include "cs_table_cmds.h" +#include "cs_memory_cmds.h" +#include "cs_app_cmds.h" +#include "cs_cmds.h" +#include "cs_dispatch.h" +#include "cs_utils.h" + +#include "cs_eds_dictionary.h" +#include "cs_eds_dispatcher.h" + +static const EdsDispatchTable_EdsComponent_CS_Application_CFE_SB_Telecommand_t CS_TC_DISPATCH_TABLE = { + .CMD = + { + .CancelOneShotCmd_indication = CS_CancelOneShotCmd, + .DisableAllCSCmd_indication = CS_DisableAllCSCmd, + .DisableAppsCmd_indication = CS_DisableAppsCmd, + .DisableCfeCoreCmd_indication = CS_DisableCfeCoreCmd, + .DisableEepromCmd_indication = CS_DisableEepromCmd, + .DisableEntryIDEepromCmd_indication = CS_DisableEntryIDEepromCmd, + .DisableEntryIDMemoryCmd_indication = CS_DisableEntryIDMemoryCmd, + .DisableMemoryCmd_indication = CS_DisableMemoryCmd, + .DisableNameAppCmd_indication = CS_DisableNameAppCmd, + .DisableNameTableCmd_indication = CS_DisableNameTableCmd, + .DisableOSCmd_indication = CS_DisableOSCmd, + .DisableTablesCmd_indication = CS_DisableTablesCmd, + .EnableAllCSCmd_indication = CS_EnableAllCSCmd, + .EnableAppsCmd_indication = CS_EnableAppsCmd, + .EnableCfeCoreCmd_indication = CS_EnableCfeCoreCmd, + .EnableEepromCmd_indication = CS_EnableEepromCmd, + .EnableEntryIDEepromCmd_indication = CS_EnableEntryIDEepromCmd, + .EnableEntryIDMemoryCmd_indication = CS_EnableEntryIDMemoryCmd, + .EnableMemoryCmd_indication = CS_EnableMemoryCmd, + .EnableNameAppCmd_indication = CS_EnableNameAppCmd, + .EnableNameTableCmd_indication = CS_EnableNameTableCmd, + .EnableOSCmd_indication = CS_EnableOSCmd, + .EnableTablesCmd_indication = CS_EnableTablesCmd, + .GetEntryIDEepromCmd_indication = CS_GetEntryIDEepromCmd, + .GetEntryIDMemoryCmd_indication = CS_GetEntryIDMemoryCmd, + .NoopCmd_indication = CS_NoopCmd, + .OneShotCmd_indication = CS_OneShotCmd, + .RecomputeBaselineAppCmd_indication = CS_RecomputeBaselineAppCmd, + .RecomputeBaselineCfeCoreCmd_indication = CS_RecomputeBaselineCfeCoreCmd, + .RecomputeBaselineEepromCmd_indication = CS_RecomputeBaselineEepromCmd, + .RecomputeBaselineMemoryCmd_indication = CS_RecomputeBaselineMemoryCmd, + .RecomputeBaselineOSCmd_indication = CS_RecomputeBaselineOSCmd, + .RecomputeBaselineTableCmd_indication = CS_RecomputeBaselineTableCmd, + .ReportBaselineAppCmd_indication = CS_ReportBaselineAppCmd, + .ReportBaselineCfeCoreCmd_indication = CS_ReportBaselineCfeCoreCmd, + .ReportBaselineEntryIDEepromCmd_indication = CS_ReportBaselineEntryIDEepromCmd, + .ReportBaselineEntryIDMemoryCmd_indication = CS_ReportBaselineEntryIDMemoryCmd, + .ReportBaselineOSCmd_indication = CS_ReportBaselineOSCmd, + .ReportBaselineTableCmd_indication = CS_ReportBaselineTableCmd, + .ResetCmd_indication = CS_ResetCmd, + }, + .SEND_HK = {.indication = CS_SendHkCmd}, + .BACKGROUND_CYCLE = {.indication = CS_BackgroundCheckCycleCmd}}; + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +/* */ +/* CS_AppPipe() -- Process command pipe message */ +/* */ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +CFE_Status_t CS_AppPipe(const CFE_SB_Buffer_t *BufPtr) +{ + CFE_Status_t status; + CFE_SB_MsgId_t MsgId; + CFE_MSG_Size_t MsgSize; + CFE_MSG_FcnCode_t MsgFc; + + status = EdsDispatch_EdsComponent_CS_Application_Telecommand(BufPtr, &CS_TC_DISPATCH_TABLE); + + if (status != CFE_SUCCESS) + { + CFE_MSG_GetMsgId(&BufPtr->Msg, &MsgId); + + ++CS_AppData.HkPacket.Payload.CmdErrCounter; + + if (status == CFE_STATUS_UNKNOWN_MSG_ID) + { + CFE_EVS_SendEvent(CS_MID_ERR_EID, CFE_EVS_EventType_ERROR, "Invalid command pipe message ID: 0x%08lX", + (unsigned long)CFE_SB_MsgIdToValue(MsgId)); + } + else + { + CFE_MSG_GetFcnCode(&BufPtr->Msg, &MsgFc); + if (status == CFE_STATUS_WRONG_MSG_LENGTH) + { + CFE_MSG_GetSize(&BufPtr->Msg, &MsgSize); + CFE_EVS_SendEvent(CS_CMD_LEN_ERR_EID, CFE_EVS_EventType_ERROR, + "Invalid msg length: ID = 0x%08lX, CC = %d, Len = %lu", + (unsigned long)CFE_SB_MsgIdToValue(MsgId), MsgFc, (unsigned long)MsgSize); + } + else + { + CFE_EVS_SendEvent(CS_CC_ERR_EID, CFE_EVS_EventType_ERROR, + "Invalid ground command code: ID = 0x%08lX, CC = %d", + (unsigned long)CFE_SB_MsgIdToValue(MsgId), MsgFc); + } + } + + /* do not exit the app */ + status = CFE_SUCCESS; + } + + return status; +} diff --git a/fsw/src/cs_eeprom_cmds.c b/fsw/src/cs_eeprom_cmds.c index 39c4170..defefbd 100644 --- a/fsw/src/cs_eeprom_cmds.c +++ b/fsw/src/cs_eeprom_cmds.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -28,9 +27,9 @@ ** **************************************************************************/ #include "cfe.h" -#include "cs_tbldefs.h" +#include "cs_tbl.h" #include "cs_app.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_compute.h" #include "cs_eeprom_cmds.h" #include "cs_utils.h" @@ -46,22 +45,24 @@ /* CS Disable background checking of EEPROM command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_DisableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableEepromCmd(const CS_DisableEepromCmd_t *CmdPtr) { - if (CS_CheckRecomputeOneshot() == false) - { - CS_AppData.HkPacket.Payload.EepromCSState = CS_STATE_DISABLED; - CS_ZeroEepromTempValues(); + if (CS_CheckRecomputeOneshot() == false) + { + CS_AppData.HkPacket.Payload.EepromCSState = CS_ChecksumState_DISABLED; + CS_ZeroEepromTempValues(); #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) - CS_UpdateCDS(); + CS_UpdateCDS(); #endif - CFE_EVS_SendEvent(CS_DISABLE_EEPROM_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of EEPROM is Disabled"); + CFE_EVS_SendEvent(CS_DISABLE_EEPROM_INF_EID, CFE_EVS_EventType_INFORMATION, + "Checksumming of EEPROM is Disabled"); - CS_AppData.HkPacket.Payload.CmdCounter++; - } + CS_AppData.HkPacket.Payload.CmdCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -69,21 +70,22 @@ void CS_DisableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Enable background checking of EEPROM command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_EnableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableEepromCmd(const CS_EnableEepromCmd_t *CmdPtr) { - if (CS_CheckRecomputeOneshot() == false) - { - CS_AppData.HkPacket.Payload.EepromCSState = CS_STATE_ENABLED; + if (CS_CheckRecomputeOneshot() == false) + { + CS_AppData.HkPacket.Payload.EepromCSState = CS_ChecksumState_ENABLED; #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) - CS_UpdateCDS(); + CS_UpdateCDS(); #endif - CFE_EVS_SendEvent(CS_ENABLE_EEPROM_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of EEPROM is Enabled"); + CFE_EVS_SendEvent(CS_ENABLE_EEPROM_INF_EID, CFE_EVS_EventType_INFORMATION, "Checksumming of EEPROM is Enabled"); - CS_AppData.HkPacket.Payload.CmdCounter++; - } + CS_AppData.HkPacket.Payload.CmdCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -91,51 +93,53 @@ void CS_EnableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Report the baseline checksum of an entry in the EEPROM table */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_ReportBaselineEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_ReportBaselineEntryIDEepromCmd(const CS_ReportBaselineEntryIDEepromCmd_t *CmdPtr) { /* command verification variables */ - uint32 Baseline = 0; - uint16 EntryID = 0; - uint16 State = CS_STATE_EMPTY; - CS_Res_EepromMemory_Table_Entry_t ResultsEntry; + uint32 Baseline = 0; + uint16 EntryID = 0; + CS_ChecksumState_Enum_t State = CS_ChecksumState_EMPTY; + CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; - EntryID = CmdPtr->Payload.EntryID; + EntryID = CmdPtr->Payload.EntryID; + ResultsEntry = CS_GetEepromResEntry(EntryID); - if ((EntryID < CS_MAX_NUM_EEPROM_TABLE_ENTRIES) && - (CS_AppData.ResEepromTblPtr[EntryID].State != CS_STATE_EMPTY)) - { - ResultsEntry = CS_AppData.ResEepromTblPtr[EntryID]; + if (ResultsEntry == NULL) + { + State = CS_ChecksumState_UNDEFINED; + } + else + { + State = ResultsEntry->State; + } - if (ResultsEntry.ComputedYet == true) - { - Baseline = ResultsEntry.ComparisonValue; + if (CS_StateValid(State)) + { + ResultsEntry->State = CS_ChecksumState_ENABLED; - CFE_EVS_SendEvent(CS_BASELINE_EEPROM_INF_EID, CFE_EVS_EventType_INFORMATION, - "Report baseline of EEPROM Entry %d is 0x%08X", EntryID, (unsigned int)Baseline); - } - else - { - CFE_EVS_SendEvent(CS_NO_BASELINE_EEPROM_INF_EID, CFE_EVS_EventType_INFORMATION, - "Report baseline of EEPROM Entry %d has not been computed yet", EntryID); - } - CS_AppData.HkPacket.Payload.CmdCounter++; + if (ResultsEntry->ComputedYet == true) + { + Baseline = ResultsEntry->ComparisonValue; + + CFE_EVS_SendEvent(CS_BASELINE_EEPROM_INF_EID, CFE_EVS_EventType_INFORMATION, + "Report baseline of EEPROM Entry %d is 0x%08X", EntryID, (unsigned int)Baseline); } else { - if (EntryID >= CS_MAX_NUM_EEPROM_TABLE_ENTRIES) - { - State = CS_STATE_UNDEFINED; - } - else - { - State = CS_AppData.ResEepromTblPtr[EntryID].State; - } - - CFE_EVS_SendEvent(CS_BASELINE_INVALID_ENTRY_EEPROM_ERR_EID, CFE_EVS_EventType_ERROR, - "EEPROM report baseline failed, Entry ID invalid: %d, State: %d Max ID: %d", EntryID, - State, (CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1)); - CS_AppData.HkPacket.Payload.CmdErrCounter++; + CFE_EVS_SendEvent(CS_NO_BASELINE_EEPROM_INF_EID, CFE_EVS_EventType_INFORMATION, + "Report baseline of EEPROM Entry %d has not been computed yet", EntryID); } + CS_AppData.HkPacket.Payload.CmdCounter++; + } + else + { + CFE_EVS_SendEvent(CS_BASELINE_INVALID_ENTRY_EEPROM_ERR_EID, CFE_EVS_EventType_ERROR, + "EEPROM report baseline failed, Entry ID invalid: %d, State: %d Max ID: %d", EntryID, State, + (CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1)); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -143,76 +147,77 @@ void CS_ReportBaselineEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) /* CS Recompute the baseline of an entry in the EEPROM table cmd */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_RecomputeBaselineEepromCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_RecomputeBaselineEepromCmd(const CS_RecomputeBaselineEepromCmd_t *CmdPtr) { /* command verification variables */ - CFE_ES_TaskId_t ChildTaskID = CFE_ES_TASKID_UNDEFINED; - CFE_Status_t Status = CS_ERROR; - uint16 EntryID = 0; - uint16 State = CS_STATE_EMPTY; + CFE_ES_TaskId_t ChildTaskID = CFE_ES_TASKID_UNDEFINED; + CFE_Status_t Status = CS_ERROR; + uint16 EntryID = 0; + CS_ChecksumState_Enum_t State = CS_ChecksumState_EMPTY; + CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; - EntryID = CmdPtr->Payload.EntryID; + if (CS_AppData.HkPacket.Payload.RecomputeInProgress == false && + CS_AppData.HkPacket.Payload.OneShotInProgress == false) + { + EntryID = CmdPtr->Payload.EntryID; + ResultsEntry = CS_GetEepromResEntry(EntryID); + + if (ResultsEntry == NULL) + { + State = CS_ChecksumState_UNDEFINED; + } + else + { + State = ResultsEntry->State; + } - if (CS_AppData.HkPacket.Payload.RecomputeInProgress == false && CS_AppData.HkPacket.Payload.OneShotInProgress == false) + if (CS_StateValid(State)) { - /* make sure the entry is a valid number and is defined in the table */ - if ((EntryID < CS_MAX_NUM_EEPROM_TABLE_ENTRIES) && - (CS_AppData.ResEepromTblPtr[EntryID].State != CS_STATE_EMPTY)) + /* There is no child task running right now, we can use it*/ + CS_AppData.HkPacket.Payload.RecomputeInProgress = true; + + /* fill in child task variables */ + CS_AppData.ChildTaskTable = CS_ChecksumType_EEPROM_TABLE; + CS_AppData.ChildTaskEntryID = EntryID; + + CS_AppData.RecomputeEepromMemoryEntryPtr = ResultsEntry; + + Status = CFE_ES_CreateChildTask(&ChildTaskID, CS_RECOMP_EEPROM_TASK_NAME, CS_RecomputeEepromMemoryChildTask, + NULL, CFE_PLATFORM_ES_DEFAULT_STACK_SIZE, CS_CHILD_TASK_PRIORITY, 0); + if (Status == CFE_SUCCESS) { - /* There is no child task running right now, we can use it*/ - CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - - /* fill in child task variables */ - CS_AppData.ChildTaskTable = CS_EEPROM_TABLE; - CS_AppData.ChildTaskEntryID = EntryID; - - CS_AppData.RecomputeEepromMemoryEntryPtr = &CS_AppData.ResEepromTblPtr[EntryID]; - - Status = - CFE_ES_CreateChildTask(&ChildTaskID, CS_RECOMP_EEPROM_TASK_NAME, CS_RecomputeEepromMemoryChildTask, - NULL, CFE_PLATFORM_ES_DEFAULT_STACK_SIZE, CS_CHILD_TASK_PRIORITY, 0); - if (Status == CFE_SUCCESS) - { - CFE_EVS_SendEvent(CS_RECOMPUTE_EEPROM_STARTED_DBG_EID, CFE_EVS_EventType_DEBUG, - "Recompute baseline of EEPROM Entry ID %d started", EntryID); - CS_AppData.HkPacket.Payload.CmdCounter++; - } - else /* child task creation failed */ - { - CFE_EVS_SendEvent( - CS_RECOMPUTE_EEPROM_CREATE_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, - "Recompute baseline of EEPROM Entry ID %d failed, CFE_ES_CreateChildTask returned: 0x%08X", - EntryID, (unsigned int)Status); - CS_AppData.HkPacket.Payload.CmdErrCounter++; - CS_AppData.HkPacket.Payload.RecomputeInProgress = false; - } + CFE_EVS_SendEvent(CS_RECOMPUTE_EEPROM_STARTED_DBG_EID, CFE_EVS_EventType_DEBUG, + "Recompute baseline of EEPROM Entry ID %d started", EntryID); + CS_AppData.HkPacket.Payload.CmdCounter++; } - else + else /* child task creation failed */ { - if (EntryID >= CS_MAX_NUM_EEPROM_TABLE_ENTRIES) - { - State = CS_STATE_UNDEFINED; - } - else - { - State = CS_AppData.ResEepromTblPtr[EntryID].State; - } - CFE_EVS_SendEvent( - CS_RECOMPUTE_INVALID_ENTRY_EEPROM_ERR_EID, CFE_EVS_EventType_ERROR, - "EEPROM recompute baseline of entry failed, Entry ID invalid: %d, State: %d, Max ID: %d", EntryID, - State, (CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1)); - + CS_RECOMPUTE_EEPROM_CREATE_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, + "Recompute baseline of EEPROM Entry ID %d failed, CFE_ES_CreateChildTask returned: 0x%08X", + EntryID, (unsigned int)Status); CS_AppData.HkPacket.Payload.CmdErrCounter++; + CS_AppData.HkPacket.Payload.RecomputeInProgress = false; } } else { - /*send event that we can't start another task right now */ - CFE_EVS_SendEvent(CS_RECOMPUTE_EEPROM_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, - "Recompute baseline of EEPROM Entry ID %d failed: child task in use", EntryID); + CFE_EVS_SendEvent(CS_RECOMPUTE_INVALID_ENTRY_EEPROM_ERR_EID, CFE_EVS_EventType_ERROR, + "EEPROM recompute baseline of entry failed, Entry ID invalid: %d, State: %d, Max ID: %d", + EntryID, State, (CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1)); + CS_AppData.HkPacket.Payload.CmdErrCounter++; } + } + else + { + /*send event that we can't start another task right now */ + CFE_EVS_SendEvent(CS_RECOMPUTE_EEPROM_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, + "Recompute baseline of EEPROM Entry ID %d failed: child task in use", EntryID); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -220,59 +225,58 @@ void CS_RecomputeBaselineEepromCmd(const CS_EntryCmd_t *CmdPtr) /* CS Enable a specific entry in the EEPROM table command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_EnableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_EnableEntryIDEepromCmd(const CS_EnableEntryIDEepromCmd_t *CmdPtr) { /* command verification variables */ CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; + CS_Def_EepromMemory_Table_Entry_t *DefEntry = NULL; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE]; uint16 EntryID = 0; - uint16 State = CS_STATE_EMPTY; + CS_ChecksumState_Enum_t State = CS_ChecksumState_EMPTY; + + if (CS_CheckRecomputeOneshot() == false) + { + EntryID = CmdPtr->Payload.EntryID; + ResultsEntry = CS_GetEepromResEntry(EntryID); - if (CS_CheckRecomputeOneshot() == false) + if (ResultsEntry == NULL) + { + State = CS_ChecksumState_UNDEFINED; + } + else { - EntryID = CmdPtr->Payload.EntryID; + State = ResultsEntry->State; + } - if ((EntryID < CS_MAX_NUM_EEPROM_TABLE_ENTRIES) && - (CS_AppData.ResEepromTblPtr[EntryID].State != CS_STATE_EMPTY)) - { - ResultsEntry = &CS_AppData.ResEepromTblPtr[EntryID]; - - ResultsEntry->State = CS_STATE_ENABLED; - - CFE_EVS_SendEvent(CS_ENABLE_EEPROM_ENTRY_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of EEPROM Entry ID %d is Enabled", EntryID); - - if (CS_AppData.DefEepromTblPtr[EntryID].State != CS_STATE_EMPTY) - { - CS_AppData.DefEepromTblPtr[EntryID].State = CS_STATE_ENABLED; - CS_ResetTablesTblResultEntry(CS_AppData.EepResTablesTblPtr); - CFE_TBL_Modified(CS_AppData.DefEepromTableHandle); - } - else - { - CFE_EVS_SendEvent(CS_ENABLE_EEPROM_DEF_EMPTY_DBG_EID, CFE_EVS_EventType_DEBUG, - "CS unable to update EEPROM definition table for entry %d, State: %d", EntryID, - State); - } + if (CS_StateValid(State)) + { + DefEntry = CS_GetEepromDefEntry(EntryID); - CS_AppData.HkPacket.Payload.CmdCounter++; - } - else + ResultsEntry->State = CS_ChecksumState_ENABLED; + + CFE_EVS_SendEvent(CS_ENABLE_EEPROM_ENTRY_INF_EID, CFE_EVS_EventType_INFORMATION, + "Checksumming of EEPROM Entry ID %d is Enabled", EntryID); + + State = CS_SetDefEntryState(tw, DefEntry, CS_ChecksumState_ENABLED); + if (!CS_StateValid(State)) { - if (EntryID >= CS_MAX_NUM_EEPROM_TABLE_ENTRIES) - { - State = CS_STATE_UNDEFINED; - } - else - { - State = CS_AppData.ResEepromTblPtr[EntryID].State; - } - - CFE_EVS_SendEvent(CS_ENABLE_EEPROM_INVALID_ENTRY_ERR_EID, CFE_EVS_EventType_ERROR, - "Enable EEPROM entry failed, invalid Entry ID: %d, State: %d, Max ID: %d", EntryID, - State, (CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1)); - CS_AppData.HkPacket.Payload.CmdErrCounter++; + CFE_EVS_SendEvent(CS_ENABLE_EEPROM_DEF_EMPTY_DBG_EID, CFE_EVS_EventType_DEBUG, + "CS unable to update EEPROM definition table for entry %d, State: %d", EntryID, + State); } - } /* end InProgress if */ + + CS_AppData.HkPacket.Payload.CmdCounter++; + } + else + { + CFE_EVS_SendEvent(CS_ENABLE_EEPROM_INVALID_ENTRY_ERR_EID, CFE_EVS_EventType_ERROR, + "Enable EEPROM entry failed, invalid Entry ID: %d, State: %d, Max ID: %d", EntryID, + State, (CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1)); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + } /* end InProgress if */ + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -280,62 +284,61 @@ void CS_EnableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) /* CS Disable a specific entry in the EEPROM table command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_DisableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_DisableEntryIDEepromCmd(const CS_DisableEntryIDEepromCmd_t *CmdPtr) { /* command verification variables */ CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; + CS_Def_EepromMemory_Table_Entry_t *DefEntry = NULL; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE]; uint16 EntryID = 0; - uint16 State = CS_STATE_EMPTY; + CS_ChecksumState_Enum_t State = CS_ChecksumState_EMPTY; + + if (CS_CheckRecomputeOneshot() == false) + { + EntryID = CmdPtr->Payload.EntryID; + ResultsEntry = CS_GetEepromResEntry(EntryID); - if (CS_CheckRecomputeOneshot() == false) + if (ResultsEntry == NULL) + { + State = CS_ChecksumState_UNDEFINED; + } + else { - EntryID = CmdPtr->Payload.EntryID; + State = ResultsEntry->State; + } - if ((EntryID < CS_MAX_NUM_EEPROM_TABLE_ENTRIES) && - (CS_AppData.ResEepromTblPtr[EntryID].State != CS_STATE_EMPTY)) - { - ResultsEntry = &CS_AppData.ResEepromTblPtr[EntryID]; - - ResultsEntry->State = CS_STATE_DISABLED; - ResultsEntry->TempChecksumValue = 0; - ResultsEntry->ByteOffset = 0; - - CFE_EVS_SendEvent(CS_DISABLE_EEPROM_ENTRY_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of EEPROM Entry ID %d is Disabled", EntryID); - - if (CS_AppData.DefEepromTblPtr[EntryID].State != CS_STATE_EMPTY) - { - CS_AppData.DefEepromTblPtr[EntryID].State = CS_STATE_DISABLED; - CS_ResetTablesTblResultEntry(CS_AppData.EepResTablesTblPtr); - CFE_TBL_Modified(CS_AppData.DefEepromTableHandle); - } - else - { - CFE_EVS_SendEvent(CS_DISABLE_EEPROM_DEF_EMPTY_DBG_EID, CFE_EVS_EventType_DEBUG, - "CS unable to update EEPROM definition table for entry %d, State: %d", EntryID, - State); - } + if (CS_StateValid(State)) + { + DefEntry = CS_GetEepromDefEntry(EntryID); - CS_AppData.HkPacket.Payload.CmdCounter++; - } - else - { - if (EntryID >= CS_MAX_NUM_EEPROM_TABLE_ENTRIES) - { - State = CS_STATE_UNDEFINED; - } - else - { - State = CS_AppData.ResEepromTblPtr[EntryID].State; - } - - CFE_EVS_SendEvent(CS_DISABLE_EEPROM_INVALID_ENTRY_ERR_EID, CFE_EVS_EventType_ERROR, - "Disable EEPROM entry failed, invalid Entry ID: %d, State: %d, Max ID: %d", EntryID, - State, (CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1)); + ResultsEntry->State = CS_ChecksumState_DISABLED; + ResultsEntry->TempChecksumValue = 0; + ResultsEntry->ByteOffset = 0; - CS_AppData.HkPacket.Payload.CmdErrCounter++; + CFE_EVS_SendEvent(CS_DISABLE_EEPROM_ENTRY_INF_EID, CFE_EVS_EventType_INFORMATION, + "Checksumming of EEPROM Entry ID %d is Disabled", EntryID); + + State = CS_SetDefEntryState(tw, DefEntry, CS_ChecksumState_DISABLED); + if (!CS_StateValid(State)) + { + CFE_EVS_SendEvent(CS_DISABLE_EEPROM_DEF_EMPTY_DBG_EID, CFE_EVS_EventType_DEBUG, + "CS unable to update EEPROM definition table for entry %d, State: %d", EntryID, + State); } - } /* end InProgress if */ + + CS_AppData.HkPacket.Payload.CmdCounter++; + } + else + { + CFE_EVS_SendEvent(CS_DISABLE_EEPROM_INVALID_ENTRY_ERR_EID, CFE_EVS_EventType_ERROR, + "Disable EEPROM entry failed, invalid Entry ID: %d, State: %d, Max ID: %d", EntryID, + State, (CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1)); + + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + } /* end InProgress if */ + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -343,34 +346,39 @@ void CS_DisableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) /* CS Retrieve an EntryID based on Address from EEPROM table cmd */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_GetEntryIDEepromCmd(const CS_GetEntryIDCmd_t *CmdPtr) +CFE_Status_t CS_GetEntryIDEepromCmd(const CS_GetEntryIDEepromCmd_t *CmdPtr) { /* command verification variables */ - CS_Res_EepromMemory_Table_Entry_t *StartOfResultsTable = NULL; - uint16 Loop = 0; - bool EntryFound = false; - CS_Res_EepromMemory_Table_Entry_t ResultsEntry; - - StartOfResultsTable = CS_AppData.ResEepromTblPtr; - - for (Loop = 0; Loop < CS_MAX_NUM_EEPROM_TABLE_ENTRIES; Loop++) + uint16 Loop = 0; + bool EntryFound = false; + CS_Res_EepromMemory_Table_Entry_t *ResultsEntry; + + Loop = 0; + while (true) + { + ResultsEntry = CS_GetEepromResEntry(Loop); + if (ResultsEntry == NULL) { - ResultsEntry = StartOfResultsTable[Loop]; - - if ((ResultsEntry.StartAddress <= CmdPtr->Payload.Address) && - CmdPtr->Payload.Address <= (ResultsEntry.StartAddress + ResultsEntry.NumBytesToChecksum) && - ResultsEntry.State != CS_STATE_EMPTY) - { - CFE_EVS_SendEvent(CS_GET_ENTRY_ID_EEPROM_INF_EID, CFE_EVS_EventType_INFORMATION, - "EEPROM Found Address 0x%08X in Entry ID %d", (unsigned int)(CmdPtr->Payload.Address), Loop); - EntryFound = true; - } + break; } - if (EntryFound == false) + if (ResultsEntry->State != CS_ChecksumState_EMPTY && ResultsEntry->StartAddress <= CmdPtr->Payload.Address && + CmdPtr->Payload.Address < (ResultsEntry->StartAddress + ResultsEntry->NumBytesToChecksum)) { - CFE_EVS_SendEvent(CS_GET_ENTRY_ID_EEPROM_NOT_FOUND_INF_EID, CFE_EVS_EventType_INFORMATION, - "Address 0x%08X was not found in EEPROM table", (unsigned int)(CmdPtr->Payload.Address)); + CFE_EVS_SendEvent(CS_GET_ENTRY_ID_EEPROM_INF_EID, CFE_EVS_EventType_INFORMATION, + "EEPROM Found Address 0x%08X in Entry ID %d", (unsigned int)(CmdPtr->Payload.Address), + Loop); + EntryFound = true; } - CS_AppData.HkPacket.Payload.CmdCounter++; + ++Loop; + } + + if (EntryFound == false) + { + CFE_EVS_SendEvent(CS_GET_ENTRY_ID_EEPROM_NOT_FOUND_INF_EID, CFE_EVS_EventType_INFORMATION, + "Address 0x%08X was not found in EEPROM table", (unsigned int)(CmdPtr->Payload.Address)); + } + CS_AppData.HkPacket.Payload.CmdCounter++; + + return CFE_SUCCESS; } diff --git a/fsw/src/cs_eeprom_cmds.h b/fsw/src/cs_eeprom_cmds.h index a1e52fb..95cbf06 100644 --- a/fsw/src/cs_eeprom_cmds.h +++ b/fsw/src/cs_eeprom_cmds.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -49,7 +48,7 @@ * * \sa #CS_DISABLE_EEPROM_CC */ -void CS_DisableEepromCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_DisableEepromCmd(const CS_DisableEepromCmd_t *CmdPtr); /** * \brief Process an enable background checking for the EEPROM @@ -68,7 +67,7 @@ void CS_DisableEepromCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_ENABLE_EEPROM_CC */ -void CS_EnableEepromCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_EnableEepromCmd(const CS_EnableEepromCmd_t *CmdPtr); /** * \brief Proccess a report baseline of an EEPROM Entry command @@ -82,9 +81,9 @@ void CS_EnableEepromCmd(const CS_NoArgsCmd_t *CmdPtr); * * \param[in] CmdPtr Command pointer, verified non-null in CS_AppMain * - * \sa #CS_REPORT_BASELINE_EEPROM_CC + * \sa #CS_REPORT_BASELINE_ENTRY_ID_EEPROM_CC */ -void CS_ReportBaselineEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr); +CFE_Status_t CS_ReportBaselineEntryIDEepromCmd(const CS_ReportBaselineEntryIDEepromCmd_t *CmdPtr); /** * \brief Process a disable background checking for an EEPROM @@ -105,9 +104,9 @@ void CS_ReportBaselineEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr); * * \param[in] CmdPtr Command pointer, verified non-null in CS_AppMain * - * \sa #CS_DISABLE_ENTRY_EEPROM_CC + * \sa #CS_DISABLE_ENTRY_ID_EEPROM_CC */ -void CS_DisableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr); +CFE_Status_t CS_DisableEntryIDEepromCmd(const CS_DisableEntryIDEepromCmd_t *CmdPtr); /** * \brief Process a recopmute baseline of an EEPROM table entry command @@ -123,7 +122,7 @@ void CS_DisableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr); * * \sa #CS_RECOMPUTE_BASELINE_EEPROM_CC */ -void CS_RecomputeBaselineEepromCmd(const CS_EntryCmd_t *CmdPtr); +CFE_Status_t CS_RecomputeBaselineEepromCmd(const CS_RecomputeBaselineEepromCmd_t *CmdPtr); /** * \brief Process an enable background checking for an EEPROM @@ -144,9 +143,9 @@ void CS_RecomputeBaselineEepromCmd(const CS_EntryCmd_t *CmdPtr); * * \param[in] CmdPtr Command pointer, verified non-null in CS_AppMain * - * \sa #CS_ENABLE_ENTRY_EEPROM_CC + * \sa #CS_ENABLE_ENTRY_ID_EEPROM_CC */ -void CS_EnableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr); +CFE_Status_t CS_EnableEntryIDEepromCmd(const CS_EnableEntryIDEepromCmd_t *CmdPtr); /** * \brief Process a get EEPROM Entry by Address command @@ -161,6 +160,6 @@ void CS_EnableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr); * * \sa #CS_GET_ENTRY_ID_EEPROM_CC */ -void CS_GetEntryIDEepromCmd(const CS_GetEntryIDCmd_t *CmdPtr); +CFE_Status_t CS_GetEntryIDEepromCmd(const CS_GetEntryIDEepromCmd_t *CmdPtr); #endif diff --git a/fsw/src/cs_init.c b/fsw/src/cs_init.c index 915da01..f22bfcd 100644 --- a/fsw/src/cs_init.c +++ b/fsw/src/cs_init.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -22,7 +21,7 @@ #include "cs_app.h" #include "cs_platform_cfg.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_utils.h" #include "cs_compute.h" #include "cs_eeprom_cmds.h" @@ -42,17 +41,12 @@ CFE_Status_t CS_SbInit(void) { CFE_Status_t Result = CFE_SUCCESS; - /* Initialize app configuration data */ - snprintf(CS_AppData.PipeName, sizeof(CS_AppData.PipeName), "%s", CS_CMD_PIPE_NAME); - - CS_AppData.PipeDepth = CS_PIPE_DEPTH; - /* Initialize housekeeping packet */ CFE_MSG_Init(CFE_MSG_PTR(CS_AppData.HkPacket.TelemetryHeader), CFE_SB_ValueToMsgId(CS_HK_TLM_MID), sizeof(CS_HkPacket_t)); /* Create Software Bus message pipe */ - Result = CFE_SB_CreatePipe(&CS_AppData.CmdPipe, CS_AppData.PipeDepth, CS_AppData.PipeName); + Result = CFE_SB_CreatePipe(&CS_AppData.CmdPipe, CS_PIPE_DEPTH, CS_CMD_PIPE_NAME); if (Result != CFE_SUCCESS) { CFE_EVS_SendEvent(CS_CR_PIPE_ERR_EID, CFE_EVS_EventType_ERROR, @@ -101,72 +95,127 @@ CFE_Status_t CS_SbInit(void) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ CFE_Status_t CS_InitAllTables(void) { - CFE_Status_t ResultInit = CFE_SUCCESS; + static const CS_TableWrapper_t TABLE_INITIALIZERS[CS_NUM_TABLES] = { + [CS_ChecksumType_CFECORE] = + { + .BaselineValue = &CS_AppData.HkPacket.Payload.CfeCoreBaseline, + .ResEntrySize = sizeof(CS_Res_EepromMemory_Table_Entry_t), + .ResAddr = &CS_AppData.CfeCoreCodeSeg, + .NumEntries = 1, + }, + [CS_ChecksumType_OSCORE] = + { + .BaselineValue = &CS_AppData.HkPacket.Payload.OSBaseline, + .ResEntrySize = sizeof(CS_Res_EepromMemory_Table_Entry_t), + .ResAddr = &CS_AppData.OSCodeSeg, + .NumEntries = 1, + }, + [CS_ChecksumType_EEPROM_TABLE] = + { + .DefTableName = CS_DEF_EEPROM_TABLE_NAME, + .ResTableName = CS_RESULTS_EEPROM_TABLE_NAME, + .GlobalState = &CS_AppData.HkPacket.Payload.EepromCSState, + .NumEntries = CS_MAX_NUM_EEPROM_TABLE_ENTRIES, + .DefEntrySize = sizeof(CS_Def_EepromMemory_Table_Entry_t), + .ResEntrySize = sizeof(CS_Res_EepromMemory_Table_Entry_t), + .DefStateOffset = offsetof(CS_Def_EepromMemory_Table_Entry_t, State), + .UpdateHandler = CS_ProcessNewEepromMemoryDefinitionTable, + .DefaultDefinitionPtr = CS_AppData.DefaultEepromDefTable, + }, + [CS_ChecksumType_MEMORY_TABLE] = + { + .DefTableName = CS_DEF_MEMORY_TABLE_NAME, + .ResTableName = CS_RESULTS_MEMORY_TABLE_NAME, + .GlobalState = &CS_AppData.HkPacket.Payload.MemoryCSState, + .NumEntries = CS_MAX_NUM_MEMORY_TABLE_ENTRIES, + .DefEntrySize = sizeof(CS_Def_EepromMemory_Table_Entry_t), + .ResEntrySize = sizeof(CS_Res_EepromMemory_Table_Entry_t), + .DefStateOffset = offsetof(CS_Def_EepromMemory_Table_Entry_t, State), + .UpdateHandler = CS_ProcessNewEepromMemoryDefinitionTable, + .DefaultDefinitionPtr = CS_AppData.DefaultMemoryDefTable, + }, + [CS_ChecksumType_TABLES_TABLE] = + { + .DefTableName = CS_DEF_TABLES_TABLE_NAME, + .ResTableName = CS_RESULTS_TABLES_TABLE_NAME, + .GlobalState = &CS_AppData.HkPacket.Payload.TablesCSState, + .NumEntries = CS_MAX_NUM_TABLES_TABLE_ENTRIES, + .DefEntrySize = sizeof(CS_Def_Tables_Table_Entry_t), + .ResEntrySize = sizeof(CS_Res_Tables_Table_Entry_t), + .DefStateOffset = offsetof(CS_Def_Tables_Table_Entry_t, State), + .UpdateHandler = CS_ProcessNewTablesDefinitionTable, + .DefaultDefinitionPtr = CS_AppData.DefaultTablesDefTable, + }, + [CS_ChecksumType_APP_TABLE] = { + .DefTableName = CS_DEF_APP_TABLE_NAME, + .ResTableName = CS_RESULTS_APP_TABLE_NAME, + .GlobalState = &CS_AppData.HkPacket.Payload.AppCSState, + .NumEntries = CS_MAX_NUM_APP_TABLE_ENTRIES, + .DefEntrySize = sizeof(CS_Def_App_Table_Entry_t), + .ResEntrySize = sizeof(CS_Res_App_Table_Entry_t), + .DefStateOffset = offsetof(CS_Def_App_Table_Entry_t, State), + .UpdateHandler = CS_ProcessNewAppDefinitionTable, + .DefaultDefinitionPtr = CS_AppData.DefaultAppDefTable, + }}; - ResultInit = CS_TableInit(&CS_AppData.DefEepromTableHandle, &CS_AppData.ResEepromTableHandle, - (void **)&CS_AppData.DefEepromTblPtr, (void **)&CS_AppData.ResEepromTblPtr, - CS_EEPROM_TABLE, CS_DEF_EEPROM_TABLE_NAME, CS_RESULTS_EEPROM_TABLE_NAME, - CS_MAX_NUM_EEPROM_TABLE_ENTRIES, CS_DEF_EEPROM_TABLE_FILENAME, - &CS_AppData.DefaultEepromDefTable, sizeof(CS_Def_EepromMemory_Table_Entry_t), - sizeof(CS_Res_EepromMemory_Table_Entry_t), CS_ValidateEepromChecksumDefinitionTable); + static const char *const TABLE_FILENAME_MAP[CS_NUM_TABLES] = { + [CS_ChecksumType_EEPROM_TABLE] = CS_DEF_EEPROM_TABLE_FILENAME, + [CS_ChecksumType_MEMORY_TABLE] = CS_DEF_MEMORY_TABLE_FILENAME, + [CS_ChecksumType_TABLES_TABLE] = CS_DEF_TABLES_TABLE_FILENAME, + [CS_ChecksumType_APP_TABLE] = CS_DEF_APP_TABLE_FILENAME}; - if (ResultInit != CFE_SUCCESS) - { - CS_AppData.HkPacket.Payload.EepromCSState = CS_STATE_DISABLED; - CFE_EVS_SendEvent(CS_INIT_EEPROM_ERR_EID, CFE_EVS_EventType_ERROR, - "Table initialization failed for EEPROM: 0x%08X", (unsigned int)ResultInit); - } - else - { - ResultInit = CS_TableInit(&CS_AppData.DefMemoryTableHandle, &CS_AppData.ResMemoryTableHandle, - (void **)&CS_AppData.DefMemoryTblPtr, (void **)&CS_AppData.ResMemoryTblPtr, - CS_MEMORY_TABLE, CS_DEF_MEMORY_TABLE_NAME, CS_RESULTS_MEMORY_TABLE_NAME, - CS_MAX_NUM_MEMORY_TABLE_ENTRIES, CS_DEF_MEMORY_TABLE_FILENAME, - &CS_AppData.DefaultMemoryDefTable, sizeof(CS_Def_EepromMemory_Table_Entry_t), - sizeof(CS_Res_EepromMemory_Table_Entry_t), CS_ValidateMemoryChecksumDefinitionTable); - - if (ResultInit != CFE_SUCCESS) - { - CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_DISABLED; - CFE_EVS_SendEvent(CS_INIT_MEMORY_ERR_EID, CFE_EVS_EventType_ERROR, - "Table initialization failed for Memory: 0x%08X", (unsigned int)ResultInit); - } - } + static const CFE_TBL_CallbackFuncPtr_t TABLE_CALLBACK_MAP[CS_NUM_TABLES] = { + [CS_ChecksumType_EEPROM_TABLE] = CS_ValidateEepromChecksumDefinitionTable, + [CS_ChecksumType_MEMORY_TABLE] = CS_ValidateMemoryChecksumDefinitionTable, + [CS_ChecksumType_TABLES_TABLE] = CS_ValidateTablesChecksumDefinitionTable, + [CS_ChecksumType_APP_TABLE] = CS_ValidateAppChecksumDefinitionTable}; - if (ResultInit == CFE_SUCCESS) - { - ResultInit = CS_TableInit( - &CS_AppData.DefAppTableHandle, &CS_AppData.ResAppTableHandle, (void **)&CS_AppData.DefAppTblPtr, - (void **)&CS_AppData.ResAppTblPtr, CS_APP_TABLE, CS_DEF_APP_TABLE_NAME, CS_RESULTS_APP_TABLE_NAME, - CS_MAX_NUM_APP_TABLE_ENTRIES, CS_DEF_APP_TABLE_FILENAME, &CS_AppData.DefaultAppDefTable, - sizeof(CS_Def_App_Table_Entry_t), sizeof(CS_Res_App_Table_Entry_t), CS_ValidateAppChecksumDefinitionTable); + static const uint16 TABLE_EVENTID_MAP[CS_NUM_TABLES] = {[CS_ChecksumType_EEPROM_TABLE] = CS_INIT_EEPROM_ERR_EID, + [CS_ChecksumType_MEMORY_TABLE] = CS_INIT_MEMORY_ERR_EID, + [CS_ChecksumType_TABLES_TABLE] = CS_INIT_TABLES_ERR_EID, + [CS_ChecksumType_APP_TABLE] = CS_INIT_APP_ERR_EID}; - if (ResultInit != CFE_SUCCESS) - { - CS_AppData.HkPacket.Payload.AppCSState = CS_STATE_DISABLED; - CFE_EVS_SendEvent(CS_INIT_APP_ERR_EID, CFE_EVS_EventType_ERROR, - "Table initialization failed for Apps: 0x%08X", (unsigned int)ResultInit); - } - } + CFE_Status_t ResultAll; + CFE_Status_t Result; + const char * LoadFilename; + CFE_TBL_CallbackFuncPtr_t ValidationFunc; + CS_TableWrapper_t * tw; + CS_ChecksumType_Enum_t TableId; + uint16 ErrorEventID; + + ResultAll = CFE_SUCCESS; + tw = CS_AppData.Tbl; - if (ResultInit == CFE_SUCCESS) + for (TableId = 0; TableId < CS_NUM_TABLES; ++TableId) { - ResultInit = CS_TableInit(&CS_AppData.DefTablesTableHandle, &CS_AppData.ResTablesTableHandle, - (void **)&CS_AppData.DefTablesTblPtr, (void **)&CS_AppData.ResTablesTblPtr, - CS_TABLES_TABLE, CS_DEF_TABLES_TABLE_NAME, CS_RESULTS_TABLES_TABLE_NAME, - CS_MAX_NUM_TABLES_TABLE_ENTRIES, CS_DEF_TABLES_TABLE_FILENAME, - &CS_AppData.DefaultTablesDefTable, sizeof(CS_Def_Tables_Table_Entry_t), - sizeof(CS_Res_Tables_Table_Entry_t), CS_ValidateTablesChecksumDefinitionTable); - - if (ResultInit != CFE_SUCCESS) + *tw = TABLE_INITIALIZERS[TableId]; + LoadFilename = TABLE_FILENAME_MAP[TableId]; + ValidationFunc = TABLE_CALLBACK_MAP[TableId]; + ErrorEventID = TABLE_EVENTID_MAP[TableId]; + + /* If this table needs to be loaded via table services, do that now */ + Result = CS_TableInit(tw, LoadFilename, ValidationFunc); + if (Result != CFE_SUCCESS) { - CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_DISABLED; - CFE_EVS_SendEvent(CS_INIT_TABLES_ERR_EID, CFE_EVS_EventType_ERROR, - "Table initialization failed for Tables: 0x%08X", (unsigned int)ResultInit); + /* If the init did not work then make sure the global status is set to disabled */ + if (tw->GlobalState) + { + *tw->GlobalState = CS_ChecksumState_DISABLED; + } + + if (ErrorEventID != 0) + { + CFE_EVS_SendEvent(ErrorEventID, CFE_EVS_EventType_ERROR, "Table initialization failed for %s: 0x%08X", + CS_GetTableTypeAsString(tw), (unsigned int)Result); + } + + ResultAll = Result; } + + ++tw; } - return ResultInit; + return ResultAll; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -182,57 +231,61 @@ void CS_InitSegments(void) uint32 KernelSize; cpuaddr KernelAddress; + CS_Res_EepromMemory_Table_Entry_t *CodeSeg; + /* Initalize the CFE core segments */ ResultSegment = CFE_PSP_GetCFETextSegmentInfo(&CFEAddress, &CFESize); + CodeSeg = CS_GetCfeCoreCodeSegResTable(); if (ResultSegment != OS_SUCCESS) { - CS_AppData.CfeCoreCodeSeg.StartAddress = 0; - CS_AppData.CfeCoreCodeSeg.NumBytesToChecksum = 0; - CS_AppData.CfeCoreCodeSeg.ComputedYet = false; - CS_AppData.CfeCoreCodeSeg.ComparisonValue = 0; - CS_AppData.CfeCoreCodeSeg.ByteOffset = 0; - CS_AppData.CfeCoreCodeSeg.TempChecksumValue = 0; - CS_AppData.CfeCoreCodeSeg.State = CS_STATE_DISABLED; + CodeSeg->StartAddress = 0; + CodeSeg->NumBytesToChecksum = 0; + CodeSeg->ComputedYet = false; + CodeSeg->ComparisonValue = 0; + CodeSeg->ByteOffset = 0; + CodeSeg->TempChecksumValue = 0; + CodeSeg->State = CS_ChecksumState_DISABLED; CFE_EVS_SendEvent(CS_CFE_TEXT_SEG_INF_EID, CFE_EVS_EventType_INFORMATION, "CFE Text Segment disabled"); } else { - CS_AppData.CfeCoreCodeSeg.StartAddress = CFEAddress; - CS_AppData.CfeCoreCodeSeg.NumBytesToChecksum = CFESize; - CS_AppData.CfeCoreCodeSeg.ComputedYet = false; - CS_AppData.CfeCoreCodeSeg.ComparisonValue = 0; - CS_AppData.CfeCoreCodeSeg.ByteOffset = 0; - CS_AppData.CfeCoreCodeSeg.TempChecksumValue = 0; - CS_AppData.CfeCoreCodeSeg.State = CS_STATE_ENABLED; + CodeSeg->StartAddress = CFEAddress; + CodeSeg->NumBytesToChecksum = CFESize; + CodeSeg->ComputedYet = false; + CodeSeg->ComparisonValue = 0; + CodeSeg->ByteOffset = 0; + CodeSeg->TempChecksumValue = 0; + CodeSeg->State = CS_ChecksumState_ENABLED; } /* Initialize the OS Core code segment*/ ResultSegment = CFE_PSP_GetKernelTextSegmentInfo(&KernelAddress, &KernelSize); + CodeSeg = CS_GetOSCodeSegResTable(); if (ResultSegment != OS_SUCCESS) { - CS_AppData.OSCodeSeg.StartAddress = 0; - CS_AppData.OSCodeSeg.NumBytesToChecksum = 0; - CS_AppData.OSCodeSeg.ComputedYet = false; - CS_AppData.OSCodeSeg.ComparisonValue = 0; - CS_AppData.OSCodeSeg.ByteOffset = 0; - CS_AppData.OSCodeSeg.TempChecksumValue = 0; - CS_AppData.OSCodeSeg.State = CS_STATE_DISABLED; + CodeSeg->StartAddress = 0; + CodeSeg->NumBytesToChecksum = 0; + CodeSeg->ComputedYet = false; + CodeSeg->ComparisonValue = 0; + CodeSeg->ByteOffset = 0; + CodeSeg->TempChecksumValue = 0; + CodeSeg->State = CS_ChecksumState_DISABLED; CFE_EVS_SendEvent(CS_OS_TEXT_SEG_INF_EID, CFE_EVS_EventType_INFORMATION, "OS Text Segment disabled due to platform"); } else { - CS_AppData.OSCodeSeg.StartAddress = KernelAddress; - CS_AppData.OSCodeSeg.NumBytesToChecksum = KernelSize; - CS_AppData.OSCodeSeg.ComputedYet = false; - CS_AppData.OSCodeSeg.ComparisonValue = 0; - CS_AppData.OSCodeSeg.ByteOffset = 0; - CS_AppData.OSCodeSeg.TempChecksumValue = 0; - CS_AppData.OSCodeSeg.State = CS_STATE_ENABLED; + CodeSeg->StartAddress = KernelAddress; + CodeSeg->NumBytesToChecksum = KernelSize; + CodeSeg->ComputedYet = false; + CodeSeg->ComparisonValue = 0; + CodeSeg->ByteOffset = 0; + CodeSeg->TempChecksumValue = 0; + CodeSeg->State = CS_ChecksumState_ENABLED; } } diff --git a/fsw/src/cs_init.h b/fsw/src/cs_init.h index 0bbdcd5..217b7f5 100644 --- a/fsw/src/cs_init.h +++ b/fsw/src/cs_init.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * diff --git a/fsw/src/cs_memory_cmds.c b/fsw/src/cs_memory_cmds.c index 41a698d..107c363 100644 --- a/fsw/src/cs_memory_cmds.c +++ b/fsw/src/cs_memory_cmds.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -28,9 +27,9 @@ ** **************************************************************************/ #include "cfe.h" -#include "cs_tbldefs.h" +#include "cs_tbl.h" #include "cs_app.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_compute.h" #include "cs_memory_cmds.h" #include "cs_utils.h" @@ -46,22 +45,24 @@ /* CS Disable background checking of Memory command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_DisableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableMemoryCmd(const CS_DisableMemoryCmd_t *CmdPtr) { - if (CS_CheckRecomputeOneshot() == false) - { - CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_DISABLED; - CS_ZeroMemoryTempValues(); + if (CS_CheckRecomputeOneshot() == false) + { + CS_AppData.HkPacket.Payload.MemoryCSState = CS_ChecksumState_DISABLED; + CS_ZeroMemoryTempValues(); #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) - CS_UpdateCDS(); + CS_UpdateCDS(); #endif - CFE_EVS_SendEvent(CS_DISABLE_MEMORY_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of Memory is Disabled"); + CFE_EVS_SendEvent(CS_DISABLE_MEMORY_INF_EID, CFE_EVS_EventType_INFORMATION, + "Checksumming of Memory is Disabled"); - CS_AppData.HkPacket.Payload.CmdCounter++; - } + CS_AppData.HkPacket.Payload.CmdCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -69,21 +70,22 @@ void CS_DisableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Enable background checking of Memory command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_EnableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableMemoryCmd(const CS_EnableMemoryCmd_t *CmdPtr) { - if (CS_CheckRecomputeOneshot() == false) - { - CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_ENABLED; + if (CS_CheckRecomputeOneshot() == false) + { + CS_AppData.HkPacket.Payload.MemoryCSState = CS_ChecksumState_ENABLED; #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) - CS_UpdateCDS(); + CS_UpdateCDS(); #endif - CFE_EVS_SendEvent(CS_ENABLE_MEMORY_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of Memory is Enabled"); + CFE_EVS_SendEvent(CS_ENABLE_MEMORY_INF_EID, CFE_EVS_EventType_INFORMATION, "Checksumming of Memory is Enabled"); - CS_AppData.HkPacket.Payload.CmdCounter++; - } + CS_AppData.HkPacket.Payload.CmdCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -91,51 +93,51 @@ void CS_EnableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Report the baseline checksum of an entry in the Memory table */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_ReportBaselineEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_ReportBaselineEntryIDMemoryCmd(const CS_ReportBaselineEntryIDMemoryCmd_t *CmdPtr) { /* command verification variables */ - CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; - uint32 Baseline = 0; - uint16 EntryID = 0; - uint16 State = CS_STATE_EMPTY; - - EntryID = CmdPtr->Payload.EntryID; - - if ((EntryID < CS_MAX_NUM_MEMORY_TABLE_ENTRIES) && - (CS_AppData.ResMemoryTblPtr[EntryID].State != CS_STATE_EMPTY)) + CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; + uint32 Baseline = 0; + uint16 EntryID = 0; + CS_ChecksumState_Enum_t State = CS_ChecksumState_EMPTY; + + EntryID = CmdPtr->Payload.EntryID; + ResultsEntry = CS_GetMemoryResEntry(EntryID); + + if (ResultsEntry == NULL) + { + State = CS_ChecksumState_UNDEFINED; + } + else + { + State = ResultsEntry->State; + } + + if (CS_StateValid(State)) + { + if (ResultsEntry->ComputedYet == true) { - ResultsEntry = &CS_AppData.ResMemoryTblPtr[EntryID]; - - if (ResultsEntry->ComputedYet == true) - { - Baseline = ResultsEntry->ComparisonValue; + Baseline = ResultsEntry->ComparisonValue; - CFE_EVS_SendEvent(CS_BASELINE_MEMORY_INF_EID, CFE_EVS_EventType_INFORMATION, - "Report baseline of Memory Entry %d is 0x%08X", EntryID, (unsigned int)Baseline); - } - else - { - CFE_EVS_SendEvent(CS_NO_BASELINE_MEMORY_INF_EID, CFE_EVS_EventType_INFORMATION, - "Report baseline of Memory Entry %d has not been computed yet", EntryID); - } - CS_AppData.HkPacket.Payload.CmdCounter++; + CFE_EVS_SendEvent(CS_BASELINE_MEMORY_INF_EID, CFE_EVS_EventType_INFORMATION, + "Report baseline of Memory Entry %d is 0x%08X", EntryID, (unsigned int)Baseline); } else { - if (EntryID >= CS_MAX_NUM_MEMORY_TABLE_ENTRIES) - { - State = CS_STATE_UNDEFINED; - } - else - { - State = CS_AppData.ResMemoryTblPtr[EntryID].State; - } - - CFE_EVS_SendEvent(CS_BASELINE_INVALID_ENTRY_MEMORY_ERR_EID, CFE_EVS_EventType_ERROR, - "Memory report baseline failed, Entry ID invalid: %d, State: %d Max ID: %d", EntryID, - State, (CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1)); - CS_AppData.HkPacket.Payload.CmdErrCounter++; + CFE_EVS_SendEvent(CS_NO_BASELINE_MEMORY_INF_EID, CFE_EVS_EventType_INFORMATION, + "Report baseline of Memory Entry %d has not been computed yet", EntryID); } + CS_AppData.HkPacket.Payload.CmdCounter++; + } + else + { + CFE_EVS_SendEvent(CS_BASELINE_INVALID_ENTRY_MEMORY_ERR_EID, CFE_EVS_EventType_ERROR, + "Memory report baseline failed, Entry ID invalid: %d, State: %d Max ID: %d", EntryID, State, + (CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1)); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -143,76 +145,78 @@ void CS_ReportBaselineEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) /* CS Recompute the baseline of an entry in the Memory table cmd */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_RecomputeBaselineMemoryCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_RecomputeBaselineMemoryCmd(const CS_RecomputeBaselineMemoryCmd_t *CmdPtr) { /* command verification variables */ - CFE_ES_TaskId_t ChildTaskID = CFE_ES_TASKID_UNDEFINED; - CFE_Status_t Status = CS_ERROR; - uint16 EntryID = 0; - uint16 State = CS_STATE_EMPTY; + CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; + CFE_ES_TaskId_t ChildTaskID = CFE_ES_TASKID_UNDEFINED; + CFE_Status_t Status = CS_ERROR; + uint16 EntryID = 0; + CS_ChecksumState_Enum_t State = CS_ChecksumState_EMPTY; + + EntryID = CmdPtr->Payload.EntryID; + + if (CS_AppData.HkPacket.Payload.RecomputeInProgress == false && + CS_AppData.HkPacket.Payload.OneShotInProgress == false) + { + ResultsEntry = CS_GetMemoryResEntry(EntryID); - EntryID = CmdPtr->Payload.EntryID; + if (ResultsEntry == NULL) + { + State = CS_ChecksumState_UNDEFINED; + } + else + { + State = ResultsEntry->State; + } - if (CS_AppData.HkPacket.Payload.RecomputeInProgress == false && CS_AppData.HkPacket.Payload.OneShotInProgress == false) + if (CS_StateValid(State)) { - /* make sure the entry is a valid number and is defined in the table */ - if ((EntryID < CS_MAX_NUM_MEMORY_TABLE_ENTRIES) && - (CS_AppData.ResMemoryTblPtr[EntryID].State != CS_STATE_EMPTY)) + /* There is no child task running right now, we can use it*/ + CS_AppData.HkPacket.Payload.RecomputeInProgress = true; + + /* fill in child task variables */ + CS_AppData.ChildTaskTable = CS_ChecksumType_MEMORY_TABLE; + CS_AppData.ChildTaskEntryID = EntryID; + + CS_AppData.RecomputeEepromMemoryEntryPtr = ResultsEntry; + + Status = CFE_ES_CreateChildTask(&ChildTaskID, CS_RECOMP_MEMORY_TASK_NAME, CS_RecomputeEepromMemoryChildTask, + NULL, CFE_PLATFORM_ES_DEFAULT_STACK_SIZE, CS_CHILD_TASK_PRIORITY, 0); + if (Status == CFE_SUCCESS) { - /* There is no child task running right now, we can use it*/ - CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - - /* fill in child task variables */ - CS_AppData.ChildTaskTable = CS_MEMORY_TABLE; - CS_AppData.ChildTaskEntryID = EntryID; - - CS_AppData.RecomputeEepromMemoryEntryPtr = &CS_AppData.ResMemoryTblPtr[EntryID]; - - Status = - CFE_ES_CreateChildTask(&ChildTaskID, CS_RECOMP_MEMORY_TASK_NAME, CS_RecomputeEepromMemoryChildTask, - NULL, CFE_PLATFORM_ES_DEFAULT_STACK_SIZE, CS_CHILD_TASK_PRIORITY, 0); - if (Status == CFE_SUCCESS) - { - CFE_EVS_SendEvent(CS_RECOMPUTE_MEMORY_STARTED_DBG_EID, CFE_EVS_EventType_DEBUG, - "Recompute baseline of Memory Entry ID %d started", EntryID); - CS_AppData.HkPacket.Payload.CmdCounter++; - } - else /* child task creation failed */ - { - CFE_EVS_SendEvent( - CS_RECOMPUTE_MEMORY_CREATE_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, - "Recompute baseline of Memory Entry ID %d failed, ES_CreateChildTask returned: 0x%08X", - EntryID, (unsigned int)Status); - CS_AppData.HkPacket.Payload.CmdErrCounter++; - CS_AppData.HkPacket.Payload.RecomputeInProgress = false; - } + CFE_EVS_SendEvent(CS_RECOMPUTE_MEMORY_STARTED_DBG_EID, CFE_EVS_EventType_DEBUG, + "Recompute baseline of Memory Entry ID %d started", EntryID); + CS_AppData.HkPacket.Payload.CmdCounter++; } - else + else /* child task creation failed */ { - if (EntryID >= CS_MAX_NUM_MEMORY_TABLE_ENTRIES) - { - State = CS_STATE_UNDEFINED; - } - else - { - State = CS_AppData.ResMemoryTblPtr[EntryID].State; - } - CFE_EVS_SendEvent( - CS_RECOMPUTE_INVALID_ENTRY_MEMORY_ERR_EID, CFE_EVS_EventType_ERROR, - "Memory recompute baseline of entry failed, Entry ID invalid: %d, State: %d, Max ID: %d", EntryID, - State, (CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1)); - + CS_RECOMPUTE_MEMORY_CREATE_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, + "Recompute baseline of Memory Entry ID %d failed, ES_CreateChildTask returned: 0x%08X", EntryID, + (unsigned int)Status); CS_AppData.HkPacket.Payload.CmdErrCounter++; + CS_AppData.HkPacket.Payload.RecomputeInProgress = false; } } else { - /*send event that we can't start another task right now */ - CFE_EVS_SendEvent(CS_RECOMPUTE_MEMORY_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, - "Recompute baseline of Memory Entry ID %d failed: child task in use", EntryID); + CFE_EVS_SendEvent(CS_RECOMPUTE_INVALID_ENTRY_MEMORY_ERR_EID, CFE_EVS_EventType_ERROR, + "Memory recompute baseline of entry failed, Entry ID invalid: %d, State: %d, Max ID: %d", + EntryID, State, (CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1)); + CS_AppData.HkPacket.Payload.CmdErrCounter++; } + } + else + { + /*send event that we can't start another task right now */ + CFE_EVS_SendEvent(CS_RECOMPUTE_MEMORY_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, + "Recompute baseline of Memory Entry ID %d failed: child task in use", EntryID); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -220,59 +224,57 @@ void CS_RecomputeBaselineMemoryCmd(const CS_EntryCmd_t *CmdPtr) /* CS Enable a specific entry in the Memory table command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_EnableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_EnableEntryIDMemoryCmd(const CS_EnableEntryIDMemoryCmd_t *CmdPtr) { /* command verification variables */ - CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; - uint16 EntryID = 0; - uint16 State = CS_STATE_EMPTY; + CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; + CS_Def_EepromMemory_Table_Entry_t *DefEntry = NULL; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE]; + uint16 EntryID = 0; + CS_ChecksumState_Enum_t State = CS_ChecksumState_EMPTY; + + if (CS_CheckRecomputeOneshot() == false) + { + EntryID = CmdPtr->Payload.EntryID; + ResultsEntry = CS_GetMemoryResEntry(EntryID); + + if (ResultsEntry == NULL) + { + State = CS_ChecksumState_UNDEFINED; + } + else + { + State = ResultsEntry->State; + } - if (CS_CheckRecomputeOneshot() == false) + if (CS_StateValid(State)) { - EntryID = CmdPtr->Payload.EntryID; + DefEntry = CS_GetMemoryDefEntry(EntryID); + ResultsEntry->State = CS_ChecksumState_ENABLED; - if ((EntryID < CS_MAX_NUM_MEMORY_TABLE_ENTRIES) && - (CS_AppData.ResMemoryTblPtr[EntryID].State != CS_STATE_EMPTY)) - { - ResultsEntry = &CS_AppData.ResMemoryTblPtr[EntryID]; - - ResultsEntry->State = CS_STATE_ENABLED; - - CFE_EVS_SendEvent(CS_ENABLE_MEMORY_ENTRY_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of Memory Entry ID %d is Enabled", EntryID); - - if (CS_AppData.DefMemoryTblPtr[EntryID].State != CS_STATE_EMPTY) - { - CS_AppData.DefMemoryTblPtr[EntryID].State = CS_STATE_ENABLED; - CS_ResetTablesTblResultEntry(CS_AppData.MemResTablesTblPtr); - CFE_TBL_Modified(CS_AppData.DefMemoryTableHandle); - } - else - { - CFE_EVS_SendEvent(CS_ENABLE_MEMORY_DEF_EMPTY_DBG_EID, CFE_EVS_EventType_DEBUG, - "CS unable to update memory definition table for entry %d, State: %d", EntryID, - State); - } + CFE_EVS_SendEvent(CS_ENABLE_MEMORY_ENTRY_INF_EID, CFE_EVS_EventType_INFORMATION, + "Checksumming of Memory Entry ID %d is Enabled", EntryID); - CS_AppData.HkPacket.Payload.CmdCounter++; - } - else + State = CS_SetDefEntryState(tw, DefEntry, CS_ChecksumState_ENABLED); + if (!CS_StateValid(State)) { - if (EntryID >= CS_MAX_NUM_MEMORY_TABLE_ENTRIES) - { - State = CS_STATE_UNDEFINED; - } - else - { - State = CS_AppData.ResMemoryTblPtr[EntryID].State; - } - - CFE_EVS_SendEvent(CS_ENABLE_MEMORY_INVALID_ENTRY_ERR_EID, CFE_EVS_EventType_ERROR, - "Enable Memory entry failed, invalid Entry ID: %d, State: %d, Max ID: %d", EntryID, - State, (CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1)); - CS_AppData.HkPacket.Payload.CmdErrCounter++; + CFE_EVS_SendEvent(CS_ENABLE_MEMORY_DEF_EMPTY_DBG_EID, CFE_EVS_EventType_DEBUG, + "CS unable to update memory definition table for entry %d, State: %d", EntryID, + State); } - } /* end InProgress if */ + + CS_AppData.HkPacket.Payload.CmdCounter++; + } + else + { + CFE_EVS_SendEvent(CS_ENABLE_MEMORY_INVALID_ENTRY_ERR_EID, CFE_EVS_EventType_ERROR, + "Enable Memory entry failed, invalid Entry ID: %d, State: %d, Max ID: %d", EntryID, + State, (CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1)); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + } /* end InProgress if */ + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -280,62 +282,61 @@ void CS_EnableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) /* CS Disable a specific entry in the Memory table command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_DisableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_DisableEntryIDMemoryCmd(const CS_DisableEntryIDMemoryCmd_t *CmdPtr) { /* command verification variables */ - CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; - uint16 EntryID = 0; - uint16 State = CS_STATE_EMPTY; + CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; + CS_Def_EepromMemory_Table_Entry_t *DefEntry = NULL; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE]; + uint16 EntryID = 0; + CS_ChecksumState_Enum_t State = CS_ChecksumState_EMPTY; + + if (CS_CheckRecomputeOneshot() == false) + { + EntryID = CmdPtr->Payload.EntryID; + ResultsEntry = CS_GetMemoryResEntry(EntryID); + + if (ResultsEntry == NULL) + { + State = CS_ChecksumState_UNDEFINED; + } + else + { + State = ResultsEntry->State; + } - if (CS_CheckRecomputeOneshot() == false) + if (CS_StateValid(State)) { - EntryID = CmdPtr->Payload.EntryID; + DefEntry = CS_GetMemoryDefEntry(EntryID); - if ((EntryID < CS_MAX_NUM_MEMORY_TABLE_ENTRIES) && - (CS_AppData.ResMemoryTblPtr[EntryID].State != CS_STATE_EMPTY)) - { - ResultsEntry = &CS_AppData.ResMemoryTblPtr[EntryID]; - - ResultsEntry->State = CS_STATE_DISABLED; - ResultsEntry->TempChecksumValue = 0; - ResultsEntry->ByteOffset = 0; - - CFE_EVS_SendEvent(CS_DISABLE_MEMORY_ENTRY_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of Memory Entry ID %d is Disabled", EntryID); - - if (CS_AppData.DefMemoryTblPtr[EntryID].State != CS_STATE_EMPTY) - { - CS_AppData.DefMemoryTblPtr[EntryID].State = CS_STATE_DISABLED; - CS_ResetTablesTblResultEntry(CS_AppData.MemResTablesTblPtr); - CFE_TBL_Modified(CS_AppData.DefMemoryTableHandle); - } - else - { - CFE_EVS_SendEvent(CS_DISABLE_MEMORY_DEF_EMPTY_DBG_EID, CFE_EVS_EventType_DEBUG, - "CS unable to update memory definition table for entry %d, State: %d", EntryID, - State); - } + ResultsEntry->State = CS_ChecksumState_DISABLED; + ResultsEntry->TempChecksumValue = 0; + ResultsEntry->ByteOffset = 0; - CS_AppData.HkPacket.Payload.CmdCounter++; - } - else - { - if (EntryID >= CS_MAX_NUM_MEMORY_TABLE_ENTRIES) - { - State = CS_STATE_UNDEFINED; - } - else - { - State = CS_AppData.ResMemoryTblPtr[EntryID].State; - } - - CFE_EVS_SendEvent(CS_DISABLE_MEMORY_INVALID_ENTRY_ERR_EID, CFE_EVS_EventType_ERROR, - "Disable Memory entry failed, invalid Entry ID: %d, State: %d, Max ID: %d", EntryID, - State, (CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1)); + CFE_EVS_SendEvent(CS_DISABLE_MEMORY_ENTRY_INF_EID, CFE_EVS_EventType_INFORMATION, + "Checksumming of Memory Entry ID %d is Disabled", EntryID); - CS_AppData.HkPacket.Payload.CmdErrCounter++; + State = CS_SetDefEntryState(tw, DefEntry, CS_ChecksumState_DISABLED); + if (!CS_StateValid(State)) + { + CFE_EVS_SendEvent(CS_DISABLE_MEMORY_DEF_EMPTY_DBG_EID, CFE_EVS_EventType_DEBUG, + "CS unable to update memory definition table for entry %d, State: %d", EntryID, + State); } - } /* end InProgress if */ + + CS_AppData.HkPacket.Payload.CmdCounter++; + } + else + { + CFE_EVS_SendEvent(CS_DISABLE_MEMORY_INVALID_ENTRY_ERR_EID, CFE_EVS_EventType_ERROR, + "Disable Memory entry failed, invalid Entry ID: %d, State: %d, Max ID: %d", EntryID, + State, (CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1)); + + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + } /* end InProgress if */ + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -343,34 +344,40 @@ void CS_DisableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) /* CS Retrieve an EntryID based on Address from Memory table cmd */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_GetEntryIDMemoryCmd(const CS_GetEntryIDCmd_t *CmdPtr) +CFE_Status_t CS_GetEntryIDMemoryCmd(const CS_GetEntryIDMemoryCmd_t *CmdPtr) { /* command verification variables */ - CS_Res_EepromMemory_Table_Entry_t *StartOfResultsTable = NULL; - CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; - uint16 Loop = 0; - bool EntryFound = false; - - StartOfResultsTable = CS_AppData.ResMemoryTblPtr; - - for (Loop = 0; Loop < CS_MAX_NUM_MEMORY_TABLE_ENTRIES; Loop++) + CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; + uint16 Loop = 0; + bool EntryFound = false; + + Loop = 0; + while (true) + { + ResultsEntry = CS_GetMemoryResEntry(Loop); + if (ResultsEntry == NULL) { - ResultsEntry = &StartOfResultsTable[Loop]; - - if ((ResultsEntry->StartAddress <= CmdPtr->Payload.Address) && - CmdPtr->Payload.Address <= (ResultsEntry->StartAddress + ResultsEntry->NumBytesToChecksum) && - ResultsEntry->State != CS_STATE_EMPTY) - { - CFE_EVS_SendEvent(CS_GET_ENTRY_ID_MEMORY_INF_EID, CFE_EVS_EventType_INFORMATION, - "Memory Found Address 0x%08X in Entry ID %d", (unsigned int)(CmdPtr->Payload.Address), Loop); - EntryFound = true; - } + break; } - if (EntryFound == false) + if (ResultsEntry->State != CS_ChecksumState_EMPTY && ResultsEntry->StartAddress <= CmdPtr->Payload.Address && + CmdPtr->Payload.Address < (ResultsEntry->StartAddress + ResultsEntry->NumBytesToChecksum)) { - CFE_EVS_SendEvent(CS_GET_ENTRY_ID_MEMORY_NOT_FOUND_INF_EID, CFE_EVS_EventType_INFORMATION, - "Address 0x%08X was not found in Memory table", (unsigned int)(CmdPtr->Payload.Address)); + CFE_EVS_SendEvent(CS_GET_ENTRY_ID_MEMORY_INF_EID, CFE_EVS_EventType_INFORMATION, + "Memory Found Address 0x%08X in Entry ID %d", (unsigned int)(CmdPtr->Payload.Address), + Loop); + EntryFound = true; } - CS_AppData.HkPacket.Payload.CmdCounter++; + + ++Loop; + } + + if (EntryFound == false) + { + CFE_EVS_SendEvent(CS_GET_ENTRY_ID_MEMORY_NOT_FOUND_INF_EID, CFE_EVS_EventType_INFORMATION, + "Address 0x%08X was not found in Memory table", (unsigned int)(CmdPtr->Payload.Address)); + } + CS_AppData.HkPacket.Payload.CmdCounter++; + + return CFE_SUCCESS; } diff --git a/fsw/src/cs_memory_cmds.h b/fsw/src/cs_memory_cmds.h index f8ec7d7..91d949a 100644 --- a/fsw/src/cs_memory_cmds.h +++ b/fsw/src/cs_memory_cmds.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -49,7 +48,7 @@ * * \sa #CS_DISABLE_MEMORY_CC */ -void CS_DisableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_DisableMemoryCmd(const CS_DisableMemoryCmd_t *CmdPtr); /** * \brief Process an enable background checking for the Memory @@ -68,7 +67,7 @@ void CS_DisableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_ENABLE_MEMORY_CC */ -void CS_EnableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_EnableMemoryCmd(const CS_EnableMemoryCmd_t *CmdPtr); /** * \brief Proccess a report baseline of a Memory Entry command @@ -82,9 +81,9 @@ void CS_EnableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr); * * \param[in] CmdPtr Command pointer, verified non-null in CS_AppMain * - * \sa #CS_REPORT_BASELINE_MEMORY_CC + * \sa #CS_REPORT_BASELINE_ENTRY_ID_MEMORY_CC */ -void CS_ReportBaselineEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr); +CFE_Status_t CS_ReportBaselineEntryIDMemoryCmd(const CS_ReportBaselineEntryIDMemoryCmd_t *CmdPtr); /** * \brief Process a disable background checking for a Memory @@ -105,9 +104,9 @@ void CS_ReportBaselineEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr); * * \param[in] CmdPtr Command pointer, verified non-null in CS_AppMain * - * \sa #CS_DISABLE_ENTRY_MEMORY_CC + * \sa #CS_DISABLE_ENTRY_ID_MEMORY_CC */ -void CS_DisableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr); +CFE_Status_t CS_DisableEntryIDMemoryCmd(const CS_DisableEntryIDMemoryCmd_t *CmdPtr); /** * \brief Process a recopmute baseline of a Memory table entry command @@ -123,7 +122,7 @@ void CS_DisableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr); * * \sa #CS_RECOMPUTE_BASELINE_MEMORY_CC */ -void CS_RecomputeBaselineMemoryCmd(const CS_EntryCmd_t *CmdPtr); +CFE_Status_t CS_RecomputeBaselineMemoryCmd(const CS_RecomputeBaselineMemoryCmd_t *CmdPtr); /** * \brief Process an enable background checking for a Memory @@ -144,9 +143,9 @@ void CS_RecomputeBaselineMemoryCmd(const CS_EntryCmd_t *CmdPtr); * * \param[in] CmdPtr Command pointer, verified non-null in CS_AppMain * - * \sa #CS_ENABLE_ENTRY_MEMORY_CC + * \sa #CS_ENABLE_ENTRY_ID_MEMORY_CC */ -void CS_EnableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr); +CFE_Status_t CS_EnableEntryIDMemoryCmd(const CS_EnableEntryIDMemoryCmd_t *CmdPtr); /** * \brief Process a get Memory Entry by Address command @@ -162,6 +161,6 @@ void CS_EnableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr); * * \sa #CS_GET_ENTRY_ID_MEMORY_CC */ -void CS_GetEntryIDMemoryCmd(const CS_GetEntryIDCmd_t *CmdPtr); +CFE_Status_t CS_GetEntryIDMemoryCmd(const CS_GetEntryIDMemoryCmd_t *CmdPtr); #endif diff --git a/fsw/src/cs_table_cmds.c b/fsw/src/cs_table_cmds.c index 80e3112..3666f80 100644 --- a/fsw/src/cs_table_cmds.c +++ b/fsw/src/cs_table_cmds.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -29,7 +28,7 @@ **************************************************************************/ #include "cfe.h" #include "cs_app.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_utils.h" #include "cs_compute.h" #include "cs_table_cmds.h" @@ -44,21 +43,23 @@ /* CS Disable background checking of Tables command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_DisableTablesCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableTablesCmd(const CS_DisableTablesCmd_t *CmdPtr) { - if (CS_CheckRecomputeOneshot() == false) - { - CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_DISABLED; - CS_ZeroTablesTempValues(); + if (CS_CheckRecomputeOneshot() == false) + { + CS_AppData.HkPacket.Payload.TablesCSState = CS_ChecksumState_DISABLED; + CS_ZeroTablesTempValues(); #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) - CS_UpdateCDS(); + CS_UpdateCDS(); #endif - CFE_EVS_SendEvent(CS_DISABLE_TABLES_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of Tables is Disabled"); - CS_AppData.HkPacket.Payload.CmdCounter++; - } + CFE_EVS_SendEvent(CS_DISABLE_TABLES_INF_EID, CFE_EVS_EventType_INFORMATION, + "Checksumming of Tables is Disabled"); + CS_AppData.HkPacket.Payload.CmdCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -66,20 +67,21 @@ void CS_DisableTablesCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Enable background checking of Tables command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_EnableTablesCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableTablesCmd(const CS_EnableTablesCmd_t *CmdPtr) { - if (CS_CheckRecomputeOneshot() == false) - { - CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_ENABLED; + if (CS_CheckRecomputeOneshot() == false) + { + CS_AppData.HkPacket.Payload.TablesCSState = CS_ChecksumState_ENABLED; #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) - CS_UpdateCDS(); + CS_UpdateCDS(); #endif - CFE_EVS_SendEvent(CS_ENABLE_TABLES_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of Tables is Enabled"); - CS_AppData.HkPacket.Payload.CmdCounter++; - } + CFE_EVS_SendEvent(CS_ENABLE_TABLES_INF_EID, CFE_EVS_EventType_INFORMATION, "Checksumming of Tables is Enabled"); + CS_AppData.HkPacket.Payload.CmdCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -87,36 +89,38 @@ void CS_EnableTablesCmd(const CS_NoArgsCmd_t *CmdPtr) /* CS Report the baseline checksum of an entry in the Tables table */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_ReportBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr) +CFE_Status_t CS_ReportBaselineTableCmd(const CS_ReportBaselineTableCmd_t *CmdPtr) { CS_Res_Tables_Table_Entry_t *ResultsEntry; uint32 Baseline; char Name[CFE_TBL_MAX_FULL_NAME_LEN]; - strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); - Name[sizeof(Name) - 1] = '\0'; + strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); + Name[sizeof(Name) - 1] = '\0'; - if (CS_GetTableResTblEntryByName(&ResultsEntry, Name)) + if (CS_GetTableResTblEntryByName(&ResultsEntry, Name)) + { + if (ResultsEntry->ComputedYet == true) { - if (ResultsEntry->ComputedYet == true) - { - Baseline = ResultsEntry->ComparisonValue; - CFE_EVS_SendEvent(CS_BASELINE_TABLES_INF_EID, CFE_EVS_EventType_INFORMATION, - "Report baseline of table %s is 0x%08X", Name, (unsigned int)Baseline); - } - else - { - CFE_EVS_SendEvent(CS_NO_BASELINE_TABLES_INF_EID, CFE_EVS_EventType_INFORMATION, - "Report baseline of table %s has not been computed yet", Name); - } - CS_AppData.HkPacket.Payload.CmdCounter++; + Baseline = ResultsEntry->ComparisonValue; + CFE_EVS_SendEvent(CS_BASELINE_TABLE_INF_EID, CFE_EVS_EventType_INFORMATION, + "Report baseline of table %s is 0x%08X", Name, (unsigned int)Baseline); } else { - CFE_EVS_SendEvent(CS_BASELINE_INVALID_NAME_TABLES_ERR_EID, CFE_EVS_EventType_ERROR, - "Tables report baseline failed, table %s not found", Name); - CS_AppData.HkPacket.Payload.CmdErrCounter++; + CFE_EVS_SendEvent(CS_NO_BASELINE_TABLE_INF_EID, CFE_EVS_EventType_INFORMATION, + "Report baseline of table %s has not been computed yet", Name); } + CS_AppData.HkPacket.Payload.CmdCounter++; + } + else + { + CFE_EVS_SendEvent(CS_BASELINE_INVALID_NAME_TABLES_ERR_EID, CFE_EVS_EventType_ERROR, + "Tables report baseline failed, table %s not found", Name); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -124,60 +128,63 @@ void CS_ReportBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr) /* CS Recompute the baseline of an entry in the Tables table cmd */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_RecomputeBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr) +CFE_Status_t CS_RecomputeBaselineTableCmd(const CS_RecomputeBaselineTableCmd_t *CmdPtr) { CFE_ES_TaskId_t ChildTaskID; CFE_Status_t Status; CS_Res_Tables_Table_Entry_t *ResultsEntry; char Name[CFE_TBL_MAX_FULL_NAME_LEN]; - if (CS_AppData.HkPacket.Payload.RecomputeInProgress == false && CS_AppData.HkPacket.Payload.OneShotInProgress == false) + if (CS_AppData.HkPacket.Payload.RecomputeInProgress == false && + CS_AppData.HkPacket.Payload.OneShotInProgress == false) + { + strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); + Name[sizeof(Name) - 1] = '\0'; + + /* make sure the entry is a valid number and is defined in the table */ + if (CS_GetTableResTblEntryByName(&ResultsEntry, Name)) { - strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); - Name[sizeof(Name) - 1] = '\0'; + /* There is no child task running right now, we can use it*/ + CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - /* make sure the entry is a valid number and is defined in the table */ - if (CS_GetTableResTblEntryByName(&ResultsEntry, Name)) + /* fill in child task variables */ + CS_AppData.ChildTaskTable = CS_ChecksumType_TABLES_TABLE; + + CS_AppData.RecomputeTablesEntryPtr = ResultsEntry; + + Status = CFE_ES_CreateChildTask(&ChildTaskID, CS_RECOMP_TABLES_TASK_NAME, CS_RecomputeTablesChildTask, NULL, + CFE_PLATFORM_ES_DEFAULT_STACK_SIZE, CS_CHILD_TASK_PRIORITY, 0); + if (Status == CFE_SUCCESS) { - /* There is no child task running right now, we can use it*/ - CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - - /* fill in child task variables */ - CS_AppData.ChildTaskTable = CS_TABLES_TABLE; - - CS_AppData.RecomputeTablesEntryPtr = ResultsEntry; - - Status = CFE_ES_CreateChildTask(&ChildTaskID, CS_RECOMP_TABLES_TASK_NAME, CS_RecomputeTablesChildTask, - NULL, CFE_PLATFORM_ES_DEFAULT_STACK_SIZE, CS_CHILD_TASK_PRIORITY, 0); - if (Status == CFE_SUCCESS) - { - CFE_EVS_SendEvent(CS_RECOMPUTE_TABLES_STARTED_DBG_EID, CFE_EVS_EventType_DEBUG, - "Recompute baseline of table %s started", Name); - CS_AppData.HkPacket.Payload.CmdCounter++; - } - else /* child task creation failed */ - { - CFE_EVS_SendEvent(CS_RECOMPUTE_TABLES_CREATE_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, - "Recompute baseline of table %s failed, CFE_ES_CreateChildTask returned: 0x%08X", - Name, (unsigned int)Status); - CS_AppData.HkPacket.Payload.CmdErrCounter++; - CS_AppData.HkPacket.Payload.RecomputeInProgress = false; - } + CFE_EVS_SendEvent(CS_RECOMPUTE_TABLES_STARTED_DBG_EID, CFE_EVS_EventType_DEBUG, + "Recompute baseline of table %s started", Name); + CS_AppData.HkPacket.Payload.CmdCounter++; } - else + else /* child task creation failed */ { - CFE_EVS_SendEvent(CS_RECOMPUTE_UNKNOWN_NAME_TABLES_ERR_EID, CFE_EVS_EventType_ERROR, - "Tables recompute baseline failed, table %s not found", Name); + CFE_EVS_SendEvent(CS_RECOMPUTE_TABLES_CREATE_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, + "Recompute baseline of table %s failed, CFE_ES_CreateChildTask returned: 0x%08X", + Name, (unsigned int)Status); CS_AppData.HkPacket.Payload.CmdErrCounter++; + CS_AppData.HkPacket.Payload.RecomputeInProgress = false; } } else { - /*send event that we can't start another task right now */ - CFE_EVS_SendEvent(CS_RECOMPUTE_TABLES_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, - "Tables recompute baseline for table %s failed: child task in use", Name); + CFE_EVS_SendEvent(CS_RECOMPUTE_UNKNOWN_NAME_TABLES_ERR_EID, CFE_EVS_EventType_ERROR, + "Tables recompute baseline failed, table %s not found", Name); CS_AppData.HkPacket.Payload.CmdErrCounter++; } + } + else + { + /*send event that we can't start another task right now */ + CFE_EVS_SendEvent(CS_RECOMPUTE_TABLES_CHDTASK_ERR_EID, CFE_EVS_EventType_ERROR, + "Tables recompute baseline for table %s failed: child task in use", Name); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -185,47 +192,48 @@ void CS_RecomputeBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr) /* CS Disable a specific entry in the Tables table command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_DisableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr) +CFE_Status_t CS_DisableNameTableCmd(const CS_DisableNameTableCmd_t *CmdPtr) { CS_Res_Tables_Table_Entry_t *ResultsEntry; CS_Def_Tables_Table_Entry_t *DefinitionEntry; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE]; char Name[CFE_TBL_MAX_FULL_NAME_LEN]; - if (CS_CheckRecomputeOneshot() == false) + if (CS_CheckRecomputeOneshot() == false) + { + strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); + Name[sizeof(Name) - 1] = '\0'; + + if (CS_GetTableResTblEntryByName(&ResultsEntry, Name)) { - strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); - Name[sizeof(Name) - 1] = '\0'; + ResultsEntry->State = CS_ChecksumState_DISABLED; + ResultsEntry->TempChecksumValue = 0; + ResultsEntry->ByteOffset = 0; - if (CS_GetTableResTblEntryByName(&ResultsEntry, Name)) - { - ResultsEntry->State = CS_STATE_DISABLED; - ResultsEntry->TempChecksumValue = 0; - ResultsEntry->ByteOffset = 0; - - CFE_EVS_SendEvent(CS_DISABLE_TABLES_NAME_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of table %s is Disabled", Name); - - if (CS_GetTableDefTblEntryByName(&DefinitionEntry, Name)) - { - DefinitionEntry->State = CS_STATE_DISABLED; - CS_ResetTablesTblResultEntry(CS_AppData.TblResTablesTblPtr); - CFE_TBL_Modified(CS_AppData.DefTablesTableHandle); - } - else - { - CFE_EVS_SendEvent(CS_DISABLE_TABLE_DEF_NOT_FOUND_DBG_EID, CFE_EVS_EventType_DEBUG, - "CS unable to update tables definition table for entry %s", Name); - } + CFE_EVS_SendEvent(CS_DISABLE_TABLES_NAME_INF_EID, CFE_EVS_EventType_INFORMATION, + "Checksumming of table %s is Disabled", Name); - CS_AppData.HkPacket.Payload.CmdCounter++; + if (CS_GetTableDefTblEntryByName(&DefinitionEntry, Name)) + { + CS_SetDefEntryState(tw, DefinitionEntry, CS_ChecksumState_DISABLED); } else { - CFE_EVS_SendEvent(CS_DISABLE_TABLES_UNKNOWN_NAME_ERR_EID, CFE_EVS_EventType_ERROR, - "Tables disable table command failed, table %s not found", Name); - CS_AppData.HkPacket.Payload.CmdErrCounter++; + CFE_EVS_SendEvent(CS_DISABLE_TABLE_DEF_NOT_FOUND_DBG_EID, CFE_EVS_EventType_DEBUG, + "CS unable to update tables definition table for entry %s", Name); } - } /* end InProgress if */ + + CS_AppData.HkPacket.Payload.CmdCounter++; + } + else + { + CFE_EVS_SendEvent(CS_DISABLE_TABLES_UNKNOWN_NAME_ERR_EID, CFE_EVS_EventType_ERROR, + "Tables disable table command failed, table %s not found", Name); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + } /* end InProgress if */ + + return CFE_SUCCESS; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -233,43 +241,44 @@ void CS_DisableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr) /* CS Enable a specific entry in the Tables table command */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_EnableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr) +CFE_Status_t CS_EnableNameTableCmd(const CS_EnableNameTableCmd_t *CmdPtr) { CS_Res_Tables_Table_Entry_t *ResultsEntry; CS_Def_Tables_Table_Entry_t *DefinitionEntry; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE]; char Name[CFE_TBL_MAX_FULL_NAME_LEN]; - if (CS_CheckRecomputeOneshot() == false) + if (CS_CheckRecomputeOneshot() == false) + { + strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); + Name[sizeof(Name) - 1] = '\0'; + + if (CS_GetTableResTblEntryByName(&ResultsEntry, Name)) { - strncpy(Name, CmdPtr->Payload.Name, sizeof(Name) - 1); - Name[sizeof(Name) - 1] = '\0'; + ResultsEntry->State = CS_ChecksumState_ENABLED; - if (CS_GetTableResTblEntryByName(&ResultsEntry, Name)) - { - ResultsEntry->State = CS_STATE_ENABLED; - - CFE_EVS_SendEvent(CS_ENABLE_TABLES_NAME_INF_EID, CFE_EVS_EventType_INFORMATION, - "Checksumming of table %s is Enabled", Name); - - if (CS_GetTableDefTblEntryByName(&DefinitionEntry, Name)) - { - DefinitionEntry->State = CS_STATE_ENABLED; - CS_ResetTablesTblResultEntry(CS_AppData.TblResTablesTblPtr); - CFE_TBL_Modified(CS_AppData.DefTablesTableHandle); - } - else - { - CFE_EVS_SendEvent(CS_ENABLE_TABLE_DEF_NOT_FOUND_DBG_EID, CFE_EVS_EventType_DEBUG, - "CS unable to update tables definition table for entry %s", Name); - } + CFE_EVS_SendEvent(CS_ENABLE_TABLES_NAME_INF_EID, CFE_EVS_EventType_INFORMATION, + "Checksumming of table %s is Enabled", Name); - CS_AppData.HkPacket.Payload.CmdCounter++; + if (CS_GetTableDefTblEntryByName(&DefinitionEntry, Name)) + { + CS_SetDefEntryState(tw, DefinitionEntry, CS_ChecksumState_ENABLED); } else { - CFE_EVS_SendEvent(CS_ENABLE_TABLES_UNKNOWN_NAME_ERR_EID, CFE_EVS_EventType_ERROR, - "Tables enable table command failed, table %s not found", Name); - CS_AppData.HkPacket.Payload.CmdErrCounter++; + CFE_EVS_SendEvent(CS_ENABLE_TABLE_DEF_NOT_FOUND_DBG_EID, CFE_EVS_EventType_DEBUG, + "CS unable to update tables definition table for entry %s", Name); } - } /* end InProgress if */ + + CS_AppData.HkPacket.Payload.CmdCounter++; + } + else + { + CFE_EVS_SendEvent(CS_ENABLE_TABLES_UNKNOWN_NAME_ERR_EID, CFE_EVS_EventType_ERROR, + "Tables enable table command failed, table %s not found", Name); + CS_AppData.HkPacket.Payload.CmdErrCounter++; + } + } /* end InProgress if */ + + return CFE_SUCCESS; } diff --git a/fsw/src/cs_table_cmds.h b/fsw/src/cs_table_cmds.h index 2b23599..3662cea 100644 --- a/fsw/src/cs_table_cmds.h +++ b/fsw/src/cs_table_cmds.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -49,7 +48,7 @@ * * \sa #CS_DISABLE_TABLES_CC */ -void CS_DisableTablesCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_DisableTablesCmd(const CS_DisableTablesCmd_t *CmdPtr); /** * \brief Process an enable background checking for the Tables @@ -68,7 +67,7 @@ void CS_DisableTablesCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_ENABLE_TABLES_CC */ -void CS_EnableTablesCmd(const CS_NoArgsCmd_t *CmdPtr); +CFE_Status_t CS_EnableTablesCmd(const CS_EnableTablesCmd_t *CmdPtr); /** * \brief Proccess a report baseline of a Table command @@ -84,7 +83,7 @@ void CS_EnableTablesCmd(const CS_NoArgsCmd_t *CmdPtr); * * \sa #CS_REPORT_BASELINE_TABLE_CC */ -void CS_ReportBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr); +CFE_Status_t CS_ReportBaselineTableCmd(const CS_ReportBaselineTableCmd_t *CmdPtr); /** * \brief Process a recompute baseline of a Table command @@ -100,7 +99,7 @@ void CS_ReportBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr); * * \sa #CS_RECOMPUTE_BASELINE_TABLE_CC */ -void CS_RecomputeBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr); +CFE_Status_t CS_RecomputeBaselineTableCmd(const CS_RecomputeBaselineTableCmd_t *CmdPtr); /** * \brief Process a disable background checking for a Table @@ -123,7 +122,7 @@ void CS_RecomputeBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr); * * \sa #CS_DISABLE_NAME_TABLE_CC */ -void CS_DisableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr); +CFE_Status_t CS_DisableNameTableCmd(const CS_DisableNameTableCmd_t *CmdPtr); /** * \brief Process an enable background checking for a Table @@ -146,6 +145,6 @@ void CS_DisableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr); * * \sa #CS_ENABLE_NAME_TABLE_CC */ -void CS_EnableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr); +CFE_Status_t CS_EnableNameTableCmd(const CS_EnableNameTableCmd_t *CmdPtr); #endif diff --git a/fsw/src/cs_table_processing.c b/fsw/src/cs_table_processing.c index aad5849..e021a3a 100644 --- a/fsw/src/cs_table_processing.c +++ b/fsw/src/cs_table_processing.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -29,206 +28,362 @@ **************************************************************************/ #include "cfe.h" #include "cs_app.h" -#include "cs_events.h" -#include "cs_tbldefs.h" +#include "cs_eventids.h" +#include "cs_tbl.h" #include "cs_utils.h" #include "cs_table_processing.h" #include +/* Errors that may be detected by table validation */ +typedef enum CS_ValidationError +{ + CS_ValidationError_NONE, /* keep first, should be 0 */ + + CS_ValidationError_LONG_NAME, + CS_ValidationError_STATE, + CS_ValidationError_ZERO_NAME, + CS_ValidationError_DUPLICATE, + CS_ValidationError_MEM_RANGE, + + CS_ValidationError_MAX /* keep last, indicates number of entries */ + +} CS_ValidationError_t; + +/* + * Helper struct to keep state of table validation + * This allows app, table, memory, and eeprom table validation to + * share common counting and reporting logic to keep things consistent. + */ +typedef struct CS_ValidationMetrics +{ + const char * TableName; + const uint16 *EventMap; + + uint16 Position; + uint16 StateField; + + CS_ValidationError_t PendingError; + char ErrorMessage[CFE_TBL_MAX_FULL_NAME_LEN]; /* Long enough to hold a table name, if needed */ + + int32 GoodCount; + int32 BadCount; + int32 EmptyCount; +} CS_ValidationMetrics_t; + /************************************************************************* ** - ** Local function prototypes + ** Function Definitions ** **************************************************************************/ -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -/* */ -/* Call respective table update handler function (helper) */ -/* */ -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_CallTableUpdateHandler(uint32 Table, const void *DefinitionPtr, void *ResultsPtr, size_t NumEntries) +/*---------------------------------------------------------------- + * + * Local helper function + * Checks if the overall validation is OK so far + * + *-----------------------------------------------------------------*/ +static inline bool CS_ValidationMetrics_IsAllOK(const CS_ValidationMetrics_t *Metrics) +{ + return (Metrics->BadCount == 0); +} + +/*---------------------------------------------------------------- + * + * Local helper function + * Checks if the current entry is OK + * + *-----------------------------------------------------------------*/ +static inline bool CS_ValidationMetrics_IsCurrentOK(const CS_ValidationMetrics_t *Metrics) +{ + return (Metrics->PendingError == CS_ValidationError_NONE); +} + +/*---------------------------------------------------------------- + * + * Local helper function + * Starts checking an entry, checks that the state is valid + * + *-----------------------------------------------------------------*/ +void CS_ValidationMetrics_StartNext(CS_ValidationMetrics_t *Metrics, uint16 EntryState) +{ + Metrics->StateField = EntryState; + Metrics->ErrorMessage[0] = 0; + + if (!CS_StateValid(EntryState) && EntryState != CS_ChecksumState_EMPTY) + { + /* The state field is not one of the valid values */ + Metrics->PendingError = CS_ValidationError_STATE; + } + else + { + Metrics->PendingError = CS_ValidationError_NONE; + } +} + +/*---------------------------------------------------------------- + * + * Local helper function + * Reports an error event associated with table validation + * + *-----------------------------------------------------------------*/ +void CS_ValidationMetrics_ReportEvent(CS_ValidationMetrics_t *Metrics) { - switch (Table) + uint16 PendingEventId; + + PendingEventId = Metrics->EventMap[Metrics->PendingError]; + switch (Metrics->PendingError) { - case CS_APP_TABLE: - CS_ProcessNewAppDefinitionTable(DefinitionPtr, ResultsPtr); + case CS_ValidationError_STATE: + default: + CFE_EVS_SendEvent(PendingEventId, CFE_EVS_EventType_ERROR, + "%s Table Validate: Illegal State Field (0x%04X) found in Entry ID %d", + Metrics->TableName, (unsigned short)Metrics->StateField, (int)Metrics->Position); + break; + + case CS_ValidationError_LONG_NAME: + CFE_EVS_SendEvent(PendingEventId, CFE_EVS_EventType_ERROR, + "%s Table Validate: Unterminated Name found at entry %d", Metrics->TableName, + (int)Metrics->Position); break; - case CS_TABLES_TABLE: - CS_ProcessNewTablesDefinitionTable(DefinitionPtr, ResultsPtr); + + case CS_ValidationError_ZERO_NAME: + CFE_EVS_SendEvent(PendingEventId, CFE_EVS_EventType_ERROR, + "%s Table Validate: Illegal State (0x%04X) with empty name at entry %d", + Metrics->TableName, (unsigned short)Metrics->StateField, (int)Metrics->Position); break; - case CS_EEPROM_TABLE: - case CS_MEMORY_TABLE: - CS_ProcessNewEepromMemoryDefinitionTable(DefinitionPtr, ResultsPtr, NumEntries, Table); + + case CS_ValidationError_DUPLICATE: + CFE_EVS_SendEvent(PendingEventId, CFE_EVS_EventType_ERROR, + "%s Table Validate: Duplicate Name (%s) found at entry %d", Metrics->TableName, + Metrics->ErrorMessage, (int)Metrics->Position); break; - default: - /* no defined handler */ + + case CS_ValidationError_MEM_RANGE: + CFE_EVS_SendEvent(PendingEventId, CFE_EVS_EventType_ERROR, + "%s Table Validate: Illegal MemRange in Entry ID %d, " + "CFE_PSP_MemValidateRange: %s", + Metrics->TableName, (int)Metrics->Position, Metrics->ErrorMessage); break; } } -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -/* */ -/* CS Validation Callback function for EEPROM Table */ -/* */ -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -CFE_Status_t CS_ValidateEepromChecksumDefinitionTable(void *TblPtr) +/*---------------------------------------------------------------- + * + * Local helper function + * Accumulate table validation counters + * + *-----------------------------------------------------------------*/ +void CS_ValidationMetrics_Accumulate(CS_ValidationMetrics_t *Metrics) +{ + /* increment the respective counter for final report */ + if (!CS_ValidationMetrics_IsCurrentOK(Metrics)) + { + /* Only do event report on the first error */ + if (CS_ValidationMetrics_IsAllOK(Metrics)) + { + CS_ValidationMetrics_ReportEvent(Metrics); + } + + ++Metrics->BadCount; + } + else if (Metrics->StateField == CS_ChecksumState_EMPTY) + { + ++Metrics->EmptyCount; + } + else + { + ++Metrics->GoodCount; + } + + ++Metrics->Position; +} + +/*---------------------------------------------------------------- + * + * Local helper function + * Gets the final status of the table validation and report INFO event + * + *-----------------------------------------------------------------*/ +int32 CS_ValidationMetrics_GetFinalStatus(const CS_ValidationMetrics_t *Metrics) { - CFE_Status_t Result = CFE_SUCCESS; - CFE_Status_t Status = OS_ERROR; - CS_Def_EepromMemory_Table_Entry_t *StartOfTable = NULL; - CS_Def_EepromMemory_Table_Entry_t *OuterEntry = NULL; - int32 OuterLoop = 0; - uint32 StateField = 0; - cpuaddr Address = 0; - uint32 Size = 0; - int32 GoodCount = 0; - int32 BadCount = 0; - int32 EmptyCount = 0; + CFE_EVS_SendEvent(Metrics->EventMap[0], CFE_EVS_EventType_INFORMATION, + "CS %s Table verification results: good = %d, bad = %d, unused = %d", Metrics->TableName, + (int)Metrics->GoodCount, (int)Metrics->BadCount, (int)Metrics->EmptyCount); - StartOfTable = (CS_Def_EepromMemory_Table_Entry_t *)TblPtr; + if (CS_ValidationMetrics_IsAllOK(Metrics)) + { + return CFE_SUCCESS; + } + else + { + return CS_TABLE_ERROR; + } +} - for (OuterLoop = 0; OuterLoop < CS_MAX_NUM_EEPROM_TABLE_ENTRIES; OuterLoop++) +/*---------------------------------------------------------------- + * + * Local helper function + * Call respective table update handler + * + *-----------------------------------------------------------------*/ +void CS_CallTableUpdateHandler(CS_TableWrapper_t *tw) +{ + if (tw->UpdateHandler) { - OuterEntry = &StartOfTable[OuterLoop]; + tw->UpdateHandler(tw); + } +} + +/*---------------------------------------------------------------- + * + * Local helper function + * Checks for duplicate name enty in table + * + *-----------------------------------------------------------------*/ +void CS_CheckForDuplicateEntry(CS_ValidationMetrics_t *Metrics, const char *RefName, size_t EntrySize) +{ + const char *EntryName; + uint16 Count; + + EntryName = RefName; + Count = Metrics->Position; - StateField = OuterEntry->State; - Address = OuterEntry->StartAddress; - Size = OuterEntry->NumBytesToChecksum; + while (Count > 0) + { + --Count; + EntryName -= EntrySize; - if ((StateField == CS_STATE_EMPTY) || (StateField == CS_STATE_ENABLED) || (StateField == CS_STATE_DISABLED)) + if (strcmp(RefName, EntryName) == 0) { - /* If the StateField is within this range, it's check if it's not empty. */ - if (StateField == CS_STATE_DISABLED || StateField == CS_STATE_ENABLED) - { - Status = CFE_PSP_MemValidateRange(Address, Size, CFE_PSP_MEM_EEPROM); - if (Status != OS_SUCCESS) - { - BadCount++; - if (Result != CS_TABLE_ERROR) - { - CFE_EVS_SendEvent(CS_VAL_EEPROM_RANGE_ERR_EID, CFE_EVS_EventType_ERROR, - "EEPROM Table Validate: Illegal checksum range found in Entry ID %d, " - "CFE_PSP_MemValidateRange returned: 0x%08X", - (int)OuterLoop, (unsigned int)Status); - Result = CS_TABLE_ERROR; - } - } - else - { - /* Valid range for non-empty entry */ - GoodCount++; - } - } - else - { - /* Entry is marked as empty */ - EmptyCount++; - } + Metrics->PendingError = CS_ValidationError_DUPLICATE; + snprintf(Metrics->ErrorMessage, sizeof(Metrics->ErrorMessage), "position=%d", (int)Count); + break; } - else + } +} + +/*---------------------------------------------------------------- + * + * Local helper function + * Checks sanity of entry name + * + *-----------------------------------------------------------------*/ +void CS_ValidateEntryName(CS_ValidationMetrics_t *Metrics, const char *NameField, size_t NameSize) +{ + if (CS_StateValid(Metrics->StateField)) + { + if (memchr(NameField, 0, NameSize) == NULL) { - /* Invalid state definition */ - BadCount++; - if (Result != CS_TABLE_ERROR) - { - CFE_EVS_SendEvent(CS_VAL_EEPROM_STATE_ERR_EID, CFE_EVS_EventType_ERROR, - "EEPROM Table Validate: Illegal State Field (0x%04X) found in Entry ID %d", - (unsigned short)StateField, (int)OuterLoop); - Result = CS_TABLE_ERROR; - } + /* Not null-terminated, name is too long */ + Metrics->PendingError = CS_ValidationError_LONG_NAME; + } + else if (NameField[0] == 0) + { + /* non-empty entries MUST have a name */ + Metrics->PendingError = CS_ValidationError_ZERO_NAME; } - } /* for (OuterLoop = 0; OuterLoop < CS_MAX_NUM_EEPROM_TABLE_ENTRIES; OuterLoop++) */ + } + else if (NameField[0] != 0) + { + /* empty entries must NOT have a name */ + Metrics->PendingError = CS_ValidationError_STATE; + } +} - CFE_EVS_SendEvent(CS_VAL_EEPROM_INF_EID, CFE_EVS_EventType_INFORMATION, - "CS EEPROM Table verification results: good = %d, bad = %d, unused = %d", (int)GoodCount, - (int)BadCount, (int)EmptyCount); +/*---------------------------------------------------------------- + * + * Local helper function + * Checks sanity of entry address + * + *-----------------------------------------------------------------*/ +void CS_ValidateEntryAddress(CS_ValidationMetrics_t *Metrics, cpuaddr MemoryAddr, size_t MemorySize, uint32 MemoryType) +{ + int32 PspStatus; - return Result; + if (CS_StateValid(Metrics->StateField)) + { + PspStatus = CFE_PSP_MemValidateRange(MemoryAddr, MemorySize, MemoryType); + if (PspStatus != CFE_PSP_SUCCESS) + { + Metrics->PendingError = CS_ValidationError_MEM_RANGE; + snprintf(Metrics->ErrorMessage, sizeof(Metrics->ErrorMessage), "status=%d", (int)PspStatus); + } + } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ -/* CS Validation Callback function for Memory Table */ +/* CS Validation Callback function for EEPROM Table */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -CFE_Status_t CS_ValidateMemoryChecksumDefinitionTable(void *TblPtr) +CFE_Status_t CS_ValidateEepromChecksumDefinitionTable(void *TblPtr) { - CFE_Status_t Result = CFE_SUCCESS; - CFE_Status_t Status = OS_ERROR; - CS_Def_EepromMemory_Table_Entry_t *StartOfTable = NULL; - CS_Def_EepromMemory_Table_Entry_t *OuterEntry = NULL; - int32 OuterLoop = 0; - uint32 StateField = 0; - cpuaddr Address = 0; - uint32 Size = 0; - int32 GoodCount = 0; - int32 BadCount = 0; - int32 EmptyCount = 0; + static const uint16 EEPROM_EVENTID_MAP[CS_ValidationError_MAX] = { + [CS_ValidationError_NONE] = CS_VAL_EEPROM_INF_EID, + [CS_ValidationError_STATE] = CS_VAL_EEPROM_STATE_ERR_EID, + [CS_ValidationError_MEM_RANGE] = CS_VAL_EEPROM_RANGE_ERR_EID, + }; + + CS_Def_EepromMemory_Table_Entry_t *Entry; + CS_ValidationMetrics_t Metrics; - StartOfTable = (CS_Def_EepromMemory_Table_Entry_t *)TblPtr; + memset(&Metrics, 0, sizeof(Metrics)); - Result = CFE_SUCCESS; + /* These are needed for assembling event data, if necessary */ + Metrics.TableName = "EEPROM"; + Metrics.EventMap = EEPROM_EVENTID_MAP; - for (OuterLoop = 0; OuterLoop < CS_MAX_NUM_MEMORY_TABLE_ENTRIES; OuterLoop++) + Entry = (CS_Def_EepromMemory_Table_Entry_t *)TblPtr; + while (Metrics.Position < CS_MAX_NUM_EEPROM_TABLE_ENTRIES) { - OuterEntry = &StartOfTable[OuterLoop]; + CS_ValidationMetrics_StartNext(&Metrics, Entry->State); - StateField = OuterEntry->State; - Address = OuterEntry->StartAddress; - Size = OuterEntry->NumBytesToChecksum; + CS_ValidateEntryAddress(&Metrics, Entry->StartAddress, Entry->NumBytesToChecksum, CFE_PSP_MEM_EEPROM); - if ((StateField == CS_STATE_EMPTY) || (StateField == CS_STATE_ENABLED) || (StateField == CS_STATE_DISABLED)) - { - /* If the StateField is within this range, check if it's not empty. */ - if (StateField == CS_STATE_DISABLED || StateField == CS_STATE_ENABLED) - { - Status = CFE_PSP_MemValidateRange(Address, Size, CFE_PSP_MEM_ANY); - if (Status != OS_SUCCESS) - { - BadCount++; - if (Result != CS_TABLE_ERROR) - { - CFE_EVS_SendEvent(CS_VAL_MEMORY_RANGE_ERR_EID, CFE_EVS_EventType_ERROR, - "Memory Table Validate: Illegal checksum range found in Entry ID %d, " - "CFE_PSP_MemValidateRange returned: 0x%08X", - (int)OuterLoop, (unsigned int)Status); - Result = CS_TABLE_ERROR; - } - } - else - { - /* Valid range for non-empty entry */ - GoodCount++; - } - } - else - { - /* Entry is marked as empty */ - EmptyCount++; - } - } - else - { - /* Invalid state definition */ - BadCount++; - if (Result != CS_TABLE_ERROR) - { - CFE_EVS_SendEvent(CS_VAL_MEMORY_STATE_ERR_EID, CFE_EVS_EventType_ERROR, - "Memory Table Validate: Illegal State Field (0x%04X) found in Entry ID %d", - (unsigned short)StateField, (int)OuterLoop); + /* increment the respective counter for final report */ + CS_ValidationMetrics_Accumulate(&Metrics); + ++Entry; + } - Result = CS_TABLE_ERROR; - } - } + return CS_ValidationMetrics_GetFinalStatus(&Metrics); +} + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +/* */ +/* CS Validation Callback function for Memory Table */ +/* */ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +CFE_Status_t CS_ValidateMemoryChecksumDefinitionTable(void *TblPtr) +{ + static const uint16 MEMORY_EVENTID_MAP[CS_ValidationError_MAX] = { + [CS_ValidationError_NONE] = CS_VAL_MEMORY_INF_EID, + [CS_ValidationError_STATE] = CS_VAL_MEMORY_STATE_ERR_EID, + [CS_ValidationError_MEM_RANGE] = CS_VAL_MEMORY_RANGE_ERR_EID, + }; - } /* for (OuterLoop = 0; OuterLoop < CS_MAX_NUM_MEMORY_TABLE_ENTRIES; OuterLoop++) */ + CS_Def_EepromMemory_Table_Entry_t *Entry; + CS_ValidationMetrics_t Metrics; - CFE_EVS_SendEvent(CS_VAL_MEMORY_INF_EID, CFE_EVS_EventType_INFORMATION, - "CS Memory Table verification results: good = %d, bad = %d, unused = %d", (int)GoodCount, - (int)BadCount, (int)EmptyCount); + memset(&Metrics, 0, sizeof(Metrics)); - return Result; + /* These are needed for assembling event data, if necessary */ + Metrics.TableName = "Memory"; + Metrics.EventMap = MEMORY_EVENTID_MAP; + + Entry = (CS_Def_EepromMemory_Table_Entry_t *)TblPtr; + while (Metrics.Position < CS_MAX_NUM_MEMORY_TABLE_ENTRIES) + { + CS_ValidationMetrics_StartNext(&Metrics, Entry->State); + + CS_ValidateEntryAddress(&Metrics, Entry->StartAddress, Entry->NumBytesToChecksum, CFE_PSP_MEM_ANY); + + /* increment the respective counter for final report */ + CS_ValidationMetrics_Accumulate(&Metrics); + ++Entry; + } + + return CS_ValidationMetrics_GetFinalStatus(&Metrics); } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -238,113 +393,40 @@ CFE_Status_t CS_ValidateMemoryChecksumDefinitionTable(void *TblPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ CFE_Status_t CS_ValidateTablesChecksumDefinitionTable(void *TblPtr) { - CFE_Status_t Result = CFE_SUCCESS; - CS_Def_Tables_Table_Entry_t *StartOfTable = NULL; - CS_Def_Tables_Table_Entry_t *OuterEntry = NULL; - int32 OuterLoop = 0; - int32 InnerLoop = 0; - uint32 StateField = 0; - int32 GoodCount = 0; - int32 BadCount = 0; - int32 EmptyCount = 0; - bool DuplicateFound = false; + static const uint16 TABLES_EVENTID_MAP[CS_ValidationError_MAX] = { + [CS_ValidationError_NONE] = CS_VAL_TABLES_INF_EID, + [CS_ValidationError_LONG_NAME] = CS_VAL_TABLES_DEF_TBL_LONG_NAME_ERR_EID, + [CS_ValidationError_STATE] = CS_VAL_TABLES_STATE_ERR_EID, + [CS_ValidationError_ZERO_NAME] = CS_VAL_TABLES_DEF_TBL_ZERO_NAME_ERR_EID, + [CS_ValidationError_DUPLICATE] = CS_VAL_TABLES_DEF_TBL_DUPL_ERR_EID, + }; - StartOfTable = (CS_Def_Tables_Table_Entry_t *)TblPtr; + CS_Def_Tables_Table_Entry_t *Entry = NULL; + CS_ValidationMetrics_t Metrics; - for (OuterLoop = 0; OuterLoop < CS_MAX_NUM_TABLES_TABLE_ENTRIES; OuterLoop++) - { - OuterEntry = &StartOfTable[OuterLoop]; - - StateField = OuterEntry->State; + memset(&Metrics, 0, sizeof(Metrics)); - /* Check for non-zero length for table name */ - if (OS_strnlen(OuterEntry->Name, CFE_TBL_MAX_FULL_NAME_LEN) != 0) - { - /* Verify valid state definition */ - if (((StateField == CS_STATE_EMPTY) || (StateField == CS_STATE_ENABLED) || - (StateField == CS_STATE_DISABLED))) - { - DuplicateFound = false; + /* These are needed for assembling event data, if necessary */ + Metrics.TableName = "Tables"; + Metrics.EventMap = TABLES_EVENTID_MAP; - /* Verify the name field is not duplicated */ - for (InnerLoop = OuterLoop + 1; InnerLoop < CS_MAX_NUM_TABLES_TABLE_ENTRIES; InnerLoop++) - { - if (strncmp(OuterEntry->Name, (&StartOfTable[InnerLoop])->Name, CFE_TBL_MAX_FULL_NAME_LEN) == 0) - { - if (DuplicateFound != true) - { - DuplicateFound = true; - BadCount++; - } - - if (Result != CS_TABLE_ERROR) - { - /* Duplicate name entry found */ - CFE_EVS_SendEvent( - CS_VAL_TABLES_DEF_TBL_DUPL_ERR_EID, CFE_EVS_EventType_ERROR, - "CS Tables Table Validate: Duplicate Name (%s) found at entries %d and %d", - OuterEntry->Name, (int)InnerLoop, (int)OuterLoop); - - Result = CS_TABLE_ERROR; - } - } - } - - /* Increment success/empty counter if name wasn't duplicated */ - if (DuplicateFound != true) - { - if (StateField != CS_STATE_EMPTY) - { - GoodCount++; - } - else - { - EmptyCount++; - } - } - } - else - { - if (Result != CS_TABLE_ERROR) - { - CFE_EVS_SendEvent(CS_VAL_TABLES_STATE_ERR_EID, CFE_EVS_EventType_ERROR, - "CS Tables Table Validate: Illegal State Field (0x%04X) found with name %s", - (unsigned short)StateField, OuterEntry->Name); + Entry = (CS_Def_Tables_Table_Entry_t *)TblPtr; + while (Metrics.Position < CS_MAX_NUM_TABLES_TABLE_ENTRIES) + { + CS_ValidationMetrics_StartNext(&Metrics, Entry->State); - Result = CS_TABLE_ERROR; - BadCount++; - } - } - } - else + CS_ValidateEntryName(&Metrics, Entry->Name, sizeof(Entry->Name)); + if (CS_ValidationMetrics_IsCurrentOK(&Metrics) && CS_StateValid(Entry->State)) { - /* Only entries marked as Empty can have zero-length names */ - if (StateField != CS_STATE_EMPTY) - { - /* Bad state for empty name */ - if (Result != CS_TABLE_ERROR) - { - CFE_EVS_SendEvent(CS_VAL_TABLES_DEF_TBL_ZERO_NAME_ERR_EID, CFE_EVS_EventType_ERROR, - "CS Tables Table Validate: Illegal State (0x%04X) with empty name at entry %d", - (unsigned short)StateField, (int)OuterLoop); - - Result = CS_TABLE_ERROR; - BadCount++; - } - } - else - { - EmptyCount++; - } + CS_CheckForDuplicateEntry(&Metrics, Entry->Name, sizeof(*Entry)); } - } /* for (OuterLoop = 0; OuterLoop < CS_MAX_NUM_TABLES_TABLE_ENTRIES; OuterLoop++) */ - - CFE_EVS_SendEvent(CS_VAL_TABLES_INF_EID, CFE_EVS_EventType_INFORMATION, - "CS Tables Table verification results: good = %d, bad = %d, unused = %d", (int)GoodCount, - (int)BadCount, (int)EmptyCount); + /* increment the respective counter for final report */ + CS_ValidationMetrics_Accumulate(&Metrics); + ++Entry; + } - return Result; + return CS_ValidationMetrics_GetFinalStatus(&Metrics); } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -354,122 +436,40 @@ CFE_Status_t CS_ValidateTablesChecksumDefinitionTable(void *TblPtr) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ CFE_Status_t CS_ValidateAppChecksumDefinitionTable(void *TblPtr) { - CFE_Status_t Result = CFE_SUCCESS; - CS_Def_App_Table_Entry_t *StartOfTable; - CS_Def_App_Table_Entry_t *OuterEntry; - int32 OuterLoop; - int32 InnerLoop; - uint32 StateField; - int32 GoodCount = 0; - int32 BadCount = 0; - int32 EmptyCount = 0; - bool DuplicateFound; - - StartOfTable = (CS_Def_App_Table_Entry_t *)TblPtr; - - for (OuterLoop = 0; OuterLoop < CS_MAX_NUM_APP_TABLE_ENTRIES; OuterLoop++) - { - OuterEntry = &StartOfTable[OuterLoop]; + static const uint16 APP_EVENTID_MAP[CS_ValidationError_MAX] = { + [CS_ValidationError_NONE] = CS_VAL_APP_INF_EID, + [CS_ValidationError_LONG_NAME] = CS_VAL_APP_DEF_TBL_LONG_NAME_ERR_EID, + [CS_ValidationError_STATE] = CS_VAL_APP_STATE_ERR_EID, + [CS_ValidationError_ZERO_NAME] = CS_VAL_APP_DEF_TBL_ZERO_NAME_ERR_EID, + [CS_ValidationError_DUPLICATE] = CS_VAL_APP_DEF_TBL_DUPL_ERR_EID, + }; - StateField = OuterEntry->State; + CS_Def_App_Table_Entry_t *Entry; + CS_ValidationMetrics_t Metrics; - if (memchr(OuterEntry->Name, 0, sizeof(OuterEntry->Name)) == NULL) - { - /* Not null-terminated, name is too long */ - if (Result != CS_TABLE_ERROR) - { - CFE_EVS_SendEvent(CS_VAL_APP_DEF_TBL_LONG_NAME_ERR_EID, CFE_EVS_EventType_ERROR, - "CS Apps Table Validate: Unterminated Name found at entry %d", (int)OuterLoop); - Result = CS_TABLE_ERROR; - } - BadCount++; - } - else if (OS_strnlen(OuterEntry->Name, CFE_TBL_MAX_FULL_NAME_LEN) != 0) - { - /* Verify valid state definition */ - if (((StateField == CS_STATE_EMPTY) || (StateField == CS_STATE_ENABLED) || - (StateField == CS_STATE_DISABLED))) - { - DuplicateFound = false; + memset(&Metrics, 0, sizeof(Metrics)); - /* Verify the name field is not duplicated */ - for (InnerLoop = 0; InnerLoop < OuterLoop; InnerLoop++) - { - if (strcmp(OuterEntry->Name, StartOfTable[InnerLoop].Name) == 0) - { - if (DuplicateFound != true) - { - DuplicateFound = true; - BadCount++; - } - - if (Result != CS_TABLE_ERROR) - { - /* Duplicate name entry found */ - CFE_EVS_SendEvent(CS_VAL_APP_DEF_TBL_DUPL_ERR_EID, CFE_EVS_EventType_ERROR, - "CS Apps Table Validate: Duplicate Name (%s) found at entries %d and %d", - OuterEntry->Name, (int)InnerLoop, (int)OuterLoop); - - Result = CS_TABLE_ERROR; - } - } - } + /* These are needed for assembling event data, if necessary */ + Metrics.TableName = "Apps"; + Metrics.EventMap = APP_EVENTID_MAP; - /* Increment success/empty counter if name wasn't duplicated */ - if (DuplicateFound != true) - { - if (StateField != CS_STATE_EMPTY) - { - GoodCount++; - } - else - { - EmptyCount++; - } - } - } - else - { - if (Result != CS_TABLE_ERROR) - { - CFE_EVS_SendEvent(CS_VAL_APP_STATE_ERR_EID, CFE_EVS_EventType_ERROR, - "CS Apps Table Validate: Illegal State Field (0x%04X) found with name %s", - (unsigned short)StateField, OuterEntry->Name); + Entry = (CS_Def_App_Table_Entry_t *)TblPtr; + while (Metrics.Position < CS_MAX_NUM_APP_TABLE_ENTRIES) + { + CS_ValidationMetrics_StartNext(&Metrics, Entry->State); - Result = CS_TABLE_ERROR; - BadCount++; - } - } - } - else + CS_ValidateEntryName(&Metrics, Entry->Name, sizeof(Entry->Name)); + if (CS_ValidationMetrics_IsCurrentOK(&Metrics) && CS_StateValid(Entry->State)) { - /* Only entries marked as Empty can have zero-length names */ - if (StateField != CS_STATE_EMPTY) - { - /* Bad state for empty name */ - if (Result != CS_TABLE_ERROR) - { - CFE_EVS_SendEvent(CS_VAL_APP_DEF_TBL_ZERO_NAME_ERR_EID, CFE_EVS_EventType_ERROR, - "CS Apps Table Validate: Illegal State (0x%04X) with empty name at entry %d", - (unsigned short)StateField, (int)OuterLoop); - - Result = CS_TABLE_ERROR; - BadCount++; - } - } - else - { - EmptyCount++; - } + CS_CheckForDuplicateEntry(&Metrics, Entry->Name, sizeof(*Entry)); } - } /* for (OuterLoop = 0; OuterLoop < CS_MAX_NUM_APPS_TABLE_ENTRIES; OuterLoop++) */ - - CFE_EVS_SendEvent(CS_VAL_APP_INF_EID, CFE_EVS_EventType_INFORMATION, - "CS Apps Table verification results: good = %d, bad = %d, unused = %d", (int)GoodCount, - (int)BadCount, (int)EmptyCount); + /* increment the respective counter for final report */ + CS_ValidationMetrics_Accumulate(&Metrics); + ++Entry; + } - return Result; + return CS_ValidationMetrics_GetFinalStatus(&Metrics); } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -477,77 +477,107 @@ CFE_Status_t CS_ValidateAppChecksumDefinitionTable(void *TblPtr) /* CS processing new definition tables for EEPROM or Memory */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_ProcessNewEepromMemoryDefinitionTable(const CS_Def_EepromMemory_Table_Entry_t *StartOfDefTable, - CS_Res_EepromMemory_Table_Entry_t *StartOfResultsTable, uint16 NumEntries, - uint16 Table) +void CS_ProcessNewEepromMemoryDefinitionTable(CS_TableWrapper_t *tw) { const CS_Def_EepromMemory_Table_Entry_t *DefEntry = NULL; CS_Res_EepromMemory_Table_Entry_t * ResultsEntry = NULL; uint16 Loop = 0; uint16 NumRegionsInTable = 0; - uint16 PreviousState = CS_STATE_EMPTY; + CS_ChecksumState_Enum_t PreviousState = CS_ChecksumState_EMPTY; /* We don't want to be doing chekcksums while changing the table out */ - if (Table == CS_EEPROM_TABLE) - { - PreviousState = CS_AppData.HkPacket.Payload.EepromCSState; - CS_AppData.HkPacket.Payload.EepromCSState = CS_STATE_DISABLED; - } - if (Table == CS_MEMORY_TABLE) + if (tw->GlobalState) { - PreviousState = CS_AppData.HkPacket.Payload.MemoryCSState; - CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_DISABLED; + PreviousState = *tw->GlobalState; + *tw->GlobalState = CS_ChecksumState_DISABLED; } - for (Loop = 0; Loop < NumEntries; Loop++) + Loop = 0; + while (true) { - DefEntry = &(StartOfDefTable[Loop]); - ResultsEntry = &(StartOfResultsTable[Loop]); + ResultsEntry = CS_GetResEntryAddr(tw, Loop); + DefEntry = CS_GetDefEntryAddr(tw, Loop); - if (DefEntry->State != CS_STATE_EMPTY) + if (ResultsEntry == NULL || DefEntry == NULL) + { + break; + } + + /* wipe the entry, sets everything to safe state, state set to CS_ChecksumState_EMPTY (0) */ + memset(ResultsEntry, 0, sizeof(*ResultsEntry)); + + if (CS_StateValid(DefEntry->State)) { /* This is just a real simple test, because all of the exception handling has already been done by the Validation routine above */ NumRegionsInTable++; ResultsEntry->State = DefEntry->State; - ResultsEntry->ComputedYet = false; ResultsEntry->NumBytesToChecksum = DefEntry->NumBytesToChecksum; - ResultsEntry->ComparisonValue = 0; - ResultsEntry->ByteOffset = 0; - ResultsEntry->TempChecksumValue = 0; ResultsEntry->StartAddress = DefEntry->StartAddress; } - else - { - ResultsEntry->State = CS_STATE_EMPTY; - ResultsEntry->ComputedYet = false; - ResultsEntry->NumBytesToChecksum = 0; - ResultsEntry->ComparisonValue = 0; - ResultsEntry->ByteOffset = 0; - ResultsEntry->TempChecksumValue = 0; - ResultsEntry->StartAddress = 0; - } + + ++Loop; } /* Reset the table back to the original checksumming state */ - if (Table == CS_EEPROM_TABLE) + if (tw->GlobalState) { - CS_AppData.HkPacket.Payload.EepromCSState = PreviousState; - CS_ResetTablesTblResultEntry(CS_AppData.EepResTablesTblPtr); + *tw->GlobalState = PreviousState; } - if (Table == CS_MEMORY_TABLE) - { - CS_AppData.HkPacket.Payload.MemoryCSState = PreviousState; - CS_ResetTablesTblResultEntry(CS_AppData.MemResTablesTblPtr); - } + CS_ResetTablesTblResultEntry(tw->ResTblPtr); if (NumRegionsInTable == 0) { CFE_EVS_SendEvent(CS_PROCESS_EEPROM_MEMORY_NO_ENTRIES_INF_EID, CFE_EVS_EventType_INFORMATION, - "CS %s Table: No valid entries in the table", CS_GetTableTypeAsString(Table)); + "CS %s Table: No valid entries in the table", CS_GetTableTypeAsString(tw)); + } +} + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +/* */ +/* Helper function to split the App.Table name pattern */ +/* */ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +void CS_ExtractNames(const CS_Def_Tables_Table_Entry_t *DefEntry, char *AppBuf, size_t AppSz, char *TableBuf, + size_t TableSz) +{ + const char *Sep; + size_t TableNameLen; + size_t AppNameLen; + + /* Look for the separator char (.) somewhere in the name */ + TableNameLen = OS_strnlen(DefEntry->Name, sizeof(DefEntry->Name)); + Sep = memchr(DefEntry->Name, '.', TableNameLen); + if (Sep == NULL) + { + /* There is no separator, assume the name is just a table name */ + Sep = DefEntry->Name; + AppNameLen = 0; + } + else + { + /* Move past the separator */ + AppNameLen = Sep - DefEntry->Name; + ++Sep; + } + + TableNameLen -= AppNameLen; + + if (AppNameLen > AppSz) + { + AppNameLen = AppSz; + } + if (TableNameLen > TableSz) + { + TableNameLen = TableSz; } + + memcpy(AppBuf, DefEntry->Name, AppNameLen); + AppBuf[AppNameLen] = 0; + memcpy(TableBuf, Sep, TableNameLen); + TableBuf[TableNameLen] = 0; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -555,144 +585,76 @@ void CS_ProcessNewEepromMemoryDefinitionTable(const CS_Def_EepromMemory_Table_En /* CS processing new definition tables for Tables */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_ProcessNewTablesDefinitionTable(const CS_Def_Tables_Table_Entry_t *StartOfDefTable, - CS_Res_Tables_Table_Entry_t * StartOfResultsTable) +void CS_ProcessNewTablesDefinitionTable(CS_TableWrapper_t *tw) { const CS_Def_Tables_Table_Entry_t *DefEntry = NULL; CS_Res_Tables_Table_Entry_t * ResultsEntry = NULL; uint16 Loop = 0; uint16 NumRegionsInTable = 0; - uint16 PreviousState = CS_STATE_EMPTY; + CS_ChecksumState_Enum_t PreviousState = CS_ChecksumState_EMPTY; CFE_ES_AppId_t AppID = CFE_ES_APPID_UNDEFINED; CFE_TBL_Handle_t TableHandle = CFE_TBL_BAD_TABLE_HANDLE; bool Owned = false; - uint16 DefNameIndex = 0; - uint16 AppNameIndex = 0; - uint16 TableNameIndex = 0; char AppName[OS_MAX_API_NAME]; char TableAppName[OS_MAX_API_NAME]; char TableTableName[CFE_MISSION_TBL_MAX_NAME_LENGTH]; + uint16 TableId; CFE_ES_GetAppID(&AppID); CFE_ES_GetAppName(AppName, AppID, OS_MAX_API_NAME); /* We don't want to be doing chekcksums while changing the table out */ PreviousState = CS_AppData.HkPacket.Payload.TablesCSState; - CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.TablesCSState = CS_ChecksumState_DISABLED; /* Assume none of the CS tables are listed in the new Tables table */ - CS_AppData.EepResTablesTblPtr = NULL; - CS_AppData.MemResTablesTblPtr = NULL; - CS_AppData.AppResTablesTblPtr = NULL; - CS_AppData.TblResTablesTblPtr = NULL; - - for (Loop = 0; Loop < CS_MAX_NUM_TABLES_TABLE_ENTRIES; Loop++) + for (TableId = 0; TableId < CS_NUM_TABLES; ++TableId) { - DefEntry = &(StartOfDefTable[Loop]); + CS_AppData.Tbl[TableId].ResTblPtr = NULL; + } - ResultsEntry = &(StartOfResultsTable[Loop]); + Loop = 0; + while (true) + { + DefEntry = CS_GetDefEntryAddr(tw, Loop); + ResultsEntry = CS_GetResEntryAddr(tw, Loop); - if (DefEntry->State != CS_STATE_EMPTY) + if (DefEntry == NULL || ResultsEntry == NULL) { - /* initialize buffer index values */ - DefNameIndex = 0; - AppNameIndex = 0; - TableNameIndex = 0; - - /* extract application name from CS definition table entry */ - while ((AppNameIndex < OS_MAX_API_NAME) && (DefEntry->Name[DefNameIndex] != '\0') && - (DefEntry->Name[DefNameIndex] != '.')) - { - TableAppName[AppNameIndex++] = DefEntry->Name[DefNameIndex++]; - } - - /* limit application name length to add string terminator */ - if (AppNameIndex == OS_MAX_API_NAME) - { - AppNameIndex = OS_MAX_API_NAME - 1; - } - - /* add string terminator to application name */ - TableAppName[AppNameIndex] = '\0'; - - /* move entry index to the dot, string terminator, or end of table entry */ - while ((DefNameIndex < CFE_TBL_MAX_FULL_NAME_LEN) && (DefEntry->Name[DefNameIndex] != '\0') && - (DefEntry->Name[DefNameIndex] != '.')) - { - DefNameIndex++; - } - - /* move entry index forward past the dot */ - if ((DefNameIndex < CFE_TBL_MAX_FULL_NAME_LEN) && (DefEntry->Name[DefNameIndex] == '.')) - { - DefNameIndex++; - } - - /* extract table name from CS definition table entry */ - while ((DefNameIndex < CFE_TBL_MAX_FULL_NAME_LEN) && (TableNameIndex < CFE_MISSION_TBL_MAX_NAME_LENGTH) && - (DefEntry->Name[DefNameIndex] != '\0')) - { - TableTableName[TableNameIndex++] = DefEntry->Name[DefNameIndex++]; - } + break; + } - /* limit table name length to add string terminator */ - if (TableNameIndex == CFE_MISSION_TBL_MAX_NAME_LENGTH) - { - TableNameIndex = CFE_MISSION_TBL_MAX_NAME_LENGTH - 1; - } + /* wipe the entry, sets everything to safe state, state set to CS_ChecksumState_EMPTY (0) */ + /* This also needs to explicitly set the TBL handle as 0 might be valid */ + memset(ResultsEntry, 0, sizeof(*ResultsEntry)); + ResultsEntry->TblHandleID = CFE_TBL_HANDLEID_UNDEFINED; - /* add string terminator to table name */ - TableTableName[TableNameIndex] = '\0'; + if (CS_StateValid(DefEntry->State)) + { + CS_ExtractNames(DefEntry, TableAppName, sizeof(TableAppName), TableTableName, sizeof(TableTableName)); TableHandle = CFE_TBL_BAD_TABLE_HANDLE; Owned = false; /* if the table's owner's name is CS */ - if (strncmp(TableAppName, AppName, OS_MAX_API_NAME) == 0) + if (strcmp(TableAppName, AppName) == 0) { - if (strncmp(TableTableName, CS_DEF_EEPROM_TABLE_NAME, CFE_MISSION_TBL_MAX_NAME_LENGTH) == 0) - { - TableHandle = CS_AppData.DefEepromTableHandle; - CS_AppData.EepResTablesTblPtr = ResultsEntry; - Owned = true; - } - if (strncmp(TableTableName, CS_DEF_MEMORY_TABLE_NAME, CFE_MISSION_TBL_MAX_NAME_LENGTH) == 0) - { - TableHandle = CS_AppData.DefMemoryTableHandle; - CS_AppData.MemResTablesTblPtr = ResultsEntry; - Owned = true; - } - if (strncmp(TableTableName, CS_DEF_TABLES_TABLE_NAME, CFE_MISSION_TBL_MAX_NAME_LENGTH) == 0) - { - TableHandle = CS_AppData.DefTablesTableHandle; - CS_AppData.TblResTablesTblPtr = ResultsEntry; - Owned = true; - } - if (strncmp(TableTableName, CS_DEF_APP_TABLE_NAME, CFE_MISSION_TBL_MAX_NAME_LENGTH) == 0) - { - TableHandle = CS_AppData.DefAppTableHandle; - CS_AppData.AppResTablesTblPtr = ResultsEntry; - Owned = true; - } - if (strncmp(TableTableName, CS_RESULTS_EEPROM_TABLE_NAME, CFE_MISSION_TBL_MAX_NAME_LENGTH) == 0) - { - TableHandle = CS_AppData.ResEepromTableHandle; - Owned = true; - } - if (strncmp(TableTableName, CS_RESULTS_MEMORY_TABLE_NAME, CFE_MISSION_TBL_MAX_NAME_LENGTH) == 0) - { - TableHandle = CS_AppData.ResMemoryTableHandle; - Owned = true; - } - if (strncmp(TableTableName, CS_RESULTS_TABLES_TABLE_NAME, CFE_MISSION_TBL_MAX_NAME_LENGTH) == 0) - { - TableHandle = CS_AppData.ResTablesTableHandle; - Owned = true; - } - if (strncmp(TableTableName, CS_RESULTS_APP_TABLE_NAME, CFE_MISSION_TBL_MAX_NAME_LENGTH) == 0) + for (TableId = 0; TableId < CS_NUM_TABLES; ++TableId) { - TableHandle = CS_AppData.ResAppTableHandle; - Owned = true; + if (CS_CheckDefTableNameMatch(TableTableName, TableId)) + { + CS_AppData.Tbl[TableId].ResTblPtr = ResultsEntry; + + TableHandle = CS_GetDefHandle(TableId); + Owned = true; + break; + } + if (CS_CheckResTableNameMatch(TableTableName, TableId)) + { + TableHandle = CS_GetResHandle(TableId); + Owned = true; + break; + } } } @@ -700,31 +662,15 @@ void CS_ProcessNewTablesDefinitionTable(const CS_Def_Tables_Table_Entry_t *Start has already been done by the Validation routine above */ NumRegionsInTable++; - ResultsEntry->State = DefEntry->State; - ResultsEntry->ComputedYet = false; - ResultsEntry->NumBytesToChecksum = 0; /* this is unknown at this time */ - ResultsEntry->ComparisonValue = 0; - ResultsEntry->ByteOffset = 0; - ResultsEntry->TempChecksumValue = 0; - ResultsEntry->StartAddress = 0; /* this is unknown at this time */ - ResultsEntry->TblHandle = TableHandle; - ResultsEntry->IsCSOwner = Owned; + ResultsEntry->State = DefEntry->State; + ResultsEntry->TblHandleID = CFE_TBL_HandleToID(TableHandle); + ResultsEntry->IsCSOwner = Owned; + CFE_SB_MessageStringGet(ResultsEntry->Name, DefEntry->Name, NULL, sizeof(ResultsEntry->Name), sizeof(DefEntry->Name)); } - else - { - ResultsEntry->State = CS_STATE_EMPTY; - ResultsEntry->ComputedYet = false; - ResultsEntry->NumBytesToChecksum = 0; - ResultsEntry->ComparisonValue = 0; - ResultsEntry->ByteOffset = 0; - ResultsEntry->TempChecksumValue = 0; - ResultsEntry->StartAddress = 0; - ResultsEntry->TblHandle = CFE_TBL_BAD_TABLE_HANDLE; - ResultsEntry->IsCSOwner = false; - ResultsEntry->Name[0] = '\0'; - } + + ++Loop; } /* Reset the table back to the original checksumming state */ @@ -743,60 +689,51 @@ void CS_ProcessNewTablesDefinitionTable(const CS_Def_Tables_Table_Entry_t *Start /* CS processing new definition tables for Apps */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -void CS_ProcessNewAppDefinitionTable(const CS_Def_App_Table_Entry_t *StartOfDefTable, - CS_Res_App_Table_Entry_t * StartOfResultsTable) +void CS_ProcessNewAppDefinitionTable(CS_TableWrapper_t *tw) { const CS_Def_App_Table_Entry_t *DefEntry = NULL; CS_Res_App_Table_Entry_t * ResultsEntry = NULL; uint16 Loop = 0; uint16 NumRegionsInTable = 0; - uint16 PreviousState = CS_STATE_EMPTY; + CS_ChecksumState_Enum_t PreviousState = CS_ChecksumState_EMPTY; /* We don't want to be doing chekcksums while changing the table out */ PreviousState = CS_AppData.HkPacket.Payload.AppCSState; - CS_AppData.HkPacket.Payload.AppCSState = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.AppCSState = CS_ChecksumState_DISABLED; - for (Loop = 0; Loop < CS_MAX_NUM_APP_TABLE_ENTRIES; Loop++) + Loop = 0; + while (true) { - DefEntry = &(StartOfDefTable[Loop]); + DefEntry = CS_GetDefEntryAddr(tw, Loop); + ResultsEntry = CS_GetResEntryAddr(tw, Loop); + + if (DefEntry == NULL || ResultsEntry == NULL) + { + break; + } - ResultsEntry = &(StartOfResultsTable[Loop]); + /* wipe the entry, sets everything to safe state, state set to CS_ChecksumState_EMPTY (0) */ + memset(ResultsEntry, 0, sizeof(*ResultsEntry)); - if (DefEntry->State != CS_STATE_EMPTY) + if (CS_StateValid(DefEntry->State)) { /* This is just a real simple test, because all of the exception handling has already been done by the Validation routine above */ NumRegionsInTable++; - ResultsEntry->State = DefEntry->State; - ResultsEntry->ComputedYet = false; - ResultsEntry->NumBytesToChecksum = 0; /* this is unknown at this time */ - ResultsEntry->ComparisonValue = 0; - ResultsEntry->ByteOffset = 0; - ResultsEntry->TempChecksumValue = 0; - ResultsEntry->StartAddress = 0; /* this is unknown at this time */ + ResultsEntry->State = DefEntry->State; CFE_SB_MessageStringGet(ResultsEntry->Name, DefEntry->Name, NULL, sizeof(ResultsEntry->Name), sizeof(DefEntry->Name)); } - else - { - ResultsEntry->State = CS_STATE_EMPTY; - ResultsEntry->ComputedYet = false; - ResultsEntry->NumBytesToChecksum = 0; - ResultsEntry->ComparisonValue = 0; - ResultsEntry->ByteOffset = 0; - ResultsEntry->TempChecksumValue = 0; - ResultsEntry->StartAddress = 0; - - ResultsEntry->Name[0] = '\0'; - } + + ++Loop; } /* Reset the table back to the original checksumming state */ CS_AppData.HkPacket.Payload.AppCSState = PreviousState; - CS_ResetTablesTblResultEntry(CS_AppData.AppResTablesTblPtr); + CS_ResetTablesTblResultEntry(tw->ResTblPtr); if (NumRegionsInTable == 0) { @@ -805,93 +742,110 @@ void CS_ProcessNewAppDefinitionTable(const CS_Def_App_Table_Entry_t *StartOfDefT } } -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -/* */ -/* CS function for initializing new tables */ -/* */ -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -CFE_Status_t CS_TableInit(CFE_TBL_Handle_t *DefinitionTableHandle, CFE_TBL_Handle_t *ResultsTableHandle, - void **DefinitionTblPtr, void **ResultsTblPtr, uint16 Table, const char *DefinitionTableName, - const char *ResultsTableName, uint16 NumEntries, const char *DefinitionTableFileName, - const void *DefaultDefTableAddress, uint16 SizeofDefinitionTableEntry, - uint16 SizeofResultsTableEntry, CFE_TBL_CallbackFuncPtr_t CallBackFunction) +/*---------------------------------------------------------------- + * + * Local helper function + * Register the result table with CFE table services and obtain the address + * + *-----------------------------------------------------------------*/ +CFE_Status_t CS_RegisterResultTable(CS_TableWrapper_t *tw) { - CFE_Status_t Result = CFE_SUCCESS; - size_t SizeOfTable = 0; - bool LoadedFromMemory = false; + CFE_Status_t Result; - SizeOfTable = NumEntries * SizeofResultsTableEntry; - - Result = CFE_TBL_Register(ResultsTableHandle, ResultsTableName, SizeOfTable, + Result = CFE_TBL_Register(&tw->ResHandle, tw->ResTableName, tw->NumEntries * tw->ResEntrySize, CFE_TBL_OPT_SNGL_BUFFER | CFE_TBL_OPT_DUMP_ONLY, NULL); - if (Result == CFE_SUCCESS) + if (Result >= CFE_SUCCESS) { - Result = CFE_TBL_GetAddress(ResultsTblPtr, *ResultsTableHandle); + Result = CFE_TBL_GetAddress(&tw->ResAddr, tw->ResHandle); } - if (Result == CFE_SUCCESS) + if (Result >= CFE_SUCCESS) { - SizeOfTable = NumEntries * SizeofDefinitionTableEntry; - - Result = CFE_TBL_Register(DefinitionTableHandle, DefinitionTableName, SizeOfTable, - CFE_TBL_OPT_SNGL_BUFFER | CFE_TBL_OPT_LOAD_DUMP, CallBackFunction); + Result = CFE_SUCCESS; } - if (Result == CFE_SUCCESS) + return Result; +} + +/*---------------------------------------------------------------- + * + * Local helper function + * Register the definition table with CFE table services, load the + * table, and obtain the address. + * + *-----------------------------------------------------------------*/ +CFE_Status_t CS_RegisterDefinitionTable(CS_TableWrapper_t *tw, const char *DefinitionTableFileName, + CFE_TBL_CallbackFuncPtr_t CallBackFunction) +{ + bool LoadedFromMemory = false; + CFE_Status_t Result; + + Result = CFE_TBL_Register(&tw->DefHandle, tw->DefTableName, tw->NumEntries * tw->DefEntrySize, + CFE_TBL_OPT_SNGL_BUFFER | CFE_TBL_OPT_LOAD_DUMP, CallBackFunction); + + if (Result >= CFE_SUCCESS) { - Result = CFE_TBL_Load(*DefinitionTableHandle, CFE_TBL_SRC_FILE, DefinitionTableFileName); + Result = CFE_TBL_Load(tw->DefHandle, CFE_TBL_SRC_FILE, DefinitionTableFileName); /* if the load from the file fails, load from the default tables in CS */ if (Result < CFE_SUCCESS) { - Result = CFE_TBL_Load(*DefinitionTableHandle, CFE_TBL_SRC_ADDRESS, DefaultDefTableAddress); + Result = CFE_TBL_Load(tw->DefHandle, CFE_TBL_SRC_ADDRESS, tw->DefaultDefinitionPtr); LoadedFromMemory = (Result >= CFE_SUCCESS); } } - if (Result == CFE_SUCCESS) + if (Result >= CFE_SUCCESS) { - Result = CFE_TBL_GetAddress(DefinitionTblPtr, *DefinitionTableHandle); - - if (Result == CFE_TBL_INFO_UPDATED) - { - CS_CallTableUpdateHandler(Table, *DefinitionTblPtr, *ResultsTblPtr, NumEntries); - } /* end if (Result == CFE_TBL_INFO_UPDATED) || (Result == CFE_SUCCESS) */ + Result = CFE_TBL_GetAddress(&tw->DefAddr, tw->DefHandle); } if (Result >= CFE_SUCCESS) { /* If we loaded from file successfully then the states we wish to use have already been set * If we loaded from memory then disable the table */ - if (LoadedFromMemory) + if (LoadedFromMemory && tw->GlobalState != NULL) { - switch (Table) - { - case CS_EEPROM_TABLE: - CS_AppData.HkPacket.Payload.EepromCSState = CS_STATE_DISABLED; - break; - case CS_MEMORY_TABLE: - CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_DISABLED; - break; - case CS_APP_TABLE: - CS_AppData.HkPacket.Payload.AppCSState = CS_STATE_DISABLED; - break; - case CS_TABLES_TABLE: - CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_DISABLED; - break; - default: - break; - } + *tw->GlobalState = CS_ChecksumState_DISABLED; } + CS_CallTableUpdateHandler(tw); Result = CFE_SUCCESS; } + + return Result; +} + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +/* */ +/* CS function for initializing new tables */ +/* */ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +CFE_Status_t CS_TableInit(CS_TableWrapper_t *tw, const char *DefinitionTableFileName, + CFE_TBL_CallbackFuncPtr_t CallBackFunction) +{ + CFE_Status_t Result; + + if (DefinitionTableFileName == NULL) + { + Result = CFE_SUCCESS; /* nothing to do */ + } else { - CFE_EVS_SendEvent(CS_TBL_INIT_ERR_EID, CFE_EVS_EventType_ERROR, - "CS received error 0x%08X initializing Definition table for %s", (unsigned int)Result, - CS_GetTableTypeAsString(Table)); + Result = CS_RegisterResultTable(tw); + + if (Result == CFE_SUCCESS) + { + Result = CS_RegisterDefinitionTable(tw, DefinitionTableFileName, CallBackFunction); + } + + if (Result != CFE_SUCCESS) + { + CFE_EVS_SendEvent(CS_TBL_INIT_ERR_EID, CFE_EVS_EventType_ERROR, + "CS received error 0x%08X initializing tables for %s", (unsigned int)Result, + CS_GetTableTypeAsString(tw)); + } } return Result; @@ -902,8 +856,7 @@ CFE_Status_t CS_TableInit(CFE_TBL_Handle_t *DefinitionTableHandle, CFE_TBL_Handl /* CS Handles table updates */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -CFE_Status_t CS_HandleTableUpdate(void **DefinitionTblPtr, void **ResultsTblPtr, CFE_TBL_Handle_t DefinitionTableHandle, - CFE_TBL_Handle_t ResultsTableHandle, uint16 Table, uint16 NumEntries) +CFE_Status_t CS_HandleTableUpdate(CS_TableWrapper_t *tw) { CFE_Status_t ReleaseResult1 = CFE_SUCCESS; CFE_Status_t ManageResult1 = CFE_SUCCESS; @@ -914,44 +867,59 @@ CFE_Status_t CS_HandleTableUpdate(void **DefinitionTblPtr, void **ResultsTblPtr, CFE_Status_t Result = CFE_SUCCESS; int32 Loop = 0; + CFE_TBL_Handle_t LocalHandle; + CS_Res_Tables_Table_Entry_t *ResTablesTblPtr; + /* Below, there are several values that are returned and assigned, but never evaluated. */ /* This is done so intentionally, as it helps us with Source-Level debugging this functions. */ /* Release the Table Address. */ - ReleaseResult1 = CFE_TBL_ReleaseAddress(ResultsTableHandle); - ReleaseResult2 = CFE_TBL_ReleaseAddress(DefinitionTableHandle); + ReleaseResult1 = CFE_TBL_ReleaseAddress(tw->ResHandle); + ReleaseResult2 = CFE_TBL_ReleaseAddress(tw->DefHandle); - ManageResult1 = CFE_TBL_Manage(ResultsTableHandle); - ManageResult2 = CFE_TBL_Manage(DefinitionTableHandle); + ManageResult1 = CFE_TBL_Manage(tw->ResHandle); + ManageResult2 = CFE_TBL_Manage(tw->DefHandle); - GetResult1 = CFE_TBL_GetAddress(ResultsTblPtr, ResultsTableHandle); + GetResult1 = CFE_TBL_GetAddress(&tw->ResAddr, tw->ResHandle); Result = GetResult1; - if (Result == CFE_SUCCESS) + if (Result >= CFE_SUCCESS) { - GetResult2 = CFE_TBL_GetAddress(DefinitionTblPtr, DefinitionTableHandle); + GetResult2 = CFE_TBL_GetAddress(&tw->DefAddr, tw->DefHandle); Result = GetResult2; } if ((Result == CFE_TBL_INFO_UPDATED)) { - if (Table == CS_TABLES_TABLE) + if (CS_CheckTableId(tw, CS_ChecksumType_TABLES_TABLE)) { /* before we update the results table, we need to release all of the table handles that are in the results table */ - for (Loop = 0; Loop < CS_MAX_NUM_TABLES_TABLE_ENTRIES; Loop++) + Loop = 0; + while (true) { - if (CS_AppData.ResTablesTblPtr[Loop].TblHandle != CFE_TBL_BAD_TABLE_HANDLE) + ResTablesTblPtr = CS_GetTablesResEntry(Loop); + if (ResTablesTblPtr == NULL) { - if (CS_AppData.ResTablesTblPtr[Loop].IsCSOwner == false) - { - CFE_TBL_Unregister(CS_AppData.ResTablesTblPtr[Loop].TblHandle); - } + break; + } + if (!ResTablesTblPtr->IsCSOwner) + { + LocalHandle = CFE_TBL_HandleFromID(ResTablesTblPtr->TblHandleID); + } + else + { + LocalHandle = CFE_TBL_BAD_TABLE_HANDLE; + } + if (CFE_TBL_HANDLE_IS_VALID(LocalHandle)) + { + CFE_TBL_Unregister(LocalHandle); } + ++Loop; } } - CS_CallTableUpdateHandler(Table, *DefinitionTblPtr, *ResultsTblPtr, NumEntries); + CS_CallTableUpdateHandler(tw); Result = CFE_SUCCESS; } @@ -964,7 +932,7 @@ CFE_Status_t CS_HandleTableUpdate(void **DefinitionTblPtr, void **ResultsTblPtr, "CS had problems updating table. Res Release: 0x%08X Def Release:0x%08X Res " "Manage:0x%08X Def Manage: 0x%08X Get:0x%08X for table %s", (unsigned int)ReleaseResult1, (unsigned int)ReleaseResult2, (unsigned int)ManageResult1, - (unsigned int)ManageResult2, (unsigned int)GetResult2, CS_GetTableTypeAsString(Table)); + (unsigned int)ManageResult2, (unsigned int)GetResult2, CS_GetTableTypeAsString(tw)); } } return Result; diff --git a/fsw/src/cs_table_processing.h b/fsw/src/cs_table_processing.h index 2569320..19bbab5 100644 --- a/fsw/src/cs_table_processing.h +++ b/fsw/src/cs_table_processing.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -29,7 +28,9 @@ ** Include section ** **************************************************************************/ -#include +#include "cs_tbl.h" +#include "cfe_error.h" +#include "cfe_tbl_api_typedefs.h" /************************************************************************** ** @@ -37,25 +38,38 @@ ** **************************************************************************/ -/** - * \brief table names for definition tables - * \{ - */ -#define CS_DEF_EEPROM_TABLE_NAME "DefEepromTbl" -#define CS_DEF_MEMORY_TABLE_NAME "DefMemoryTbl" -#define CS_DEF_TABLES_TABLE_NAME "DefTablesTbl" -#define CS_DEF_APP_TABLE_NAME "DefAppTbl" -/**\}*/ +/************************************************************************* + ** + ** Type definitions + ** + **************************************************************************/ +typedef struct CS_TableWrapper +{ + const char *DefTableName; /**< \brief Name of definition table */ + const char *ResTableName; /**< \brief Name of result table */ -/** - * \brief names for the results tables - * \{ - */ -#define CS_RESULTS_EEPROM_TABLE_NAME "ResEepromTbl" -#define CS_RESULTS_MEMORY_TABLE_NAME "ResMemoryTbl" -#define CS_RESULTS_TABLES_TABLE_NAME "ResTablesTbl" -#define CS_RESULTS_APP_TABLE_NAME "ResAppTbl" -/**\}*/ + CFE_TBL_Handle_t DefHandle; /**< \brief Handle to the definition table */ + CFE_TBL_Handle_t ResHandle; /**< \brief Handle to the results table */ + + size_t NumEntries; /**< \brief Number of entries in table (applies to both def and res) */ + + void * DefAddr; /**< \brief Pointer to definition table */ + size_t DefEntrySize; /**< \brief Size of each entry in definition table */ + size_t DefStateOffset; /**< \brief Offset of "State" member within definition entry */ + + void * ResAddr; /**< \brief Pointer to results table */ + size_t ResEntrySize; /**< \brief Size of each entry in result table */ + + const void *DefaultDefinitionPtr; /**< Pointer to default definition, if applicable */ + + void (*UpdateHandler)(struct CS_TableWrapper *); /**< Function to handle table updates */ + + uint32 *BaselineValue; /**< \brief pointer to HK TLM entry containing baseline value */ + uint8 * GlobalState; /**< \brief pointer to HK TLM entry containing global enable/disable */ + + CS_Res_Tables_Table_Entry_t *ResTblPtr; /**< \brief CS results entry for this table */ + +} CS_TableWrapper_t; /************************************************************************** ** @@ -63,6 +77,15 @@ ** **************************************************************************/ +/** + * \brief Calls the table update handler, if configured + * + * This is a helper function, tested separately + * + * \param [in] tw A pointer to the table wrapper struct + */ +void CS_CallTableUpdateHandler(CS_TableWrapper_t *tw); + /** * \brief Validate EEPROM definition table * @@ -73,7 +96,7 @@ * \par Assumptions, External Events, and Notes: * None * - * \param [in] TblPtr A pointer to the table to be validated + * \param [in] TblPtr A pointer to the table data to be validated * * \return Execution status see \ref CFEReturnCodes * \retval #CFE_SUCCESS \copydoc CFE_SUCCESS @@ -91,7 +114,7 @@ CFE_Status_t CS_ValidateEepromChecksumDefinitionTable(void *TblPtr); * \par Assumptions, External Events, and Notes: * None * - * \param [in] TblPtr A pointer to the table to be validated + * \param [in] TblPtr A pointer to the table data to be validated * * \return Execution status see \ref CFEReturnCodes * \retval #CFE_SUCCESS \copydoc CFE_SUCCESS @@ -109,7 +132,7 @@ CFE_Status_t CS_ValidateMemoryChecksumDefinitionTable(void *TblPtr); * \par Assumptions, External Events, and Notes: * None * - * \param [in] TblPtr A pointer to the table to be validated + * \param [in] TblPtr A pointer to the table data to be validated * * \return Execution status see \ref CFEReturnCodes * \retval #CFE_SUCCESS \copydoc CFE_SUCCESS @@ -127,7 +150,7 @@ CFE_Status_t CS_ValidateTablesChecksumDefinitionTable(void *TblPtr); * \par Assumptions, External Events, and Notes: * None * - * \param [in] TblPtr A pointer to the table to be validated + * \param [in] TblPtr A pointer to the table data to be validated * * \return Execution status see \ref CFEReturnCodes * \retval #CFE_SUCCESS \copydoc CFE_SUCCESS @@ -146,19 +169,9 @@ CFE_Status_t CS_ValidateAppChecksumDefinitionTable(void *TblPtr); * \par Assumptions, External Events, and Notes: * None * - * \param [in] DefinitionTblPtr A pointer to the definiton table - * (#CS_Def_EepromMemory_Table_Entry_t) - * that we are operating on - * - * \param [in] ResultsTblPtr A pointer to the result table - * (#CS_Res_EepromMemory_Table_Entry_t) - * to operate on - * \param [in] NumEntries The number of entries in the table - * \param [in] Table The specific table we are operating on + * \param [in] tw A pointer to the table wrapper struct */ -void CS_ProcessNewEepromMemoryDefinitionTable(const CS_Def_EepromMemory_Table_Entry_t *DefinitionTblPtr, - CS_Res_EepromMemory_Table_Entry_t *ResultsTblPtr, uint16 NumEntries, - uint16 Table); +void CS_ProcessNewEepromMemoryDefinitionTable(CS_TableWrapper_t *tw); /** * \brief Processes a new definition table for the Tables table @@ -171,16 +184,9 @@ void CS_ProcessNewEepromMemoryDefinitionTable(const CS_Def_EepromMemory_Table_En * \par Assumptions, External Events, and Notes: * None * - * \param [in] DefinitionTblPtr A pointer to the definiton table - * (#CS_Def_Tables_Table_Entry_t) - * that we are operating on - * - * \param [in] ResultsTblPtr A pointer to the result table - * (#CS_Res_Tables_Table_Entry_t) - * to operate on + * \param [in] tw A pointer to the table wrapper struct */ -void CS_ProcessNewTablesDefinitionTable(const CS_Def_Tables_Table_Entry_t *DefinitionTblPtr, - CS_Res_Tables_Table_Entry_t * ResultsTblPtr); +void CS_ProcessNewTablesDefinitionTable(CS_TableWrapper_t *tw); /** * \brief Processes a new definition table for the App table @@ -193,16 +199,9 @@ void CS_ProcessNewTablesDefinitionTable(const CS_Def_Tables_Table_Entry_t *Defin * \par Assumptions, External Events, and Notes: * None * - * \param [in] DefinitionTblPtr A pointer to the definiton table - * (#CS_Def_App_Table_Entry_t) - * that we are operating on - * - * \param [in] ResultsTblPtr A pointer to the result table - * (#CS_Res_App_Table_Entry_t) - * to operate on + * \param [in] tw A pointer to the table wrapper struct */ -void CS_ProcessNewAppDefinitionTable(const CS_Def_App_Table_Entry_t *DefinitionTblPtr, - CS_Res_App_Table_Entry_t * ResultsTblPtr); +void CS_ProcessNewAppDefinitionTable(CS_TableWrapper_t *tw); /** * \brief Initializes the results and definition table on startup @@ -216,75 +215,19 @@ void CS_ProcessNewAppDefinitionTable(const CS_Def_App_Table_Entry_t *DefinitionT * Also, if the default table file is not found for the definitionm * table, this function loads a 'blank' table from memory * - * \param [in] DefinitionTableHandle A #CFE_TBL_Handle_t pointer - * that will get filled in with the - * table handle to the definition - * table - * - * \param [in] ResultsTableHandle A #CFE_TBL_Handle_t pointer - * that will get filled in with the - * table handle to the results - * table - * - * \param [in] DefinitionTblPtr A pointer to the definiton table - * that we are operating on, it - * will get assigned during this - * call - * - * \param [in] ResultsTblPtr A pointer to the result table - * to operate on , it will get - * assigned during this call - * - * \param [in] Table The specific table we are - * operating on - * - * \param [in] DefinitionTableName The name of the definition table - * - * \param [in] ResultsTableName The name of the results table - * - * \param [in] NumEntries The number of entries in the - * table + * \param [in] tw A pointer to the table wrapper struct * * \param [in] DefinitionTableFileName The name of the file to load the * definition table from * - * \param [in] DefaultDefTableAddress The address of the default - * definition table that we may - * have to load from memory if - * the file is absent - * - * \param [in] SizeofDefinitionTableEntry The sizeof an entry in the - * definition table - * - * \param [in] SizeofResultsTableEntry The size of an enrty in the - * results table - * * \param [in] CallBackFunction A pointer to a function used to * validate the definition table * - * \param [out] * DefinitionTableHandle A #CFE_TBL_Handle_t pointer that - * will get filled in with the tbl - * handle to the definition table - * - * \param [out] * ResultsTableHandle A #CFE_TBL_Handle_t pointer that - * will get filled in with the tbl - * handle to the results table - * - * \param [out] * DefinitionTblPtr A pointer to the definiton table - * that we are operating on - * - * \param [in] * ResultsTblPtr A pointer to the result table - * to operate on , it will get - * be used to access the table - * * \return Execution status, see \ref CFEReturnCodes * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS */ -CFE_Status_t CS_TableInit(CFE_TBL_Handle_t *DefinitionTableHandle, CFE_TBL_Handle_t *ResultsTableHandle, - void **DefinitionTblPtr, void **ResultsTblPtr, uint16 Table, const char *DefinitionTableName, - const char *ResultsTableName, uint16 NumEntries, const char *DefinitionTableFileName, - const void *DefaultDefTableAddress, uint16 SizeofDefinitionTableEntry, - uint16 SizeofResultsTableEntry, CFE_TBL_CallbackFuncPtr_t CallBackFunction); +CFE_Status_t CS_TableInit(CS_TableWrapper_t *tw, const char *DefinitionTableFileName, + CFE_TBL_CallbackFuncPtr_t CallBackFunction); /** * \brief Handles table updates for all CS tables @@ -296,26 +239,11 @@ CFE_Status_t CS_TableInit(CFE_TBL_Handle_t *DefinitionTableHandle, CFE_TBL_Handl * \par Assumptions, External Events, and Notes: * None * - * \param [in] DefinitionTblPtr A pointer to the definiton table - * that we are operating on - * - * \param [in] ResultsTblPtr A pointer to the result table - * to operate on - * \param [in] DefinitionTableHandle A table handle to the definition - * table - * - * \param [in] ResultsTableHandle A table handle to the results - * table - * - * \param [in] NumEntries The number of entries in the table - * - * \param [in] Table The specific table we are operating - * on + * \param [in] tw A pointer to the table wrapper struct * * \return Execution status, see \ref CFEReturnCodes * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS */ -CFE_Status_t CS_HandleTableUpdate(void **DefinitionTblPtr, void **ResultsTblPtr, CFE_TBL_Handle_t DefinitionTableHandle, - CFE_TBL_Handle_t ResultsTableHandle, uint16 Table, uint16 NumEntries); +CFE_Status_t CS_HandleTableUpdate(CS_TableWrapper_t *tw); #endif diff --git a/fsw/src/cs_utils.c b/fsw/src/cs_utils.c index 8646e93..9eeb084 100644 --- a/fsw/src/cs_utils.c +++ b/fsw/src/cs_utils.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -29,7 +28,7 @@ **************************************************************************/ #include "cfe.h" #include "cs_app.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_compute.h" #include "cs_utils.h" #include "cs_table_processing.h" @@ -40,33 +39,176 @@ ** Functions ** **************************************************************************/ + +/*---------------------------------------------------------------- + * + * Local helper function + * Checks if two names match in a NULL-safe manner. + * If either string is NULL then there is no match. + * + *-----------------------------------------------------------------*/ +bool CS_CheckGenericNameMatch(const char *Name1, const char *Name2) +{ + if (Name1 == NULL || Name2 == NULL) + { + return false; + } + + return (strcmp(Name1, Name2) == 0); +} + +/*---------------------------------------------------------------- + * + * Application utility function + * Checks if the definition table name matches (NULL-safe) + * + *-----------------------------------------------------------------*/ +bool CS_CheckDefTableNameMatch(const char *Name, uint16 TableId) +{ + return CS_CheckGenericNameMatch(CS_GetDefName(TableId), Name); +} + +/*---------------------------------------------------------------- + * + * Application utility function + * Checks if the result table name matches (NULL-safe) + * + *-----------------------------------------------------------------*/ +bool CS_CheckResTableNameMatch(const char *Name, uint16 TableId) +{ + return CS_CheckGenericNameMatch(CS_GetResName(TableId), Name); +} + +/*---------------------------------------------------------------- + * + * Application utility function + * Gets a pointer to the given definition table entry + * + *-----------------------------------------------------------------*/ +void *CS_GetDefEntryAddr(CS_TableWrapper_t *tw, uint16 EntryId) +{ + uint8 *EntryAddr = tw->DefAddr; + + if (tw->DefAddr != NULL && EntryId < tw->NumEntries) + { + EntryAddr = tw->DefAddr; + EntryAddr += (tw->DefEntrySize * EntryId); + } + else + { + EntryAddr = NULL; + } + + return EntryAddr; +} + +/*---------------------------------------------------------------- + * + * Application utility function + * Gets a pointer to the given result table entry + * + *-----------------------------------------------------------------*/ +void *CS_GetResEntryAddr(CS_TableWrapper_t *tw, uint16 EntryId) +{ + uint8 *EntryAddr; + + if (tw->ResAddr != NULL && EntryId < tw->NumEntries) + { + EntryAddr = tw->ResAddr; + EntryAddr += (tw->ResEntrySize * EntryId); + } + else + { + EntryAddr = NULL; + } + + return EntryAddr; +} + +/*---------------------------------------------------------------- + * + * Local helper function + * Sets the state of a definition table entry + * + *-----------------------------------------------------------------*/ +CS_ChecksumState_Enum_t CS_SetGenericEntryState(void *EntryPtr, size_t Offset, CS_ChecksumState_Enum_t NewState) +{ + uint8 * StateAddr; + CS_ChecksumState_Enum_t PreviousDefState; + uint16 * StatePtr; + + PreviousDefState = CS_ChecksumState_UNDEFINED; + if (CS_StateValid(NewState)) + { + StateAddr = EntryPtr; + } + else + { + StateAddr = NULL; + } + + if (StateAddr != NULL) + { + StateAddr += Offset; + StatePtr = (uint16 *)(void *)StateAddr; + + PreviousDefState = *StatePtr; + if (CS_StateValid(PreviousDefState)) + { + *StatePtr = NewState; + } + } + + return PreviousDefState; +} + +/*---------------------------------------------------------------- + * + * Application utility function + * Sets the state of a definition table entry + * + *-----------------------------------------------------------------*/ +CS_ChecksumState_Enum_t CS_SetDefEntryState(CS_TableWrapper_t *tw, void *EntryPtr, CS_ChecksumState_Enum_t NewState) +{ + CS_ChecksumState_Enum_t PreviousDefState; + + PreviousDefState = CS_SetGenericEntryState(EntryPtr, tw->DefStateOffset, NewState); + if (CS_StateValid(PreviousDefState) && PreviousDefState != NewState) + { + CS_ResetTablesTblResultEntry(tw->ResTblPtr); + CFE_TBL_Modified(tw->DefHandle); + } + + return PreviousDefState; +} + /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* Gets a table type ID value as a printable string */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -const char *CS_GetTableTypeAsString(uint32 TableId) +const char *CS_GetTableTypeAsString(const CS_TableWrapper_t *tw) { const char *TableTypeStr; - switch (TableId) + switch (CS_GetTableId(tw)) { - case CS_APP_TABLE: + case CS_ChecksumType_APP_TABLE: TableTypeStr = "Apps"; break; - case CS_TABLES_TABLE: + case CS_ChecksumType_TABLES_TABLE: TableTypeStr = "Tables"; break; - case CS_EEPROM_TABLE: + case CS_ChecksumType_EEPROM_TABLE: TableTypeStr = "EEPROM"; break; - case CS_MEMORY_TABLE: + case CS_ChecksumType_MEMORY_TABLE: TableTypeStr = "Memory"; break; - case CS_CFECORE: + case CS_ChecksumType_CFECORE: TableTypeStr = "cFE Core"; break; - case CS_OSCORE: + case CS_ChecksumType_OSCORE: TableTypeStr = "OS"; break; default: @@ -84,12 +226,22 @@ const char *CS_GetTableTypeAsString(uint32 TableId) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_ZeroEepromTempValues(void) { - uint16 Loop; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr; + uint16 Loop; - for (Loop = 0; Loop < CS_MAX_NUM_EEPROM_TABLE_ENTRIES; Loop++) + Loop = 0; + while (true) { - CS_AppData.ResEepromTblPtr[Loop].TempChecksumValue = 0; - CS_AppData.ResEepromTblPtr[Loop].ByteOffset = 0; + ResEepromTblPtr = CS_GetEepromResEntry(Loop); + if (ResEepromTblPtr == NULL) + { + break; + } + + ResEepromTblPtr->TempChecksumValue = 0; + ResEepromTblPtr->ByteOffset = 0; + + ++Loop; } } @@ -100,12 +252,22 @@ void CS_ZeroEepromTempValues(void) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_ZeroMemoryTempValues(void) { - uint16 Loop; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr; + uint16 Loop; - for (Loop = 0; Loop < CS_MAX_NUM_MEMORY_TABLE_ENTRIES; Loop++) + Loop = 0; + while (true) { - CS_AppData.ResMemoryTblPtr[Loop].TempChecksumValue = 0; - CS_AppData.ResMemoryTblPtr[Loop].ByteOffset = 0; + ResMemoryTblPtr = CS_GetMemoryResEntry(Loop); + if (ResMemoryTblPtr == NULL) + { + break; + } + + ResMemoryTblPtr->TempChecksumValue = 0; + ResMemoryTblPtr->ByteOffset = 0; + + ++Loop; } } @@ -116,12 +278,22 @@ void CS_ZeroMemoryTempValues(void) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_ZeroTablesTempValues(void) { - uint16 Loop; + CS_Res_Tables_Table_Entry_t *ResTablesTblPtr; + uint16 Loop; - for (Loop = 0; Loop < CS_MAX_NUM_TABLES_TABLE_ENTRIES; Loop++) + Loop = 0; + while (true) { - CS_AppData.ResTablesTblPtr[Loop].TempChecksumValue = 0; - CS_AppData.ResTablesTblPtr[Loop].ByteOffset = 0; + ResTablesTblPtr = CS_GetTablesResEntry(Loop); + if (ResTablesTblPtr == NULL) + { + break; + } + + ResTablesTblPtr->TempChecksumValue = 0; + ResTablesTblPtr->ByteOffset = 0; + + ++Loop; } } @@ -132,12 +304,22 @@ void CS_ZeroTablesTempValues(void) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_ZeroAppTempValues(void) { - uint16 Loop; + CS_Res_App_Table_Entry_t *ResAppTblPtr; + uint16 Loop; - for (Loop = 0; Loop < CS_MAX_NUM_APP_TABLE_ENTRIES; Loop++) + Loop = 0; + while (true) { - CS_AppData.ResAppTblPtr[Loop].TempChecksumValue = 0; - CS_AppData.ResAppTblPtr[Loop].ByteOffset = 0; + ResAppTblPtr = CS_GetAppResEntry(Loop); + if (ResAppTblPtr == NULL) + { + break; + } + + ResAppTblPtr->TempChecksumValue = 0; + ResAppTblPtr->ByteOffset = 0; + + ++Loop; } } @@ -148,8 +330,13 @@ void CS_ZeroAppTempValues(void) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_ZeroCfeCoreTempValues(void) { - CS_AppData.CfeCoreCodeSeg.TempChecksumValue = 0; - CS_AppData.CfeCoreCodeSeg.ByteOffset = 0; + CS_Res_EepromMemory_Table_Entry_t *CfeCoreCodeSeg = CS_GetCfeCoreCodeSegResTable(); + + if (CfeCoreCodeSeg != NULL) + { + CfeCoreCodeSeg->TempChecksumValue = 0; + CfeCoreCodeSeg->ByteOffset = 0; + } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -159,8 +346,13 @@ void CS_ZeroCfeCoreTempValues(void) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void CS_ZeroOSTempValues(void) { - CS_AppData.OSCodeSeg.TempChecksumValue = 0; - CS_AppData.OSCodeSeg.ByteOffset = 0; + CS_Res_EepromMemory_Table_Entry_t *OSCodeSeg = CS_GetOSCodeSegResTable(); + + if (OSCodeSeg != NULL) + { + OSCodeSeg->TempChecksumValue = 0; + OSCodeSeg->ByteOffset = 0; + } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -174,27 +366,27 @@ void CS_InitializeDefaultTables(void) for (Loop = 0; Loop < CS_MAX_NUM_EEPROM_TABLE_ENTRIES; Loop++) { - CS_AppData.DefaultEepromDefTable[Loop].State = CS_STATE_EMPTY; + CS_AppData.DefaultEepromDefTable[Loop].State = CS_ChecksumState_EMPTY; CS_AppData.DefaultEepromDefTable[Loop].NumBytesToChecksum = 0; CS_AppData.DefaultEepromDefTable[Loop].StartAddress = 0; } for (Loop = 0; Loop < CS_MAX_NUM_MEMORY_TABLE_ENTRIES; Loop++) { - CS_AppData.DefaultMemoryDefTable[Loop].State = CS_STATE_EMPTY; + CS_AppData.DefaultMemoryDefTable[Loop].State = CS_ChecksumState_EMPTY; CS_AppData.DefaultMemoryDefTable[Loop].NumBytesToChecksum = 0; CS_AppData.DefaultMemoryDefTable[Loop].StartAddress = 0; } for (Loop = 0; Loop < CS_MAX_NUM_APP_TABLE_ENTRIES; Loop++) { - CS_AppData.DefaultAppDefTable[Loop].State = CS_STATE_EMPTY; + CS_AppData.DefaultAppDefTable[Loop].State = CS_ChecksumState_EMPTY; CS_AppData.DefaultAppDefTable[Loop].Name[0] = '\0'; } for (Loop = 0; Loop < CS_MAX_NUM_TABLES_TABLE_ENTRIES; Loop++) { - CS_AppData.DefaultTablesDefTable[Loop].State = CS_STATE_EMPTY; + CS_AppData.DefaultTablesDefTable[Loop].State = CS_ChecksumState_EMPTY; CS_AppData.DefaultTablesDefTable[Loop].Name[0] = '\0'; } } @@ -228,25 +420,28 @@ void CS_GoToNextTable(void) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ bool CS_GetTableResTblEntryByName(CS_Res_Tables_Table_Entry_t **EntryPtr, const char *Name) { - CS_Res_Tables_Table_Entry_t *StartOfResultsTable = NULL; - CS_Res_Tables_Table_Entry_t *ResultsEntry = NULL; + CS_Res_Tables_Table_Entry_t *ResultsEntry = NULL; int32 Loop; - uint16 MaxEntries; bool Status = false; - StartOfResultsTable = CS_AppData.ResTablesTblPtr; - MaxEntries = CS_MAX_NUM_TABLES_TABLE_ENTRIES; - - for (Loop = 0; Loop < MaxEntries; Loop++) + Loop = 0; + while (true) { - ResultsEntry = &StartOfResultsTable[Loop]; + ResultsEntry = CS_GetTablesResEntry(Loop); + if (ResultsEntry == NULL) + { + break; + } - if (strncmp(ResultsEntry->Name, Name, CFE_TBL_MAX_FULL_NAME_LEN) == 0 && ResultsEntry->State != CS_STATE_EMPTY) + if (ResultsEntry->State != CS_ChecksumState_EMPTY && + strncmp(ResultsEntry->Name, Name, CFE_TBL_MAX_FULL_NAME_LEN) == 0) { Status = true; *EntryPtr = ResultsEntry; break; } + + ++Loop; } return Status; } @@ -258,26 +453,28 @@ bool CS_GetTableResTblEntryByName(CS_Res_Tables_Table_Entry_t **EntryPtr, const /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ bool CS_GetTableDefTblEntryByName(CS_Def_Tables_Table_Entry_t **EntryPtr, const char *Name) { - CS_Def_Tables_Table_Entry_t *StartOfDefinitionTable = NULL; - CS_Def_Tables_Table_Entry_t *DefinitionEntry = NULL; + CS_Def_Tables_Table_Entry_t *DefinitionEntry = NULL; int32 Loop; - uint16 MaxEntries; bool Status = false; - StartOfDefinitionTable = CS_AppData.DefTablesTblPtr; - MaxEntries = CS_MAX_NUM_TABLES_TABLE_ENTRIES; - - for (Loop = 0; Loop < MaxEntries; Loop++) + Loop = 0; + while (true) { - DefinitionEntry = &StartOfDefinitionTable[Loop]; + DefinitionEntry = CS_GetTablesDefEntry(Loop); + if (DefinitionEntry == NULL) + { + break; + } - if (strncmp(DefinitionEntry->Name, Name, CFE_TBL_MAX_FULL_NAME_LEN) == 0 && - DefinitionEntry->State != CS_STATE_EMPTY) + if (CS_StateValid(DefinitionEntry->State) && + strncmp(DefinitionEntry->Name, Name, CFE_TBL_MAX_FULL_NAME_LEN) == 0) { Status = true; *EntryPtr = DefinitionEntry; break; } + + ++Loop; } return Status; } @@ -289,25 +486,27 @@ bool CS_GetTableDefTblEntryByName(CS_Def_Tables_Table_Entry_t **EntryPtr, const /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ bool CS_GetAppResTblEntryByName(CS_Res_App_Table_Entry_t **EntryPtr, const char *Name) { - CS_Res_App_Table_Entry_t *StartOfResultsTable = NULL; - CS_Res_App_Table_Entry_t *ResultsEntry = NULL; + CS_Res_App_Table_Entry_t *ResultsEntry = NULL; int32 Loop; - uint16 MaxEntries; bool Status = false; - StartOfResultsTable = CS_AppData.ResAppTblPtr; - MaxEntries = CS_MAX_NUM_APP_TABLE_ENTRIES; - - for (Loop = 0; Loop < MaxEntries; Loop++) + Loop = 0; + while (true) { - ResultsEntry = &StartOfResultsTable[Loop]; + ResultsEntry = CS_GetAppResEntry(Loop); + if (ResultsEntry == NULL) + { + break; + } - if (strncmp(ResultsEntry->Name, Name, OS_MAX_API_NAME) == 0 && ResultsEntry->State != CS_STATE_EMPTY) + if (ResultsEntry->State != CS_ChecksumState_EMPTY && strncmp(ResultsEntry->Name, Name, OS_MAX_API_NAME) == 0) { Status = true; *EntryPtr = ResultsEntry; break; } + + ++Loop; } return Status; } @@ -319,25 +518,27 @@ bool CS_GetAppResTblEntryByName(CS_Res_App_Table_Entry_t **EntryPtr, const char /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ bool CS_GetAppDefTblEntryByName(CS_Def_App_Table_Entry_t **EntryPtr, const char *Name) { - CS_Def_App_Table_Entry_t *StartOfDefinitionTable = NULL; - CS_Def_App_Table_Entry_t *DefinitionEntry = NULL; + CS_Def_App_Table_Entry_t *DefinitionEntry = NULL; int32 Loop; - uint16 MaxEntries; bool Status = false; - StartOfDefinitionTable = CS_AppData.DefAppTblPtr; - MaxEntries = CS_MAX_NUM_APP_TABLE_ENTRIES; - - for (Loop = 0; Loop < MaxEntries; Loop++) + Loop = 0; + while (true) { - DefinitionEntry = &StartOfDefinitionTable[Loop]; + DefinitionEntry = CS_GetAppDefEntry(Loop); + if (DefinitionEntry == NULL) + { + break; + } - if (strncmp(DefinitionEntry->Name, Name, OS_MAX_API_NAME) == 0 && DefinitionEntry->State != CS_STATE_EMPTY) + if (CS_StateValid(DefinitionEntry->State) && strncmp(DefinitionEntry->Name, Name, OS_MAX_API_NAME) == 0) { Status = true; *EntryPtr = DefinitionEntry; break; } + + ++Loop; } return Status; } @@ -347,33 +548,22 @@ bool CS_GetAppDefTblEntryByName(CS_Def_App_Table_Entry_t **EntryPtr, const char /* CS Get the next CS-enabled entry of this table */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -bool CS_FindEnabledEepromEntry(uint16 *EnabledEntry) +CS_Res_EepromMemory_Table_Entry_t *CS_FindEnabledEepromEntry(void) { - CS_Res_EepromMemory_Table_Entry_t *StartOfResultsTable = NULL; - CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; - bool EnabledEntries = true; - - StartOfResultsTable = CS_AppData.ResEepromTblPtr; - - ResultsEntry = &StartOfResultsTable[CS_AppData.HkPacket.Payload.CurrentEntryInTable]; + CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; - while (ResultsEntry->State != CS_STATE_ENABLED) + while (true) { - CS_AppData.HkPacket.Payload.CurrentEntryInTable++; - - if (CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_EEPROM_TABLE_ENTRIES) + ResultsEntry = CS_GetEepromResEntry(CS_AppData.HkPacket.Payload.CurrentEntryInTable); + if (ResultsEntry == NULL || ResultsEntry->State == CS_ChecksumState_ENABLED) { - /* we reached the end no more enabled entries */ - EnabledEntries = false; break; } - ResultsEntry = &StartOfResultsTable[CS_AppData.HkPacket.Payload.CurrentEntryInTable]; + CS_AppData.HkPacket.Payload.CurrentEntryInTable++; } /* end while */ - *EnabledEntry = CS_AppData.HkPacket.Payload.CurrentEntryInTable; - - return EnabledEntries; + return ResultsEntry; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -381,32 +571,22 @@ bool CS_FindEnabledEepromEntry(uint16 *EnabledEntry) /* CS Get the next CS-enabled entry of this table */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -bool CS_FindEnabledMemoryEntry(uint16 *EnabledEntry) +CS_Res_EepromMemory_Table_Entry_t *CS_FindEnabledMemoryEntry(void) { - CS_Res_EepromMemory_Table_Entry_t *StartOfResultsTable = NULL; - CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; - bool EnabledEntries = true; - - StartOfResultsTable = CS_AppData.ResMemoryTblPtr; - ResultsEntry = &StartOfResultsTable[CS_AppData.HkPacket.Payload.CurrentEntryInTable]; + CS_Res_EepromMemory_Table_Entry_t *ResultsEntry = NULL; - while (ResultsEntry->State != CS_STATE_ENABLED) + while (true) { - CS_AppData.HkPacket.Payload.CurrentEntryInTable++; - - if (CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_MEMORY_TABLE_ENTRIES) + ResultsEntry = CS_GetMemoryResEntry(CS_AppData.HkPacket.Payload.CurrentEntryInTable); + if (ResultsEntry == NULL || ResultsEntry->State == CS_ChecksumState_ENABLED) { - /* we reached the end no more enabled entries */ - EnabledEntries = false; break; } - ResultsEntry = &StartOfResultsTable[CS_AppData.HkPacket.Payload.CurrentEntryInTable]; + CS_AppData.HkPacket.Payload.CurrentEntryInTable++; } /* end while */ - *EnabledEntry = CS_AppData.HkPacket.Payload.CurrentEntryInTable; - - return EnabledEntries; + return ResultsEntry; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -414,97 +594,44 @@ bool CS_FindEnabledMemoryEntry(uint16 *EnabledEntry) /* CS Get the next CS-enabled entry of this table */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -bool CS_FindEnabledTablesEntry(uint16 *EnabledEntry) +CS_Res_Tables_Table_Entry_t *CS_FindEnabledTablesEntry(void) { - CS_Res_Tables_Table_Entry_t *StartOfResultsTable = NULL; - CS_Res_Tables_Table_Entry_t *ResultsEntry = NULL; - bool EnabledEntries = true; - - StartOfResultsTable = CS_AppData.ResTablesTblPtr; - ResultsEntry = &StartOfResultsTable[CS_AppData.HkPacket.Payload.CurrentEntryInTable]; + CS_Res_Tables_Table_Entry_t *ResultsEntry = NULL; - while (ResultsEntry->State != CS_STATE_ENABLED) + while (true) { - CS_AppData.HkPacket.Payload.CurrentEntryInTable++; - - if (CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_TABLES_TABLE_ENTRIES) + ResultsEntry = CS_GetTablesResEntry(CS_AppData.HkPacket.Payload.CurrentEntryInTable); + if (ResultsEntry == NULL || ResultsEntry->State == CS_ChecksumState_ENABLED) { - /* we reached the end no more enabled entries */ - EnabledEntries = false; - break; } - ResultsEntry = &StartOfResultsTable[CS_AppData.HkPacket.Payload.CurrentEntryInTable]; - + CS_AppData.HkPacket.Payload.CurrentEntryInTable++; } /* end while */ - *EnabledEntry = CS_AppData.HkPacket.Payload.CurrentEntryInTable; - - return EnabledEntries; + return ResultsEntry; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* CS Get the next CS-enabled entry of this table */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -bool CS_FindEnabledAppEntry(uint16 *EnabledEntry) +CS_Res_App_Table_Entry_t *CS_FindEnabledAppEntry(void) { - CS_Res_App_Table_Entry_t *StartOfResultsTable = NULL; - CS_Res_App_Table_Entry_t *ResultsEntry = NULL; - bool EnabledEntries = true; + CS_Res_App_Table_Entry_t *ResultsEntry = NULL; - StartOfResultsTable = CS_AppData.ResAppTblPtr; - ResultsEntry = &StartOfResultsTable[CS_AppData.HkPacket.Payload.CurrentEntryInTable]; - - while (ResultsEntry->State != CS_STATE_ENABLED) + while (true) { - CS_AppData.HkPacket.Payload.CurrentEntryInTable++; - - if (CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_APP_TABLE_ENTRIES) + ResultsEntry = CS_GetAppResEntry(CS_AppData.HkPacket.Payload.CurrentEntryInTable); + if (ResultsEntry == NULL || ResultsEntry->State == CS_ChecksumState_ENABLED) { - /* we reached the end no more enabled entries */ - EnabledEntries = false; break; } - ResultsEntry = &StartOfResultsTable[CS_AppData.HkPacket.Payload.CurrentEntryInTable]; - + CS_AppData.HkPacket.Payload.CurrentEntryInTable++; } /* end while */ - *EnabledEntry = CS_AppData.HkPacket.Payload.CurrentEntryInTable; - - return EnabledEntries; -} - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -/* */ -/* CS Verify the length of the command */ -/* */ -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ -bool CS_VerifyCmdLength(const CFE_MSG_Message_t *msg, size_t ExpectedLength) -{ - CFE_SB_MsgId_t MessageID = CFE_SB_INVALID_MSG_ID; - CFE_MSG_FcnCode_t CommandCode = 0; - bool Result = true; - size_t ActualLength = 0; - - CFE_MSG_GetSize(msg, &ActualLength); - - /* Verify the command packet length */ - if (ExpectedLength != ActualLength) - { - CFE_MSG_GetMsgId(msg, &MessageID); - CFE_MSG_GetFcnCode(msg, &CommandCode); - - CFE_EVS_SendEvent(CS_CMD_LEN_ERR_EID, CFE_EVS_EventType_ERROR, - "Invalid msg length: ID = 0x%08lX, CC = %d, Len = %lu, Expected = %lu", - (unsigned long)CFE_SB_MsgIdToValue(MessageID), CommandCode, (unsigned long)ActualLength, - (unsigned long)ExpectedLength); - Result = false; - CS_AppData.HkPacket.Payload.CmdErrCounter++; - } - return Result; + return ResultsEntry; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ @@ -520,13 +647,13 @@ bool CS_BackgroundCfeCore(void) uint32 ComputedCSValue = 0; CFE_Status_t Status; - if (CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_STATE_ENABLED) + if (CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_ChecksumState_ENABLED) { - ResultsEntry = &CS_AppData.CfeCoreCodeSeg; + ResultsEntry = CS_GetCfeCoreCodeSegResTable(); /* Check if the code segment state is enabled (could be disabled for a ground-commanded recompute) */ - if (ResultsEntry->State == CS_STATE_ENABLED) + if (ResultsEntry->State == CS_ChecksumState_ENABLED) { /* If we complete an entry's checksum, this function will update it for us */ Status = CS_ComputeEepromMemory(ResultsEntry, &ComputedCSValue, &DoneWithEntry); @@ -587,13 +714,13 @@ bool CS_BackgroundOS(void) uint32 ComputedCSValue = 0; CFE_Status_t Status; - if (CS_AppData.HkPacket.Payload.OSCSState == CS_STATE_ENABLED) + if (CS_AppData.HkPacket.Payload.OSCSState == CS_ChecksumState_ENABLED) { - ResultsEntry = &CS_AppData.OSCodeSeg; + ResultsEntry = CS_GetOSCodeSegResTable(); /* Check if the code segment state is enabled (could be disabled for a ground-commanded recompute) */ - if (ResultsEntry->State == CS_STATE_ENABLED) + if (ResultsEntry->State == CS_ChecksumState_ENABLED) { /* If we complete an entry's checksum, this function will update it for us */ Status = CS_ComputeEepromMemory(ResultsEntry, &ComputedCSValue, &DoneWithEntry); @@ -646,68 +773,77 @@ bool CS_BackgroundOS(void) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ bool CS_BackgroundEeprom(void) { - CS_Res_EepromMemory_Table_Entry_t *StartOfResultsTable; CS_Res_EepromMemory_Table_Entry_t *ResultsEntry; + CS_Res_EepromMemory_Table_Entry_t *LoopEntry; bool DoneWithCycle = false; bool DoneWithEntry = false; uint32 ComputedCSValue = 0; int32 Loop; uint32 EntireEepromCS; - uint16 CurrEntry; CFE_Status_t Status; - if (CS_AppData.HkPacket.Payload.EepromCSState == CS_STATE_ENABLED) + if (CS_AppData.HkPacket.Payload.EepromCSState == CS_ChecksumState_ENABLED) { - if (CS_FindEnabledEepromEntry(&CurrEntry) == true) - { - /* we found an enabled entry to checksum */ - StartOfResultsTable = CS_AppData.ResEepromTblPtr; - ResultsEntry = &StartOfResultsTable[CurrEntry]; + ResultsEntry = CS_FindEnabledEepromEntry(); + } + else + { + ResultsEntry = NULL; + } - /* If we complete an entry's checksum, this function will update it for us */ - Status = CS_ComputeEepromMemory(ResultsEntry, &ComputedCSValue, &DoneWithEntry); + if (ResultsEntry != NULL) + { + /* we found an enabled entry to checksum */ + /* If we complete an entry's checksum, this function will update it for us */ + Status = CS_ComputeEepromMemory(ResultsEntry, &ComputedCSValue, &DoneWithEntry); - /* We need to avoid the case of finishing a table, moving on to the next one - and computing an entry in that table, since it could put us above the - maximum bytes per cycle */ - DoneWithCycle = true; + /* We need to avoid the case of finishing a table, moving on to the next one + and computing an entry in that table, since it could put us above the + maximum bytes per cycle */ + DoneWithCycle = true; - if (Status == CS_ERROR) - { - /* we had a miscompare */ + if (Status == CS_ERROR) + { + /* we had a miscompare */ - CS_AppData.HkPacket.Payload.EepromCSErrCounter++; + CS_AppData.HkPacket.Payload.EepromCSErrCounter++; - CFE_EVS_SendEvent(CS_EEPROM_MISCOMPARE_ERR_EID, CFE_EVS_EventType_ERROR, - "Checksum Failure: Entry %d in EEPROM Table, Expected: 0x%08X, Calculated: 0x%08X", - CurrEntry, (unsigned int)(ResultsEntry->ComparisonValue), - (unsigned int)ComputedCSValue); - } + CFE_EVS_SendEvent(CS_EEPROM_MISCOMPARE_ERR_EID, CFE_EVS_EventType_ERROR, + "Checksum Failure: Address 0x%lx in EEPROM Table, Expected: 0x%08X, Calculated: 0x%08X", + (unsigned long)ResultsEntry->StartAddress, (unsigned int)(ResultsEntry->ComparisonValue), + (unsigned int)ComputedCSValue); + } - if (DoneWithEntry == true) - { - CS_AppData.HkPacket.Payload.CurrentEntryInTable++; - } + if (DoneWithEntry) + { + CS_AppData.HkPacket.Payload.CurrentEntryInTable++; } + } - if (CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_EEPROM_TABLE_ENTRIES) + if (CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_EEPROM_TABLE_ENTRIES) + { + /* Since we are done CS'ing the entire EEPROM table, update the baseline + number for telemetry */ + EntireEepromCS = 0; + Loop = 0; + while (true) { - /* Since we are done CS'ing the entire EEPROM table, update the baseline - number for telemetry */ - EntireEepromCS = 0; - for (Loop = 0; Loop < CS_MAX_NUM_EEPROM_TABLE_ENTRIES; Loop++) + LoopEntry = CS_GetEepromResEntry(Loop); + if (LoopEntry == NULL) { - EntireEepromCS += CS_AppData.ResEepromTblPtr[Loop].ComparisonValue; + break; } - CS_AppData.HkPacket.Payload.EepromBaseline = EntireEepromCS; - - /* We are done with this table */ - CS_GoToNextTable(); + EntireEepromCS += LoopEntry->ComparisonValue; + ++Loop; } + + CS_AppData.HkPacket.Payload.EepromBaseline = EntireEepromCS; } - else /* Table is disabled, skip it */ + + if (ResultsEntry == NULL || CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_EEPROM_TABLE_ENTRIES) { + /* We are done with this table */ CS_GoToNextTable(); } @@ -721,62 +857,54 @@ bool CS_BackgroundEeprom(void) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ bool CS_BackgroundMemory(void) { - CS_Res_EepromMemory_Table_Entry_t *StartOfResultsTable; CS_Res_EepromMemory_Table_Entry_t *ResultsEntry; bool DoneWithCycle = false; bool DoneWithEntry = false; uint32 ComputedCSValue = 0; - uint16 CurrEntry; CFE_Status_t Status; - if (CS_AppData.HkPacket.Payload.MemoryCSState == CS_STATE_ENABLED) + if (CS_AppData.HkPacket.Payload.MemoryCSState == CS_ChecksumState_ENABLED) { /* If we complete an entry's checksum, this function will update it for us */ + ResultsEntry = CS_FindEnabledMemoryEntry(); + } + else + { + ResultsEntry = NULL; + } - if (CS_FindEnabledMemoryEntry(&CurrEntry) == true) - { - /* we found an enabled entry to checksum */ - StartOfResultsTable = CS_AppData.ResMemoryTblPtr; - ResultsEntry = &StartOfResultsTable[CurrEntry]; - - /* If we complete an entry's checksum, this function will update it for us */ - Status = CS_ComputeEepromMemory(ResultsEntry, &ComputedCSValue, &DoneWithEntry); - - /* We need to avoid the case of finishing a table, moving on to the next one - and computing an entry in that table, since it could put us above the - maximum bytes per cycle */ - DoneWithCycle = true; + if (ResultsEntry != NULL) + { + /* we found an enabled entry to checksum */ + /* If we complete an entry's checksum, this function will update it for us */ + Status = CS_ComputeEepromMemory(ResultsEntry, &ComputedCSValue, &DoneWithEntry); - if (Status == CS_ERROR) - { - /* we had a miscompare */ + /* We need to avoid the case of finishing a table, moving on to the next one + and computing an entry in that table, since it could put us above the + maximum bytes per cycle */ + DoneWithCycle = true; - CS_AppData.HkPacket.Payload.MemoryCSErrCounter++; + if (Status == CS_ERROR) + { + /* we had a miscompare */ - CFE_EVS_SendEvent(CS_MEMORY_MISCOMPARE_ERR_EID, CFE_EVS_EventType_ERROR, - "Checksum Failure: Entry %d in Memory Table, Expected: 0x%08X, Calculated: 0x%08X", - CurrEntry, (unsigned int)(ResultsEntry->ComparisonValue), - (unsigned int)ComputedCSValue); - } + CS_AppData.HkPacket.Payload.MemoryCSErrCounter++; - if (DoneWithEntry == true) - { - CS_AppData.HkPacket.Payload.CurrentEntryInTable++; - } - - if (CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_MEMORY_TABLE_ENTRIES) - { - /* We are done with this table */ - CS_GoToNextTable(); - } + CFE_EVS_SendEvent(CS_MEMORY_MISCOMPARE_ERR_EID, CFE_EVS_EventType_ERROR, + "Checksum Failure: Address 0x%lx in Memory Table, Expected: 0x%08X, Calculated: 0x%08X", + (unsigned long)ResultsEntry->StartAddress, (unsigned int)(ResultsEntry->ComparisonValue), + (unsigned int)ComputedCSValue); } - else /* since there aren't any enabled entries in this table, go to the next one */ + + if (DoneWithEntry) { - CS_GoToNextTable(); + CS_AppData.HkPacket.Payload.CurrentEntryInTable++; } } - else /* Table is disabled, skip it */ + + if (ResultsEntry == NULL || CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_MEMORY_TABLE_ENTRIES) { + /* We are done with this table */ CS_GoToNextTable(); } @@ -790,70 +918,62 @@ bool CS_BackgroundMemory(void) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ bool CS_BackgroundTables(void) { - CS_Res_Tables_Table_Entry_t *StartOfTablesResultsTable; CS_Res_Tables_Table_Entry_t *TablesResultsEntry; bool DoneWithCycle = false; bool DoneWithEntry = false; uint32 ComputedCSValue = 0; - uint16 CurrEntry; CFE_Status_t Status; - if (CS_AppData.HkPacket.Payload.TablesCSState == CS_STATE_ENABLED) + if (CS_AppData.HkPacket.Payload.TablesCSState == CS_ChecksumState_ENABLED) { /* If we complete an entry's checksum, this function will update it for us */ + TablesResultsEntry = CS_FindEnabledTablesEntry(); + } + else + { + TablesResultsEntry = NULL; + } - if (CS_FindEnabledTablesEntry(&CurrEntry) == true) - { - /* we found an enabled entry to checksum */ - - StartOfTablesResultsTable = CS_AppData.ResTablesTblPtr; - TablesResultsEntry = &StartOfTablesResultsTable[CurrEntry]; - - Status = CS_ComputeTables(TablesResultsEntry, &ComputedCSValue, &DoneWithEntry); - - /* We need to avoid the case of finishing a table, moving on to the next one - and computing an entry in that table, since it could put us above the - maximum bytes per cycle */ - DoneWithCycle = true; - - if (Status == CS_ERROR) - { - /* we had a miscompare */ - CS_AppData.HkPacket.Payload.TablesCSErrCounter++; + if (TablesResultsEntry != NULL) + { + /* we found an enabled entry to checksum */ + Status = CS_ComputeTables(TablesResultsEntry, &ComputedCSValue, &DoneWithEntry); - CFE_EVS_SendEvent(CS_TABLES_MISCOMPARE_ERR_EID, CFE_EVS_EventType_ERROR, - "Checksum Failure: Table %s, Expected: 0x%08X, Calculated: 0x%08X", - TablesResultsEntry->Name, (unsigned int)(TablesResultsEntry->ComparisonValue), - (unsigned int)ComputedCSValue); - } + /* We need to avoid the case of finishing a table, moving on to the next one + and computing an entry in that table, since it could put us above the + maximum bytes per cycle */ + DoneWithCycle = true; - if (Status == CS_ERR_NOT_FOUND) - { - CFE_EVS_SendEvent(CS_COMPUTE_TABLES_NOT_FOUND_ERR_EID, CFE_EVS_EventType_ERROR, - "Tables table computing: Table %s could not be found, skipping", - TablesResultsEntry->Name); + if (Status == CS_ERROR) + { + /* we had a miscompare */ + CS_AppData.HkPacket.Payload.TablesCSErrCounter++; - CS_AppData.HkPacket.Payload.CurrentEntryInTable++; - } + CFE_EVS_SendEvent(CS_TABLES_MISCOMPARE_ERR_EID, CFE_EVS_EventType_ERROR, + "Checksum Failure: Table %s, Expected: 0x%08X, Calculated: 0x%08X", + TablesResultsEntry->Name, (unsigned int)(TablesResultsEntry->ComparisonValue), + (unsigned int)ComputedCSValue); + } - if (DoneWithEntry == true) - { - CS_AppData.HkPacket.Payload.CurrentEntryInTable++; - } + if (Status == CS_ERR_NOT_FOUND) + { + CFE_EVS_SendEvent(CS_COMPUTE_TABLES_NOT_FOUND_ERR_EID, CFE_EVS_EventType_ERROR, + "Tables table computing: Table %s could not be found, skipping", + TablesResultsEntry->Name); - if (CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_TABLES_TABLE_ENTRIES) - { - /* We are done with this table */ - CS_GoToNextTable(); - } + DoneWithEntry = true; } - else /* since there aren't any enabled entries in this table, go to the next one */ + + if (DoneWithEntry) { - CS_GoToNextTable(); + CS_AppData.HkPacket.Payload.CurrentEntryInTable++; } } - else /* Table is disabled, skip it */ + + if (TablesResultsEntry == NULL || + CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_TABLES_TABLE_ENTRIES) { + /* We are done with this table */ CS_GoToNextTable(); } @@ -867,70 +987,63 @@ bool CS_BackgroundTables(void) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ bool CS_BackgroundApp(void) { - CS_Res_App_Table_Entry_t *StartOfAppResultsTable; CS_Res_App_Table_Entry_t *AppResultsEntry; bool DoneWithCycle = false; bool DoneWithEntry = false; uint32 ComputedCSValue = 0; - uint16 CurrEntry; CFE_Status_t Status; - if (CS_AppData.HkPacket.Payload.AppCSState == CS_STATE_ENABLED) + if (CS_AppData.HkPacket.Payload.AppCSState == CS_ChecksumState_ENABLED) { - if (CS_FindEnabledAppEntry(&CurrEntry) == true) - { - /* we found an enabled entry to checksum */ - - StartOfAppResultsTable = CS_AppData.ResAppTblPtr; - AppResultsEntry = &StartOfAppResultsTable[CurrEntry]; - - /* If we complete an entry's checksum, this function will update it for us */ - Status = CS_ComputeApp(AppResultsEntry, &ComputedCSValue, &DoneWithEntry); - - /* We need to avoid the case of finishing a table, moving on to the next one - and computing an entry in that table, since it could put us above the - maximum bytes per cycle */ - DoneWithCycle = true; + AppResultsEntry = CS_FindEnabledAppEntry(); + } + else + { + AppResultsEntry = NULL; + } - if (Status == CS_ERROR) - { - /* we had a miscompare */ - CS_AppData.HkPacket.Payload.AppCSErrCounter++; + if (AppResultsEntry != NULL) + { + /* we found an enabled entry to checksum */ + /* If we complete an entry's checksum, this function will update it for us */ + Status = CS_ComputeApp(AppResultsEntry, &ComputedCSValue, &DoneWithEntry); - CFE_EVS_SendEvent(CS_APP_MISCOMPARE_ERR_EID, CFE_EVS_EventType_ERROR, - "Checksum Failure: Application %s, Expected: 0x%08X, Calculated: 0x%08X", - AppResultsEntry->Name, (unsigned int)(AppResultsEntry->ComparisonValue), - (unsigned int)ComputedCSValue); - } + /* We need to avoid the case of finishing a table, moving on to the next one + and computing an entry in that table, since it could put us above the + maximum bytes per cycle */ + DoneWithCycle = true; - if (Status == CS_ERR_NOT_FOUND) - { - CFE_EVS_SendEvent(CS_COMPUTE_APP_NOT_FOUND_ERR_EID, CFE_EVS_EventType_ERROR, - "App table computing: App %s could not be found, skipping", AppResultsEntry->Name); + if (Status == CS_ERROR) + { + /* we had a miscompare */ + CS_AppData.HkPacket.Payload.AppCSErrCounter++; - CS_AppData.HkPacket.Payload.CurrentEntryInTable++; - } + CFE_EVS_SendEvent(CS_APP_MISCOMPARE_ERR_EID, CFE_EVS_EventType_ERROR, + "Checksum Failure: Application %s, Expected: 0x%08X, Calculated: 0x%08X", + AppResultsEntry->Name, (unsigned int)(AppResultsEntry->ComparisonValue), + (unsigned int)ComputedCSValue); + } - if (DoneWithEntry == true) - { - CS_AppData.HkPacket.Payload.CurrentEntryInTable++; - } + if (Status == CS_ERR_NOT_FOUND) + { + CFE_EVS_SendEvent(CS_COMPUTE_APP_NOT_FOUND_ERR_EID, CFE_EVS_EventType_ERROR, + "App table computing: App %s could not be found, skipping", AppResultsEntry->Name); - if (CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_APP_TABLE_ENTRIES) - { - /* We are done with this table */ - CS_GoToNextTable(); - } + DoneWithEntry = true; } - else /* since there aren't any enabled entries in this table, go to the next one */ + + if (DoneWithEntry) { - CS_GoToNextTable(); + CS_AppData.HkPacket.Payload.CurrentEntryInTable++; } } - else /* Table is disabled, skip it */ + + if (AppResultsEntry == NULL || CS_AppData.HkPacket.Payload.CurrentEntryInTable >= CS_MAX_NUM_APP_TABLE_ENTRIES) { + /* We are done with this table */ CS_GoToNextTable(); } + return DoneWithCycle; } @@ -942,7 +1055,7 @@ bool CS_BackgroundApp(void) void CS_ResetTablesTblResultEntry(CS_Res_Tables_Table_Entry_t *TablesTblResultEntry) { /* Ptr will be NULL if this CS table is not listed in the CS Tables table */ - if (TablesTblResultEntry != (CS_Res_Tables_Table_Entry_t *)NULL) + if (TablesTblResultEntry != NULL) { TablesTblResultEntry->ByteOffset = 0; TablesTblResultEntry->TempChecksumValue = 0; @@ -957,116 +1070,68 @@ void CS_ResetTablesTblResultEntry(CS_Res_Tables_Table_Entry_t *TablesTblResultEn /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ CFE_Status_t CS_HandleRoutineTableUpdates(void) { - CFE_Status_t Result = CFE_SUCCESS; - CFE_Status_t ErrorCode = CFE_SUCCESS; - - if (!((CS_AppData.HkPacket.Payload.RecomputeInProgress == true) && - (CS_AppData.HkPacket.Payload.OneShotInProgress == false) && (CS_AppData.ChildTaskTable == CS_EEPROM_TABLE))) + CFE_Status_t Result = CFE_SUCCESS; + uint16 TableId; + CS_TableWrapper_t *tw; + bool ShouldProcess; + + static const uint16 EventIdMap[CS_NUM_TABLES] = { + [CS_ChecksumType_EEPROM_TABLE] = CS_UPDATE_EEPROM_ERR_EID, + [CS_ChecksumType_MEMORY_TABLE] = CS_UPDATE_MEMORY_ERR_EID, + [CS_ChecksumType_TABLES_TABLE] = CS_UPDATE_TABLES_ERR_EID, + [CS_ChecksumType_APP_TABLE] = CS_UPDATE_APP_ERR_EID, + }; + + for (TableId = 0; TableId < CS_NUM_TABLES; ++TableId) { - Result = CS_HandleTableUpdate((void **)&CS_AppData.DefEepromTblPtr, (void **)&CS_AppData.ResEepromTblPtr, - CS_AppData.DefEepromTableHandle, CS_AppData.ResEepromTableHandle, CS_EEPROM_TABLE, - CS_MAX_NUM_EEPROM_TABLE_ENTRIES); + tw = &CS_AppData.Tbl[TableId]; - if (Result != CFE_SUCCESS) + if (tw->DefEntrySize == 0) { - CS_AppData.HkPacket.Payload.EepromCSState = CS_STATE_DISABLED; - Result = CFE_EVS_SendEvent(CS_UPDATE_EEPROM_ERR_EID, CFE_EVS_EventType_ERROR, - "Table update failed for EEPROM: 0x%08X, checksumming EEPROM is disabled", - (unsigned int)Result); - ErrorCode = Result; + /* There is no table to update */ + ShouldProcess = false; } - } - - if (!((CS_AppData.HkPacket.Payload.RecomputeInProgress == true) && - (CS_AppData.HkPacket.Payload.OneShotInProgress == false) && (CS_AppData.ChildTaskTable == CS_MEMORY_TABLE))) - { - Result = CS_HandleTableUpdate((void **)&CS_AppData.DefMemoryTblPtr, (void **)&CS_AppData.ResMemoryTblPtr, - CS_AppData.DefMemoryTableHandle, CS_AppData.ResMemoryTableHandle, CS_MEMORY_TABLE, - CS_MAX_NUM_MEMORY_TABLE_ENTRIES); - if (Result != CFE_SUCCESS) + else if (!CS_AppData.HkPacket.Payload.RecomputeInProgress || CS_AppData.HkPacket.Payload.OneShotInProgress) { - CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_DISABLED; - Result = CFE_EVS_SendEvent(CS_UPDATE_MEMORY_ERR_EID, CFE_EVS_EventType_ERROR, - "Table update failed for Memory: 0x%08X, checksumming Memory is disabled", - (unsigned int)Result); - - if (ErrorCode == CFE_SUCCESS) - { - ErrorCode = Result; - } + /* Always update */ + ShouldProcess = true; } - } - - if (!((CS_AppData.HkPacket.Payload.RecomputeInProgress == true) && - (CS_AppData.HkPacket.Payload.OneShotInProgress == false) && (CS_AppData.ChildTaskTable == CS_APP_TABLE))) - { - Result = CS_HandleTableUpdate((void **)&CS_AppData.DefAppTblPtr, (void **)&CS_AppData.ResAppTblPtr, - CS_AppData.DefAppTableHandle, CS_AppData.ResAppTableHandle, CS_APP_TABLE, - CS_MAX_NUM_APP_TABLE_ENTRIES); - if (Result != CFE_SUCCESS) + else { - CS_AppData.HkPacket.Payload.AppCSState = CS_STATE_DISABLED; - Result = CFE_EVS_SendEvent(CS_UPDATE_APP_ERR_EID, CFE_EVS_EventType_ERROR, - "Table update failed for Apps: 0x%08X, checksumming Apps is disabled", - (unsigned int)Result); - if (ErrorCode == CFE_SUCCESS) - { - ErrorCode = Result; - } + /* Do not process if the child task owns this table */ + ShouldProcess = (CS_AppData.ChildTaskTable != TableId); } - } - if (!((CS_AppData.HkPacket.Payload.RecomputeInProgress == true) && - (CS_AppData.HkPacket.Payload.OneShotInProgress == false) && (CS_AppData.ChildTaskTable == CS_TABLES_TABLE))) - { - Result = CS_HandleTableUpdate((void **)&CS_AppData.DefTablesTblPtr, (void **)&CS_AppData.ResTablesTblPtr, - CS_AppData.DefTablesTableHandle, CS_AppData.ResTablesTableHandle, CS_TABLES_TABLE, - CS_MAX_NUM_TABLES_TABLE_ENTRIES); + if (ShouldProcess) + { + Result = CS_HandleTableUpdate(tw); + } + else + { + Result = CFE_SUCCESS; + } if (Result != CFE_SUCCESS) { - CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_DISABLED; - Result = CFE_EVS_SendEvent(CS_UPDATE_TABLES_ERR_EID, CFE_EVS_EventType_ERROR, - "Table update failed for Tables: 0x%08X, checksumming Tables is disabled", - (unsigned int)Result); - if (ErrorCode == CFE_SUCCESS) + CFE_EVS_SendEvent(EventIdMap[TableId], CFE_EVS_EventType_ERROR, + "Table update failed for %s: 0x%08X, checksumming is disabled", + CS_GetTableTypeAsString(tw), (unsigned int)Result); + + if (tw->GlobalState) { - ErrorCode = Result; + *tw->GlobalState = CS_ChecksumState_DISABLED; } } } - return ErrorCode; -} - -CFE_Status_t CS_AttemptTableReshare(CS_Res_Tables_Table_Entry_t *ResultsEntry, CFE_TBL_Handle_t *LocalTblHandle, - CFE_TBL_Info_t *TblInfo, cpuaddr *LocalAddress, int32 *ResultGetInfo) -{ - CFE_Status_t Result; - - /* Maybe the table came back, try and reshare it */ - Result = CFE_TBL_Share(LocalTblHandle, ResultsEntry->Name); - - if (Result == CFE_SUCCESS) - { - ResultsEntry->TblHandle = *LocalTblHandle; - - *ResultGetInfo = CFE_TBL_GetInfo(TblInfo, ResultsEntry->Name); - - /* need to try to get the address again */ - Result = CFE_TBL_GetAddress((void *)LocalAddress, *LocalTblHandle); - - /* if the table was never loaded, release the address to prevent the table from being - locked by CS, which would prevent the owner app from updating it*/ - if (Result == CFE_TBL_ERR_NEVER_LOADED) - { - CFE_TBL_ReleaseAddress(*LocalTblHandle); - } - } - - return Result; + return CFE_SUCCESS; } +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ +/* */ +/* Check if one shot recompute is already in progress */ +/* */ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ bool CS_CheckRecomputeOneshot(void) { bool Result = false; diff --git a/fsw/src/cs_utils.h b/fsw/src/cs_utils.h index 5c0aa61..dd2d98e 100644 --- a/fsw/src/cs_utils.h +++ b/fsw/src/cs_utils.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -30,16 +29,24 @@ ** **************************************************************************/ #include "cfe.h" -#include "cs_tbldefs.h" +#include "cs_tbl.h" +#include "cs_table_processing.h" +#include "cs_app.h" + +/************************************************************************** + ** + ** Utility function declarations + ** + **************************************************************************/ /** - * \brief Converts the numeric table ID to a string for logging + * \brief Converts the table reference to a string for logging * - * \param [in] TableId Numeric identifier of table + * \param [in] Tbl Pointer to global table wrapper struct * * \return Pointer to printable string (never NULL) */ -const char *CS_GetTableTypeAsString(uint32 TableId); +const char *CS_GetTableTypeAsString(const CS_TableWrapper_t *Tbl); /** * \brief Zeros out temporary checksum values of EEPROM table entries @@ -255,19 +262,10 @@ bool CS_GetAppDefTblEntryByName(CS_Def_App_Table_Entry_t **EntryPtr, const char * \par Assumptions, External Events, and Notes: * None * - * \param [in] EnabledEntry A pointer to a uint16 that will be - * assigned an enabled entry ID, if - * one exists. Calling function ensures - * this is non-null. - * - * \param [out] * EnabledEntry The ID of an enabled entry in the - * table, if the function resturs true - * - * \return Boolean entry found response - * \retval true Entry was found in the table - * \retval false Entry was not found in the table + * \return Pointer to next entry + * \retval NULL if no enabled entry was found */ -bool CS_FindEnabledEepromEntry(uint16 *EnabledEntry); +CS_Res_EepromMemory_Table_Entry_t *CS_FindEnabledEepromEntry(void); /** * \brief Find an enabled Memory entry @@ -279,19 +277,10 @@ bool CS_FindEnabledEepromEntry(uint16 *EnabledEntry); * \par Assumptions, External Events, and Notes: * None * - * \param [in] EnabledEntry A pointer to a uint16 that will be - * assigned an enabled entry ID, if - * one exists. Calling function ensures - * this is non-null. - * - * \param [out] * EnabledEntry The ID of an enabled entry in the - * table, if the function resturs true - * - * \return Boolean enabled entry found response - * \retval true Enabled entry was found in the table - * \retval false Enabled entry was not found in the table + * \return Pointer to next entry + * \retval NULL if no enabled entry was found */ -bool CS_FindEnabledMemoryEntry(uint16 *EnabledEntry); +CS_Res_EepromMemory_Table_Entry_t *CS_FindEnabledMemoryEntry(void); /** * \brief Find an enabled Tables entry @@ -303,19 +292,10 @@ bool CS_FindEnabledMemoryEntry(uint16 *EnabledEntry); * \par Assumptions, External Events, and Notes: * None * - * \param [in] EnabledEntry A pointer to a uint16 that will be - * assigned an enabled entry ID, if - * one exists. Calling function ensures - * this is non-null. - * - * \param [out] * EnabledEntry The ID of an enabled entry in the - * table, if the function resturs true - * - * \return Boolean enabled entry found response - * \retval true Enabled entry was found in the table - * \retval false Enabled entry was not found in the table + * \return Pointer to next entry + * \retval NULL if no enabled entry was found */ -bool CS_FindEnabledTablesEntry(uint16 *EnabledEntry); +CS_Res_Tables_Table_Entry_t *CS_FindEnabledTablesEntry(void); /** * \brief Find an enabled App entry @@ -327,46 +307,10 @@ bool CS_FindEnabledTablesEntry(uint16 *EnabledEntry); * \par Assumptions, External Events, and Notes: * None * - * \param [in] EnabledEntry A pointer to a uint16 that will be - * assigned an enabled entry ID, if - * one exists. Calling function ensures - * this is non-null. - * - * \param [out] * EnabledEntry The ID of an enabled entry in the - * table, if the function resturs true - * - * \return Boolean enabled entry found response - * \retval true Enabled entry was found in the table - * \retval false Enabled entry was not found in the table + * \return Pointer to next entry + * \retval NULL if no enabled entry was found */ -bool CS_FindEnabledAppEntry(uint16 *EnabledEntry); - -/** - * \brief Verify command message length - * - * \par Description - * This routine will check if the actual length of a software bus - * command message matches the expected length and send an - * error event message if a mismatch occurs - * - * \par Assumptions, External Events, and Notes: - * None - * - * \param [in] msg A #CFE_MSG_Message_t* pointer that - * references the software bus message. - * Calling function ensures this is - * non-null. - * - * \param [in] ExpectedLength The expected length of the message - * based upon the command code - * - * \return Boolean length valid response - * \retval true Message length matches ExpectedLength - * \retval false Message length ExpectedLength mismatch - * - * \sa #CS_CMD_LEN_ERR_EID - */ -bool CS_VerifyCmdLength(const CFE_MSG_Message_t *msg, size_t ExpectedLength); +CS_Res_App_Table_Entry_t *CS_FindEnabledAppEntry(void); /** * \brief Compute a background check cycle on the OS @@ -492,23 +436,291 @@ void CS_ResetTablesTblResultEntry(CS_Res_Tables_Table_Entry_t *TablesTblResultEn CFE_Status_t CS_HandleRoutineTableUpdates(void); /** - * \brief Attempts to re-share a table + * \brief Check if one shot recompute is in progress * * \par Description - * This function is called if the first attempt to share the table - * is unsuccessful. This function attempts to share the table again - * to see if it reappeared. Calling function ensures that parameters - * are non-null. + * Checks that the one shot is NOT currently running * * \par Assumptions, External Events, and Notes: * None * - * \return Execution status, see \ref CFEReturnCodes - * \retval #CFE_SUCCESS \copybrief CFE_SUCCESS + * \retval true if one shot recompute is in progress + * \retval false if one shot recompute is not in progress */ -CFE_Status_t CS_AttemptTableReshare(CS_Res_Tables_Table_Entry_t *ResultsEntry, CFE_TBL_Handle_t *LocalTblHandle, - CFE_TBL_Info_t *TblInfo, cpuaddr *LocalAddress, int32 *ResultGetInfo); - bool CS_CheckRecomputeOneshot(void); +/** + * \brief Switches definition state between ENABLED and DISABLED + * + * \par Description + * Changes the state of the definition table entry to the indicated value + * If the state within the definition table is not valid then the state is + * not changed, it will remain at the previous value. + * + * If this resulted in an actual change to the definition table, then the + * table is marked as modified within table services. + * + * \par Assumptions, External Events, and Notes: + * None + * + * \param tw Pointer to table wrapper struct + * \param EntryPtr Pointer to entry within definition table + * \param NewState value to set the "State" field to (Must be ENABLED or DISABLED) + * + * \returns Previous state of table entry + */ +CS_ChecksumState_Enum_t CS_SetDefEntryState(CS_TableWrapper_t *tw, void *EntryPtr, CS_ChecksumState_Enum_t NewState); + +/** + * \brief Checks if the definition table matches the given name + * + * \par Description + * Checks if the passed-in name matches the name of the definition table + * for the given table ID + * + * \par Assumptions, External Events, and Notes: + * None + * + * \param Name Name of table + * \param TableIdx Identifier of global table + * + * \retval true if name matches + * \retval false if name does not match + */ +bool CS_CheckDefTableNameMatch(const char *Name, uint16 TableIdx); + +/** + * \brief Checks if the result table matches the given name + * + * \par Description + * Checks if the passed-in name matches the name of the result table + * for the given table ID + * + * \par Assumptions, External Events, and Notes: + * None + * + * \param Name Name of table + * \param TableIdx Identifier of global table + * + * \retval true if name matches + * \retval false if name does not match + */ +bool CS_CheckResTableNameMatch(const char *Name, uint16 TableIdx); + +/** + * \brief Gets the address of the specified definition table entry + * + * \par Description + * Computes and returns a pointer to the specified definition table entry + * + * \par Assumptions, External Events, and Notes: + * The returned pointer is generic and must be cast to the correct + * structure type depending on which table is being accessed. + * + * \param tw Pointer to global table wrapper + * \param EntryIdx Index of entry to locate + * + * \returns Pointer to definition table entry + * \retval NULL if the entry index is out of range + */ +void *CS_GetDefEntryAddr(CS_TableWrapper_t *tw, uint16 EntryIdx); + +/** + * \brief Gets the address of the specified result table entry + * + * \par Description + * Computes and returns a pointer to the specified result table entry + * + * \par Assumptions, External Events, and Notes: + * The returned pointer is generic and must be cast to the correct + * structure type depending on which table is being accessed. + * + * \param tw Pointer to global table wrapper + * \param EntryIdx Index of entry to locate + * + * \returns Pointer to result table entry + * \retval NULL if the entry index is out of range + */ +void *CS_GetResEntryAddr(CS_TableWrapper_t *tw, uint16 EntryIdx); + +/************************************************************************** + ** + ** Helper functions (inline) + ** These exist to consolidate repetitive logic and make the code more readable + ** + **************************************************************************/ + +/** + * \brief Checks that a state value is ENABLED and DISABLED + * + * \par Description + * A configured table entry must be set to ENABLED or DISABLED only. + * This confirms that the state is one of those two values. + * + * \par Assumptions, External Events, and Notes: + * EMPTY is allowed for unused entries. A check for empty entries + * must be done separately. + * + * \param State State value to test + * + * \retval true if state is ENABLED or DISABLED + * \retval false if state is anything else + */ +static inline bool CS_StateValid(CS_ChecksumState_Enum_t State) +{ + return (State == CS_ChecksumState_ENABLED || State == CS_ChecksumState_DISABLED); +} + +/** + * \brief Gets a pointer to the EEPROM checksum definition for the given index + * + * \par Description + * Gets a pointer to the definition table entry + * + * \par Assumptions, External Events, and Notes: + * Returns NULL if the entry index is out of range + * + * \param EntryIdx Index of entry to locate + * + * \returns Pointer to definition table entry, if index is valid + * \retval NULL if index is invalid + */ +static inline CS_Def_EepromMemory_Table_Entry_t *CS_GetEepromDefEntry(uint16 EntryIdx) +{ + return CS_GetDefEntryAddr(&CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE], EntryIdx); +} + +/** + * \brief Gets a pointer to the EEPROM checksum result for the given index + * + * \par Description + * Gets a pointer to the result table entry + * + * \par Assumptions, External Events, and Notes: + * Returns NULL if the entry index is out of range + * + * \param EntryIdx Index of entry to locate + * + * \returns Pointer to result table entry, if index is valid + * \retval NULL if index is invalid + */ +static inline CS_Res_EepromMemory_Table_Entry_t *CS_GetEepromResEntry(uint16 EntryIdx) +{ + return CS_GetResEntryAddr(&CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE], EntryIdx); +} + +/** + * \brief Gets a pointer to the Memory checksum definition for the given index + * + * \par Description + * Gets a pointer to the definition table entry + * + * \par Assumptions, External Events, and Notes: + * Returns NULL if the entry index is out of range + * + * \param EntryIdx Index of entry to locate + * + * \returns Pointer to definition table entry, if index is valid + * \retval NULL if index is invalid + */ +static inline CS_Def_EepromMemory_Table_Entry_t *CS_GetMemoryDefEntry(uint16 EntryIdx) +{ + return CS_GetDefEntryAddr(&CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE], EntryIdx); +} + +/** + * \brief Gets a pointer to the Memory checksum result for the given index + * + * \par Description + * Gets a pointer to the result table entry + * + * \par Assumptions, External Events, and Notes: + * Returns NULL if the entry index is out of range + * + * \param EntryIdx Index of entry to locate + * + * \returns Pointer to result table entry, if index is valid + * \retval NULL if index is invalid + */ +static inline CS_Res_EepromMemory_Table_Entry_t *CS_GetMemoryResEntry(uint16 EntryIdx) +{ + return CS_GetResEntryAddr(&CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE], EntryIdx); +} + +/** + * \brief Gets a pointer to the Table checksum definition for the given index + * + * \par Description + * Gets a pointer to the definition table entry + * + * \par Assumptions, External Events, and Notes: + * Returns NULL if the entry index is out of range + * + * \param EntryIdx Index of entry to locate + * + * \returns Pointer to definition table entry, if index is valid + * \retval NULL if index is invalid + */ +static inline CS_Def_Tables_Table_Entry_t *CS_GetTablesDefEntry(uint16 EntryIdx) +{ + return CS_GetDefEntryAddr(&CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE], EntryIdx); +} + +/** + * \brief Gets a pointer to the Table checksum result for the given index + * + * \par Description + * Gets a pointer to the result table entry + * + * \par Assumptions, External Events, and Notes: + * Returns NULL if the entry index is out of range + * + * \param EntryIdx Index of entry to locate + * + * \returns Pointer to result table entry, if index is valid + * \retval NULL if index is invalid + */ +static inline CS_Res_Tables_Table_Entry_t *CS_GetTablesResEntry(uint16 EntryIdx) +{ + return CS_GetResEntryAddr(&CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE], EntryIdx); +} + +/** + * \brief Gets a pointer to the App checksum definition for the given index + * + * \par Description + * Gets a pointer to the definition table entry + * + * \par Assumptions, External Events, and Notes: + * Returns NULL if the entry index is out of range + * + * \param EntryIdx Index of entry to locate + * + * \returns Pointer to definition table entry, if index is valid + * \retval NULL if index is invalid + */ +static inline CS_Def_App_Table_Entry_t *CS_GetAppDefEntry(uint16 EntryIdx) +{ + return CS_GetDefEntryAddr(&CS_AppData.Tbl[CS_ChecksumType_APP_TABLE], EntryIdx); +} + +/** + * \brief Gets a pointer to the App checksum result for the given index + * + * \par Description + * Gets a pointer to the result table entry + * + * \par Assumptions, External Events, and Notes: + * Returns NULL if the entry index is out of range + * + * \param EntryIdx Index of entry to locate + * + * \returns Pointer to result table entry, if index is valid + * \retval NULL if index is invalid + */ +static inline CS_Res_App_Table_Entry_t *CS_GetAppResEntry(uint16 EntryIdx) +{ + return CS_GetResEntryAddr(&CS_AppData.Tbl[CS_ChecksumType_APP_TABLE], EntryIdx); +} + #endif diff --git a/fsw/src/cs_verify.h b/fsw/src/cs_verify.h index 09e836e..0d0d44c 100644 --- a/fsw/src/cs_verify.h +++ b/fsw/src/cs_verify.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * diff --git a/fsw/src/cs_version.h b/fsw/src/cs_version.h index 5fe7269..df40326 100644 --- a/fsw/src/cs_version.h +++ b/fsw/src/cs_version.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -30,9 +29,9 @@ * \{ */ -#define CS_MAJOR_VERSION 2 /**< \brief Major version number */ -#define CS_MINOR_VERSION 5 /**< \brief Minor version number */ -#define CS_REVISION 99 /**< \brief Revision number */ +#define CS_MAJOR_VERSION 7 /**< \brief Major version number */ +#define CS_MINOR_VERSION 0 /**< \brief Minor version number */ +#define CS_REVISION 0 /**< \brief Revision number */ /**\}*/ diff --git a/fsw/tables/cs_apptbl.c b/fsw/tables/cs_apptbl.c index 512a753..2ad8130 100644 --- a/fsw/tables/cs_apptbl.c +++ b/fsw/tables/cs_apptbl.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -33,30 +32,30 @@ CS_Def_App_Table_Entry_t CS_AppTable[CS_MAX_NUM_APP_TABLE_ENTRIES] = { /* State Name */ - /* 0 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 1 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 2 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 3 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 4 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 5 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 6 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 7 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 8 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 9 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 10 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 11 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 12 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 13 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 14 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 15 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 16 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 17 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 18 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 19 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 20 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 21 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 22 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 23 */ {.State = CS_STATE_EMPTY, .Name = ""}}; + /* 0 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 1 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 2 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 3 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 4 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 5 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 6 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 7 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 8 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 9 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 10 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 11 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 12 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 13 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 14 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 15 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 16 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 17 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 18 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 19 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 20 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 21 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 22 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 23 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}}; /* ** Table file header diff --git a/fsw/tables/cs_eepromtbl.c b/fsw/tables/cs_eepromtbl.c index 60cfab0..81357dc 100644 --- a/fsw/tables/cs_eepromtbl.c +++ b/fsw/tables/cs_eepromtbl.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -34,37 +33,40 @@ CS_Def_EepromMemory_Table_Entry_t CS_EepromTable[CS_MAX_NUM_EEPROM_TABLE_ENTRIES] = { /* State Filler StartAddress NumBytes */ /* 0 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 1 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 2 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 3 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 4 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 5 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 6 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 7 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 8 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 9 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 10 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 11 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 12 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 13 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 14 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 15 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}}; + {.State = CS_ChecksumState_EMPTY, + .Filler16 = 0x1234, + .StartAddress = 0x00000000, + .NumBytesToChecksum = 0x00000000}}; /* ** Table file header diff --git a/fsw/tables/cs_memorytbl.c b/fsw/tables/cs_memorytbl.c index 99e5d05..e67436e 100644 --- a/fsw/tables/cs_memorytbl.c +++ b/fsw/tables/cs_memorytbl.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -34,37 +33,40 @@ CS_Def_EepromMemory_Table_Entry_t CS_MemoryTable[CS_MAX_NUM_MEMORY_TABLE_ENTRIES] = { /* State Filler StartAddress NumBytes */ /* 0 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 1 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 2 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 3 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 4 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 5 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 6 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 7 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 8 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 9 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 10 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 11 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 12 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 13 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 14 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, + {.State = CS_ChecksumState_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}, /* 15 */ - {.State = CS_STATE_EMPTY, .Filler16 = 0x1234, .StartAddress = 0x00000000, .NumBytesToChecksum = 0x00000000}}; + {.State = CS_ChecksumState_EMPTY, + .Filler16 = 0x1234, + .StartAddress = 0x00000000, + .NumBytesToChecksum = 0x00000000}}; /* ** Table file header diff --git a/fsw/tables/cs_tablestbl.c b/fsw/tables/cs_tablestbl.c index b9a43fb..e5b8e57 100644 --- a/fsw/tables/cs_tablestbl.c +++ b/fsw/tables/cs_tablestbl.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -34,30 +33,30 @@ CS_Def_Tables_Table_Entry_t CS_TablesTable[CS_MAX_NUM_TABLES_TABLE_ENTRIES] = { /* State Name */ - /* 0 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 1 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 2 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 3 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 4 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 5 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 6 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 7 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 8 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 9 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 10 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 11 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 12 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 13 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 14 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 15 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 16 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 17 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 18 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 19 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 20 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 21 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 22 */ {.State = CS_STATE_EMPTY, .Name = ""}, - /* 23 */ {.State = CS_STATE_EMPTY, .Name = ""}}; + /* 0 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 1 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 2 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 3 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 4 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 5 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 6 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 7 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 8 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 9 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 10 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 11 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 12 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 13 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 14 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 15 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 16 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 17 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 18 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 19 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 20 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 21 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 22 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}, + /* 23 */ {.State = CS_ChecksumState_EMPTY, .Name = ""}}; /* ** Table file header diff --git a/mission_build.cmake b/mission_build.cmake index 6b865c0..a0df301 100644 --- a/mission_build.cmake +++ b/mission_build.cmake @@ -2,3 +2,19 @@ # Add stand alone documentation add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/docs/dox_src ${MISSION_BINARY_DIR}/docs/cs-usersguide) + +# The list of header files that control the CF configuration +set(CS_MISSION_CONFIG_FILE_LIST + cs_extern_typedefs.h + cs_fcncode_values.h + cs_interface_cfg_values.h + cs_mission_cfg.h + cs_msgdefs.h + cs_msg.h + cs_msgstruct.h + cs_tbldefs.h + cs_tbl.h + cs_topicid_values.h +) + +generate_configfile_set(${CS_MISSION_CONFIG_FILE_LIST}) diff --git a/unit-test/CMakeLists.txt b/unit-test/CMakeLists.txt index a51d3fa..64c0eda 100644 --- a/unit-test/CMakeLists.txt +++ b/unit-test/CMakeLists.txt @@ -20,6 +20,7 @@ add_cfe_coverage_stubs("cs_internal" stubs/cs_cmds_stubs.c stubs/cs_init_stubs.c stubs/cs_eeprom_cmds_stubs.c + stubs/cs_dispatch_stubs.c ) # Link with the cfe core stubs and unit test assert libs diff --git a/unit-test/cs_app_cmds_tests.c b/unit-test/cs_app_cmds_tests.c index 8bb2bf3..22cb567 100644 --- a/unit-test/cs_app_cmds_tests.c +++ b/unit-test/cs_app_cmds_tests.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -24,7 +23,7 @@ #include "cs_app_cmds.h" #include "cs_msg.h" #include "cs_msgdefs.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_version.h" #include "cs_utils.h" #include "cs_test_utils.h" @@ -49,9 +48,10 @@ void CS_APP_CMDS_TEST_CS_GetAppResTblEntryByNameHandler1(void *UserObj, UT_Entry CS_Res_App_Table_Entry_t **EntryPtr = (CS_Res_App_Table_Entry_t **)UT_Hook_GetArgValueByName(Context, "EntryPtr", CS_Res_App_Table_Entry_t **); - *EntryPtr = CS_AppData.ResAppTblPtr; + CS_Res_App_Table_Entry_t *ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + *EntryPtr = ResAppTblPtr; - CS_AppData.ResAppTblPtr->ComputedYet = true; + ResAppTblPtr->ComputedYet = true; } void CS_APP_CMDS_TEST_CS_GetAppResTblEntryByNameHandler2(void *UserObj, UT_EntryKey_t FuncKey, @@ -60,9 +60,10 @@ void CS_APP_CMDS_TEST_CS_GetAppResTblEntryByNameHandler2(void *UserObj, UT_Entry CS_Res_App_Table_Entry_t **EntryPtr = (CS_Res_App_Table_Entry_t **)UT_Hook_GetArgValueByName(Context, "EntryPtr", CS_Res_App_Table_Entry_t **); - *EntryPtr = CS_AppData.ResAppTblPtr; + CS_Res_App_Table_Entry_t *ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + *EntryPtr = ResAppTblPtr; - CS_AppData.ResAppTblPtr->ComputedYet = false; + ResAppTblPtr->ComputedYet = false; } void CS_APP_CMDS_TEST_CS_GetAppDefTblEntryByNameHandler1(void *UserObj, UT_EntryKey_t FuncKey, @@ -71,25 +72,25 @@ void CS_APP_CMDS_TEST_CS_GetAppDefTblEntryByNameHandler1(void *UserObj, UT_Entry CS_Def_Tables_Table_Entry_t **EntryPtr = (CS_Def_Tables_Table_Entry_t **)UT_Hook_GetArgValueByName(Context, "EntryPtr", CS_Def_Tables_Table_Entry_t **); - *EntryPtr = CS_AppData.DefTablesTblPtr; + CS_Def_Tables_Table_Entry_t *DefTablesTblPtr = CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].DefAddr; + *EntryPtr = DefTablesTblPtr; } -void CS_DisableAppCmd_Test(void) +void CS_DisableAppsCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableAppsCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of App is Disabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ - CS_DisableAppCmd(&CmdPacket); + CS_DisableAppsCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.AppCSState == CS_STATE_DISABLED, - "CS_AppData.HkPacket.Payload.AppCSState == CS_STATE_DISABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.AppCSState == CS_ChecksumState_DISABLED, + "CS_AppData.HkPacket.Payload.AppCSState == CS_ChecksumState_DISABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_APP_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -106,16 +107,15 @@ void CS_DisableAppCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableAppCmd_Test_OneShot(void) +void CS_DisableAppsCmd_Test_OneShot(void) { - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_DisableAppsCmd_t CmdPacket; + memset(&CmdPacket, 0, sizeof(CmdPacket)); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ - CS_DisableAppCmd(&CmdPacket); + CS_DisableAppsCmd(&CmdPacket); /* Verify results */ UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 0, "CS_AppData.HkPacket.Payload.CmdCounter == 0"); @@ -126,22 +126,21 @@ void CS_DisableAppCmd_Test_OneShot(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableAppCmd_Test(void) +void CS_EnableAppsCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableAppsCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of App is Enabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ - CS_EnableAppCmd(&CmdPacket); + CS_EnableAppsCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.AppCSState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.AppCSState == CS_STATE_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.AppCSState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.AppCSState == CS_ChecksumState_ENABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ENABLE_APP_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -160,16 +159,15 @@ void CS_EnableAppCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableAppCmd_Test_OneShot(void) +void CS_EnableAppsCmd_Test_OneShot(void) { - CS_NoArgsCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_EnableAppsCmd_t CmdPacket; + memset(&CmdPacket, 0, sizeof(CmdPacket)); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ - CS_EnableAppCmd(&CmdPacket); + CS_EnableAppsCmd(&CmdPacket); /* Verify results */ UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 0, "CS_AppData.HkPacket.Payload.CmdCounter == 0"); @@ -182,21 +180,22 @@ void CS_EnableAppCmd_Test_OneShot(void) void CS_ReportBaselineAppCmd_Test_Baseline(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_App_Table_Entry_t *ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Report baseline of app %%s is 0x%%08X"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); /* Needed to make subfunction CS_GetAppResTblEntryByName behave properly */ - CS_AppData.ResAppTblPtr->State = 1; - CS_AppData.ResAppTblPtr->ComputedYet = true; - CS_AppData.ResAppTblPtr->ComparisonValue = 1; + ResAppTblPtr->State = 1; + ResAppTblPtr->ComputedYet = true; + ResAppTblPtr->ComparisonValue = 1; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, true); UT_SetHandlerFunction(UT_KEY(CS_GetAppResTblEntryByName), CS_APP_CMDS_TEST_CS_GetAppResTblEntryByNameHandler1, NULL); @@ -222,21 +221,22 @@ void CS_ReportBaselineAppCmd_Test_Baseline(void) void CS_ReportBaselineAppCmd_Test_NoBaseline(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_App_Table_Entry_t *ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Report baseline of app %%s has not been computed yet"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); /* Needed to make subfunction CS_GetAppResTblEntryByName behave properly */ - CS_AppData.ResAppTblPtr->State = 1; - CS_AppData.ResAppTblPtr->ComputedYet = false; + ResAppTblPtr->State = 1; + ResAppTblPtr->ComputedYet = false; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, true); UT_SetHandlerFunction(UT_KEY(CS_GetAppResTblEntryByName), CS_APP_CMDS_TEST_CS_GetAppResTblEntryByNameHandler2, NULL); @@ -264,19 +264,20 @@ void CS_ReportBaselineAppCmd_Test_NoBaseline(void) void CS_ReportBaselineAppCmd_Test_BaselineInvalidName(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_App_Table_Entry_t *ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "App report baseline failed, app %%s not found"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App2", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App2", OS_MAX_API_NAME); /* Needed to make subfunction CS_GetAppResTblEntryByName behave properly */ - CS_AppData.ResAppTblPtr->State = 1; + ResAppTblPtr->State = 1; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, false); /* Execute the function being tested */ @@ -298,23 +299,23 @@ void CS_ReportBaselineAppCmd_Test_BaselineInvalidName(void) call_count_CFE_EVS_SendEvent); } -void CS_ReportBaselineAppCmd_Test_OneShot(void) +void CS_RecomputeBaselineAppCmd_Test_OneShot(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_App_Table_Entry_t * ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "App recompute baseline for app %%s failed: child task in use"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App2", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App2", OS_MAX_API_NAME); CS_AppData.HkPacket.Payload.RecomputeInProgress = false; CS_AppData.HkPacket.Payload.OneShotInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineAppCmd(&CmdPacket); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, true); @@ -339,24 +340,25 @@ void CS_ReportBaselineAppCmd_Test_OneShot(void) void CS_RecomputeBaselineAppCmd_Test_Nominal(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_App_Table_Entry_t * ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute baseline of app %%s started"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); CS_AppData.HkPacket.Payload.RecomputeInProgress = false; /* Needed to make subfunction CS_GetAppResTblEntryByName behave properly */ - CS_AppData.ResAppTblPtr->State = 1; + ResAppTblPtr->State = 1; /* Set to generate event message CS_RECOMPUTE_APP_STARTED_DBG_EID */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CreateChildTask), 1, CFE_SUCCESS); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, true); UT_SetHandlerFunction(UT_KEY(CS_GetAppResTblEntryByName), CS_APP_CMDS_TEST_CS_GetAppResTblEntryByNameHandler1, NULL); @@ -365,8 +367,7 @@ void CS_RecomputeBaselineAppCmd_Test_Nominal(void) CS_RecomputeBaselineAppCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.ResAppTblPtr == CS_AppData.RecomputeAppEntryPtr, - "CS_AppData.ResAppTblPtr == CS_AppData.RecomputeAppEntryPtr"); + UtAssert_True(ResAppTblPtr == CS_AppData.RecomputeAppEntryPtr, "ResAppTblPtr == CS_AppData.RecomputeAppEntryPtr"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_APP_STARTED_DBG_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_DEBUG); @@ -387,25 +388,26 @@ void CS_RecomputeBaselineAppCmd_Test_Nominal(void) void CS_RecomputeBaselineAppCmd_Test_CreateChildTaskError(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_App_Table_Entry_t * ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute baseline of app %%s failed, CFE_ES_CreateChildTask returned: 0x%%08X"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); CS_AppData.HkPacket.Payload.RecomputeInProgress = false; /* Needed to make subfunction CS_GetAppResTblEntryByName behave properly */ - CS_AppData.ResAppTblPtr->State = 1; + ResAppTblPtr->State = 1; /* Set to generate event message CS_RECOMPUTE_APP_CREATE_CHDTASK_ERR_EID */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CreateChildTask), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, true); UT_SetHandlerFunction(UT_KEY(CS_GetAppResTblEntryByName), CS_APP_CMDS_TEST_CS_GetAppResTblEntryByNameHandler1, NULL); @@ -414,8 +416,7 @@ void CS_RecomputeBaselineAppCmd_Test_CreateChildTaskError(void) CS_RecomputeBaselineAppCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.ResAppTblPtr == CS_AppData.RecomputeAppEntryPtr, - "CS_AppData.ResAppTblPtr == CS_AppData.RecomputeAppEntryPtr"); + UtAssert_True(ResAppTblPtr == CS_AppData.RecomputeAppEntryPtr, "ResAppTblPtr == CS_AppData.RecomputeAppEntryPtr"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_APP_CREATE_CHDTASK_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); @@ -434,22 +435,23 @@ void CS_RecomputeBaselineAppCmd_Test_CreateChildTaskError(void) void CS_RecomputeBaselineAppCmd_Test_UnknownNameError(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_App_Table_Entry_t * ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "App recompute baseline failed, app %%s not found"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App2", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App2", OS_MAX_API_NAME); CS_AppData.HkPacket.Payload.RecomputeInProgress = false; /* Needed to make subfunction CS_GetAppResTblEntryByName behave properly */ - CS_AppData.ResAppTblPtr->State = 1; + ResAppTblPtr->State = 1; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, false); /* Execute the function being tested */ @@ -473,20 +475,20 @@ void CS_RecomputeBaselineAppCmd_Test_UnknownNameError(void) void CS_RecomputeBaselineAppCmd_Test_RecomputeInProgress(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_App_Table_Entry_t * ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "App recompute baseline for app %%s failed: child task in use"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App2", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App2", OS_MAX_API_NAME); CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineAppCmd(&CmdPacket); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, true); @@ -511,23 +513,25 @@ void CS_RecomputeBaselineAppCmd_Test_RecomputeInProgress(void) void CS_DisableNameAppCmd_Test_Nominal(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableNameAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_App_Table_Entry_t *DefAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].DefAddr; + CS_Res_App_Table_Entry_t *ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of app %%s is Disabled"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.DefAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(DefAppTblPtr->Name, "App1", OS_MAX_API_NAME); /* Needed to make subfunction CS_GetAppDefTblEntryByName behave properly */ - CS_AppData.ResAppTblPtr->State = 1; + ResAppTblPtr->State = 1; /* Needed to make subfunction CS_GetAppDefTblEntryByName behave properly */ - CS_AppData.DefAppTblPtr->State = 1; + DefAppTblPtr->State = 1; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, true); UT_SetHandlerFunction(UT_KEY(CS_GetAppResTblEntryByName), CS_APP_CMDS_TEST_CS_GetAppResTblEntryByNameHandler1, @@ -559,26 +563,28 @@ void CS_DisableNameAppCmd_Test_Nominal(void) void CS_DisableNameAppCmd_Test_UpdateAppsDefinitionTableError(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableNameAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_App_Table_Entry_t *DefAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].DefAddr; + CS_Res_App_Table_Entry_t *ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of app %%s is Disabled"); snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "CS unable to update apps definition table for entry %%s"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.DefAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(DefAppTblPtr->Name, "App1", OS_MAX_API_NAME); /* Needed to make subfunction CS_GetAppDefTblEntryByName behave properly */ - CS_AppData.ResAppTblPtr->State = 1; + ResAppTblPtr->State = 1; /* Set to make subfunction CS_GetAppDefTblEntryByName return false */ - CS_AppData.DefAppTblPtr->State = CS_STATE_EMPTY; + DefAppTblPtr->State = CS_ChecksumState_EMPTY; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, true); UT_SetHandlerFunction(UT_KEY(CS_GetAppResTblEntryByName), CS_APP_CMDS_TEST_CS_GetAppResTblEntryByNameHandler1, NULL); @@ -615,21 +621,23 @@ void CS_DisableNameAppCmd_Test_UpdateAppsDefinitionTableError(void) void CS_DisableNameAppCmd_Test_UnknownNameError(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableNameAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_App_Table_Entry_t *DefAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].DefAddr; + CS_Res_App_Table_Entry_t *ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "App disable app command failed, app %%s not found"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.DefAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(DefAppTblPtr->Name, "App1", OS_MAX_API_NAME); /* Set to make subfunction CS_GetAppResTblEntryByName return false */ - CS_AppData.ResAppTblPtr->State = CS_STATE_EMPTY; + ResAppTblPtr->State = CS_ChecksumState_EMPTY; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, false); /* Execute the function being tested */ @@ -653,10 +661,9 @@ void CS_DisableNameAppCmd_Test_UnknownNameError(void) void CS_DisableNameAppCmd_Test_OneShot(void) { - CS_AppNameCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_DisableNameAppCmd_t CmdPacket; + memset(&CmdPacket, 0, sizeof(CmdPacket)); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ @@ -673,23 +680,25 @@ void CS_DisableNameAppCmd_Test_OneShot(void) void CS_EnableNameAppCmd_Test_Nominal(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableNameAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_App_Table_Entry_t *DefAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].DefAddr; + CS_Res_App_Table_Entry_t *ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of app %%s is Enabled"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.DefAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(DefAppTblPtr->Name, "App1", OS_MAX_API_NAME); /* Needed to make subfunction CS_GetAppDefTblEntryByName behave properly */ - CS_AppData.ResAppTblPtr->State = 1; + ResAppTblPtr->State = 1; /* Needed to make subfunction CS_GetAppDefTblEntryByName behave properly */ - CS_AppData.DefAppTblPtr->State = 1; + DefAppTblPtr->State = 1; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, true); UT_SetHandlerFunction(UT_KEY(CS_GetAppResTblEntryByName), CS_APP_CMDS_TEST_CS_GetAppResTblEntryByNameHandler1, @@ -721,26 +730,28 @@ void CS_EnableNameAppCmd_Test_Nominal(void) void CS_EnableNameAppCmd_Test_UpdateAppsDefinitionTableError(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableNameAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_App_Table_Entry_t *DefAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].DefAddr; + CS_Res_App_Table_Entry_t *ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of app %%s is Enabled"); snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "CS unable to update apps definition table for entry %%s"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.DefAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(DefAppTblPtr->Name, "App1", OS_MAX_API_NAME); /* Needed to make subfunction CS_GetAppDefTblEntryByName behave properly */ - CS_AppData.ResAppTblPtr->State = 1; + ResAppTblPtr->State = 1; /* Set to make subfunction CS_GetAppDefTblEntryByName return false */ - CS_AppData.DefAppTblPtr->State = CS_STATE_EMPTY; + DefAppTblPtr->State = CS_ChecksumState_EMPTY; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, true); UT_SetHandlerFunction(UT_KEY(CS_GetAppResTblEntryByName), CS_APP_CMDS_TEST_CS_GetAppResTblEntryByNameHandler1, NULL); @@ -777,21 +788,23 @@ void CS_EnableNameAppCmd_Test_UpdateAppsDefinitionTableError(void) void CS_EnableNameAppCmd_Test_UnknownNameError(void) { - CS_AppNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableNameAppCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_App_Table_Entry_t *DefAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].DefAddr; + CS_Res_App_Table_Entry_t *ResAppTblPtr = CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "App enable app command failed, app %%s not found"); strncpy(CmdPacket.Payload.Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); - strncpy(CS_AppData.DefAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(ResAppTblPtr->Name, "App1", OS_MAX_API_NAME); + strncpy(DefAppTblPtr->Name, "App1", OS_MAX_API_NAME); /* Set to make subfunction CS_GetAppResTblEntryByName return false */ - CS_AppData.ResAppTblPtr->State = CS_STATE_EMPTY; + ResAppTblPtr->State = CS_ChecksumState_EMPTY; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); UT_SetDeferredRetcode(UT_KEY(CS_GetAppResTblEntryByName), 1, false); @@ -816,10 +829,9 @@ void CS_EnableNameAppCmd_Test_UnknownNameError(void) void CS_EnableNameAppCmd_Test_OneShot(void) { - CS_AppNameCmd_t CmdPacket; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_EnableNameAppCmd_t CmdPacket; + memset(&CmdPacket, 0, sizeof(CmdPacket)); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ @@ -836,11 +848,11 @@ void CS_EnableNameAppCmd_Test_OneShot(void) void UtTest_Setup(void) { - UtTest_Add(CS_DisableAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_DisableAppCmd_Test"); - UtTest_Add(CS_DisableAppCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_DisableAppCmd_Test_OneShot"); + UtTest_Add(CS_DisableAppsCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_DisableAppsCmd_Test"); + UtTest_Add(CS_DisableAppsCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_DisableAppsCmd_Test_OneShot"); - UtTest_Add(CS_EnableAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_EnableAppCmd_Test"); - UtTest_Add(CS_EnableAppCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_EnableAppCmd_Test_OneShot"); + UtTest_Add(CS_EnableAppsCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_EnableAppsCmd_Test"); + UtTest_Add(CS_EnableAppsCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_EnableAppsCmd_Test_OneShot"); UtTest_Add(CS_ReportBaselineAppCmd_Test_Baseline, CS_Test_Setup, CS_Test_TearDown, "CS_ReportBaselineAppCmd_Test_Baseline"); @@ -848,8 +860,8 @@ void UtTest_Setup(void) "CS_ReportBaselineAppCmd_Test_NoBaseline"); UtTest_Add(CS_ReportBaselineAppCmd_Test_BaselineInvalidName, CS_Test_Setup, CS_Test_TearDown, "CS_ReportBaselineAppCmd_Test_BaselineInvalidName"); - UtTest_Add(CS_ReportBaselineAppCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, - "CS_ReportBaselineAppCmd_Test_OneShot"); + UtTest_Add(CS_RecomputeBaselineAppCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, + "CS_RecomputeBaselineAppCmd_Test_OneShot"); UtTest_Add(CS_RecomputeBaselineAppCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeBaselineAppCmd_Test_Nominal"); diff --git a/unit-test/cs_app_tests.c b/unit-test/cs_app_tests.c index 4faaaab..2a4edda 100644 --- a/unit-test/cs_app_tests.c +++ b/unit-test/cs_app_tests.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -29,10 +28,11 @@ #include "cs_table_cmds.h" #include "cs_msg.h" #include "cs_msgdefs.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_version.h" #include "cs_init.h" #include "cs_utils.h" +#include "cs_dispatch.h" #include "cs_test_utils.h" #include #include @@ -50,13 +50,51 @@ /* Command buffer typedef for any handler */ typedef union { - CFE_SB_Buffer_t Buf; - CS_NoArgsCmd_t NoArgsCmd; - CS_GetEntryIDCmd_t GetEntryIDCmd; - CS_EntryCmd_t EntryCmd; - CS_TableNameCmd_t TableNameCmd; - CS_AppNameCmd_t AppNameCmd; - CS_OneShotCmd_t OneShotCmd; + CFE_SB_Buffer_t Buf; + + CS_SendHkCmd_t SendHkCmd; + CS_NoopCmd_t NoopCmd; + CS_ResetCmd_t ResetCmd; + CS_BackgroundCheckCycleCmd_t BackgroundCheckCycle; + CS_DisableAllCSCmd_t DisableAllCSCmd; + CS_EnableAllCSCmd_t EnableAllCSCmd; + CS_DisableCfeCoreCmd_t DisableCfeCoreCmd; + CS_EnableCfeCoreCmd_t EnableCfeCoreCmd; + CS_DisableOSCmd_t DisableOSCmd; + CS_EnableOSCmd_t EnableOSCmd; + CS_ReportBaselineCfeCoreCmd_t ReportBaselineCfeCoreCmd; + CS_ReportBaselineOSCmd_t ReportBaselineOSCmd; + CS_RecomputeBaselineCfeCoreCmd_t RecomputeBaselineCfeCoreCmd; + CS_RecomputeBaselineOSCmd_t RecomputeBaselineOSCmd; + CS_CancelOneShotCmd_t CancelOneShotCmd; + CS_DisableAppsCmd_t DisableAppsCmd; + CS_EnableAppsCmd_t EnableAppsCmd; + CS_DisableEepromCmd_t DisableEepromCmd; + CS_EnableEepromCmd_t EnableEepromCmd; + CS_DisableMemoryCmd_t DisableMemoryCmd; + CS_EnableMemoryCmd_t EnableMemoryCmd; + CS_DisableTablesCmd_t DisableTablesCmd; + CS_EnableTablesCmd_t EnableTablesCmd; + CS_GetEntryIDEepromCmd_t GetEntryIDEepromCmd; + CS_GetEntryIDMemoryCmd_t GetEntryIDMemoryCmd; + CS_ReportBaselineEntryIDEepromCmd_t ReportBaselineEntryIDEepromCmd; + CS_DisableEntryIDEepromCmd_t DisableEntryIDEepromCmd; + CS_RecomputeBaselineEepromCmd_t RecomputeBaselineEepromCmd; + CS_EnableEntryIDEepromCmd_t EnableEntryIDEepromCmd; + CS_ReportBaselineEntryIDMemoryCmd_t ReportBaselineEntryIDMemoryCmd; + CS_DisableEntryIDMemoryCmd_t DisableEntryIDMemoryCmd; + CS_RecomputeBaselineMemoryCmd_t RecomputeBaselineMemoryCmd; + CS_EnableEntryIDMemoryCmd_t EnableEntryIDMemoryCmd; + CS_ReportBaselineTableCmd_t ReportBaselineTableCmd; + CS_RecomputeBaselineTableCmd_t RecomputeBaselineTableCmd; + CS_DisableNameTableCmd_t DisableNameTableCmd; + CS_EnableNameTableCmd_t EnableNameTableCmd; + CS_ReportBaselineAppCmd_t ReportBaselineAppCmd; + CS_RecomputeBaselineAppCmd_t RecomputeBaselineAppCmd; + CS_DisableNameAppCmd_t DisableNameAppCmd; + CS_EnableNameAppCmd_t EnableNameAppCmd; + CS_OneShotCmd_t OneShotCmd; + } UT_CmdBuf_t; /* cs_app_tests globals */ @@ -78,13 +116,13 @@ void CS_APP_TEST_CFE_ES_RestoreFromCDS_Handler(void *UserObj, UT_EntryKey_t Func { uint8 *DataStoreBuffer = (uint8 *)UT_Hook_GetArgValueByName(Context, "RestoreToMemory", uint8 *); - DataStoreBuffer[0] = CS_STATE_ENABLED; - DataStoreBuffer[1] = CS_STATE_ENABLED; - DataStoreBuffer[2] = CS_STATE_ENABLED; - DataStoreBuffer[3] = CS_STATE_ENABLED; + DataStoreBuffer[0] = CS_ChecksumState_ENABLED; + DataStoreBuffer[1] = CS_ChecksumState_ENABLED; + DataStoreBuffer[2] = CS_ChecksumState_ENABLED; + DataStoreBuffer[3] = CS_ChecksumState_ENABLED; - DataStoreBuffer[4] = CS_STATE_ENABLED; - DataStoreBuffer[5] = CS_STATE_ENABLED; + DataStoreBuffer[4] = CS_ChecksumState_ENABLED; + DataStoreBuffer[5] = CS_ChecksumState_ENABLED; } void CS_App_TestCmdTlmAlign(void) @@ -94,12 +132,67 @@ void CS_App_TestCmdTlmAlign(void) #define TLM_STRUCT_DATA_IS_32_ALIGNED(x) ((sizeof(x) - sizeof(CFE_MSG_TelemetryHeader_t)) % 4) == 0 UtAssert_True(TLM_STRUCT_DATA_IS_32_ALIGNED(CS_HkPacket_t), "CS_HkPacket_t is 32-bit aligned"); - - UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_NoArgsCmd_t), "CS_NoArgsCmd_t is 32-bit aligned"); - UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_GetEntryIDCmd_t), "CS_GetEntryIDCmd_t is 32-bit aligned"); - UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_EntryCmd_t), "CS_EntryCmd_t is 32-bit aligned"); - UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_TableNameCmd_t), "CS_TableNameCmd_t is 32-bit aligned"); - UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_AppNameCmd_t), "CS_AppNameCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_SendHkCmd_t), "CS_SendHkCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_NoopCmd_t), "CS_NoopCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_ResetCmd_t), "CS_ResetCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_BackgroundCheckCycleCmd_t), + "CS_BackgroundCheckCycleCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_DisableAllCSCmd_t), "CS_DisableAllCSCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_EnableAllCSCmd_t), "CS_EnableAllCSCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_DisableCfeCoreCmd_t), "CS_DisableCfeCoreCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_EnableCfeCoreCmd_t), "CS_EnableCfeCoreCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_DisableOSCmd_t), "CS_DisableOSCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_EnableOSCmd_t), "CS_EnableOSCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_ReportBaselineCfeCoreCmd_t), + "CS_ReportBaselineCfeCoreCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_ReportBaselineOSCmd_t), + "CS_ReportBaselineOSCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_RecomputeBaselineCfeCoreCmd_t), + "CS_RecomputeBaselineCfeCoreCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_RecomputeBaselineOSCmd_t), + "CS_RecomputeBaselineOSCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_CancelOneShotCmd_t), "CS_CancelOneShotCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_DisableAppsCmd_t), "CS_DisableAppsCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_EnableAppsCmd_t), "CS_EnableAppsCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_DisableEepromCmd_t), "CS_DisableEepromCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_EnableEepromCmd_t), "CS_EnableEepromCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_DisableMemoryCmd_t), "CS_DisableMemoryCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_EnableMemoryCmd_t), "CS_EnableMemoryCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_DisableTablesCmd_t), "CS_DisableTablesCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_EnableTablesCmd_t), "CS_EnableTablesCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_GetEntryIDEepromCmd_t), + "CS_GetEntryIDEepromCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_GetEntryIDMemoryCmd_t), + "CS_GetEntryIDMemoryCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_ReportBaselineEntryIDEepromCmd_t), + "CS_ReportBaselineEntryIDEepromCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_DisableEntryIDEepromCmd_t), + "CS_DisableEntryIDEepromCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_RecomputeBaselineEepromCmd_t), + "CS_RecomputeBaselineEepromCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_EnableEntryIDEepromCmd_t), + "CS_EnableEntryIDEepromCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_ReportBaselineEntryIDMemoryCmd_t), + "CS_ReportBaselineEntryIDMemoryCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_DisableEntryIDMemoryCmd_t), + "CS_DisableEntryIDMemoryCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_RecomputeBaselineMemoryCmd_t), + "CS_RecomputeBaselineMemoryCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_EnableEntryIDMemoryCmd_t), + "CS_EnableEntryIDMemoryCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_ReportBaselineTableCmd_t), + "CS_ReportBaselineTableCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_RecomputeBaselineTableCmd_t), + "CS_RecomputeBaselineTableCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_DisableNameTableCmd_t), + "CS_DisableNameTableCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_EnableNameTableCmd_t), "CS_EnableNameTableCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_ReportBaselineAppCmd_t), + "CS_ReportBaselineAppCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_RecomputeBaselineAppCmd_t), + "CS_RecomputeBaselineAppCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_DisableNameAppCmd_t), "CS_DisableNameAppCmd_t is 32-bit aligned"); + UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_EnableNameAppCmd_t), "CS_EnableNameAppCmd_t is 32-bit aligned"); UtAssert_True(CMD_STRUCT_DATA_IS_32_ALIGNED(CS_OneShotCmd_t), "CS_OneShotCmd_t is 32-bit aligned"); } @@ -299,7 +392,7 @@ void CS_AppMain_Test_RcvMsgTimeout(void) UT_SetDeferredRetcode(UT_KEY(CFE_ES_RunLoop), 1, true); TestMsgId = CFE_SB_ValueToMsgId(CS_SEND_HK_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(Packet); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); UT_SetDataBuffer(UT_KEY(CFE_SB_ReceiveBuffer), &Packet, sizeof(Packet), false); @@ -387,12 +480,12 @@ void CS_AppMain_Test_RcvNoMsg(void) void CS_AppMain_Test_RcvNullBufPtr(void) { - CFE_SB_MsgId_t TestMsgId; - size_t MsgSize; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - char ExpectedSysLogString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - CS_NoArgsCmd_t *Packet = NULL; + CFE_SB_MsgId_t TestMsgId; + size_t MsgSize; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + char ExpectedSysLogString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_NoopCmd_t * PacketPtr = NULL; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "App terminating, RunStatus:0x%%08X, RC:0x%%08X"); @@ -403,16 +496,16 @@ void CS_AppMain_Test_RcvNullBufPtr(void) UT_SetDeferredRetcode(UT_KEY(CFE_ES_RunLoop), 1, true); TestMsgId = CFE_SB_ValueToMsgId(CS_SEND_HK_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(*PacketPtr); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - UT_SetDataBuffer(UT_KEY(CFE_SB_ReceiveBuffer), &Packet, sizeof(Packet), false); + UT_SetDataBuffer(UT_KEY(CFE_SB_ReceiveBuffer), &PacketPtr, sizeof(PacketPtr), false); /* Set to make CS_AppPipe return -1 */ UT_SetDeferredRetcode(UT_KEY(CS_HandleRoutineTableUpdates), 1, -1); /* Set to satisfy subsequent condition "BufPtr == NULL" */ - UT_SetDataBuffer(UT_KEY(CFE_SB_ReceiveBuffer), Packet, sizeof(CS_NoArgsCmd_t), false); + UT_SetDataBuffer(UT_KEY(CFE_SB_ReceiveBuffer), PacketPtr, sizeof(*PacketPtr), false); /* Execute the function being tested */ CS_AppMain(); @@ -433,13 +526,11 @@ void CS_AppMain_Test_RcvNullBufPtr(void) void CS_AppMain_Test_AppPipeError(void) { - CFE_SB_MsgId_t TestMsgId; - size_t MsgSize; - CS_NoArgsCmd_t Packet; - CS_NoArgsCmd_t *PacketPtr = &Packet; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - char ExpectedSysLogString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_NoopCmd_t Packet; + CS_NoopCmd_t *PacketPtr = &Packet; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + char ExpectedSysLogString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "App terminating, RunStatus:0x%%08X, RC:0x%%08X"); @@ -448,15 +539,10 @@ void CS_AppMain_Test_AppPipeError(void) /* Set to make loop execute exactly once */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_RunLoop), 1, true); - - TestMsgId = CFE_SB_ValueToMsgId(CS_SEND_HK_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); UT_SetDataBuffer(UT_KEY(CFE_SB_ReceiveBuffer), &PacketPtr, sizeof(PacketPtr), false); /* Set to make CS_AppPipe return -1 */ - UT_SetDeferredRetcode(UT_KEY(CS_HandleRoutineTableUpdates), 1, -1); + UT_SetDeferredRetcode(UT_KEY(CS_AppPipe), 1, -1); /* Set to prevent unintended error messages */ @@ -587,12 +673,12 @@ void CS_AppInit_Test_NominalProcReset(void) UtAssert_INT32_EQ(CS_AppInit(), CFE_SUCCESS); /* Verify results */ - UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.EepromCSState, CS_STATE_ENABLED); - UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.MemoryCSState, CS_STATE_ENABLED); - UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.AppCSState, CS_STATE_ENABLED); - UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.TablesCSState, CS_STATE_ENABLED); - UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.OSCSState, CS_STATE_ENABLED); - UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.CfeCoreCSState, CS_STATE_ENABLED); + UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.EepromCSState, CS_ChecksumState_ENABLED); + UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.MemoryCSState, CS_ChecksumState_ENABLED); + UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.AppCSState, CS_ChecksumState_ENABLED); + UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.TablesCSState, CS_ChecksumState_ENABLED); + UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.OSCSState, CS_ChecksumState_ENABLED); + UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.CfeCoreCSState, CS_ChecksumState_ENABLED); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_INIT_INF_EID); @@ -616,12 +702,17 @@ void CS_CreateRestoreStatesFromCDS_Test_NoExistingCDS(void) /* Verify results */ UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSState == 99, "CS_AppData.HkPacket.Payload.EepromCSState == CS_STATE_ENABLED"); - UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == 99, "CS_AppData.HkPacket.Payload.MemoryCSState == CS_STATE_ENABLED"); - UtAssert_True(CS_AppData.HkPacket.Payload.AppCSState == 99, "CS_AppData.HkPacket.Payload.AppCSState == CS_STATE_ENABLED"); - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 99, "CS_AppData.HkPacket.Payload.TablesCSState == CS_STATE_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSState == 99, + "CS_AppData.HkPacket.Payload.EepromCSState == CS_ChecksumState_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == 99, + "CS_AppData.HkPacket.Payload.MemoryCSState == CS_ChecksumState_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.AppCSState == 99, + "CS_AppData.HkPacket.Payload.AppCSState == CS_ChecksumState_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 99, + "CS_AppData.HkPacket.Payload.TablesCSState == CS_ChecksumState_ENABLED"); - UtAssert_True(CS_AppData.HkPacket.Payload.OSCSState == 99, "CS_AppData.HkPacket.Payload.OSCSState == CS_OSCS_CHECKSUM_STATE"); + UtAssert_True(CS_AppData.HkPacket.Payload.OSCSState == 99, + "CS_AppData.HkPacket.Payload.OSCSState == CS_OSCS_CHECKSUM_STATE"); UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSState == 99, "CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_CFECORE_CHECKSUM_STATE"); @@ -653,19 +744,19 @@ void CS_CreateRestoreStatesFromCDS_Test_CDSSuccess(void) /* Verify results */ UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.EepromCSState == CS_STATE_ENABLED"); - UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.MemoryCSState == CS_STATE_ENABLED"); - UtAssert_True(CS_AppData.HkPacket.Payload.AppCSState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.AppCSState == CS_STATE_ENABLED"); - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.TablesCSState == CS_STATE_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.EepromCSState == CS_ChecksumState_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.MemoryCSState == CS_ChecksumState_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.AppCSState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.AppCSState == CS_ChecksumState_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.TablesCSState == CS_ChecksumState_ENABLED"); - UtAssert_True(CS_AppData.HkPacket.Payload.OSCSState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.OSCSState == CS_STATE_ENABLED"); - UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_STATE_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.OSCSState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.OSCSState == CS_ChecksumState_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_ChecksumState_ENABLED"); call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -872,3097 +963,88 @@ void CS_AppInit_Test_EVSRegisterError(void) UtAssert_True(strCmpResult == 0, "Sys Log string matched expected result, '%s'", context_CFE_ES_WriteToSysLog.Spec); } -void CS_AppPipe_Test_TableUpdateErrors(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - size_t MsgSize; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_SEND_HK_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); - /* Generates 5 event messages we don't care about in this test */ -} - -void CS_AppPipe_Test_BackgroundCycle(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - size_t MsgSize; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_BACKGROUND_CYCLE_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_NoopCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_NOOP_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_ResetCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_RESET_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_OneShotCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_ONE_SHOT_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_CancelOneShotCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_CANCEL_ONE_SHOT_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_EnableAllCSCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_ENABLE_ALL_CS_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_DisableAllCSCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_DISABLE_ALL_CS_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_EnableCfeCoreCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_ENABLE_CFE_CORE_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} +#if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) -void CS_AppPipe_Test_DisableCfeCoreCmd(void) +void CS_UpdateCDS_Test_Nominal(void) { - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; + UT_SetDeferredRetcode(UT_KEY(CFE_ES_CopyToCDS), 1, CFE_SUCCESS); - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_DISABLE_CFE_CORE_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + /* Set as valid CDS handle */ + CS_AppData.DataStoreHandle = UT_VALID_CDSID; /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); + CS_UpdateCDS(); /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", call_count_CFE_EVS_SendEvent); } -void CS_AppPipe_Test_ReportBaselineCfeCoreCmd(void) +void CS_UpdateCDS_Test_CopyToCDSFail(void) { - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - memset(&CmdBuf, 0, sizeof(CmdBuf)); + snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Critical Data Store access error = 0x%%08X"); - CS_AppData.ChildTaskTable = -1; + UT_SetDeferredRetcode(UT_KEY(CFE_ES_CopyToCDS), 1, -1); - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_REPORT_BASELINE_CFE_CORE_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + /* Set a valid CDS handle */ + CS_AppData.DataStoreHandle = UT_VALID_CDSID; /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); + CS_UpdateCDS(); /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_RecomputeBaselineCfeCoreCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_RECOMPUTE_BASELINE_CFE_CORE_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_UPDATE_CDS_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); + strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", call_count_CFE_EVS_SendEvent); } -void CS_AppPipe_Test_EnableOSCmd(void) +void CS_UpdateCDS_Test_NullCDSHandle(void) { - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_ENABLE_OS_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + CS_AppData.DataStoreHandle = CFE_ES_CDS_BAD_HANDLE; /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); + CS_UpdateCDS(); /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", call_count_CFE_EVS_SendEvent); } +#endif /* #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) */ -void CS_AppPipe_Test_DisableOSCmd(void) +void UtTest_Setup(void) { - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_DISABLE_OS_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); + UtTest_Add(CS_App_TestCmdTlmAlign, CS_Test_Setup, CS_Test_TearDown, "CS_App_TestCmdTlmAlign"); - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_ReportBaselineOSCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_REPORT_BASELINE_OS_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_RecomputeBaselineOSCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_RECOMPUTE_BASELINE_OS_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_EnableEepromCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_ENABLE_EEPROM_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_DisableEepromCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_DISABLE_EEPROM_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_ReportBaselineEntryIDEepromCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_REPORT_BASELINE_EEPROM_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_RecomputeBaselineEepromCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_RECOMPUTE_BASELINE_EEPROM_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_EnableEntryIDEepromCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_ENABLE_ENTRY_EEPROM_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_DisableEntryIDEepromCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_DISABLE_ENTRY_EEPROM_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_GetEntryIDEepromCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_GET_ENTRY_ID_EEPROM_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_EnableMemoryCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_ENABLE_MEMORY_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_DisableMemoryCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_DISABLE_MEMORY_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_ReportBaselineEntryIDMemoryCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_REPORT_BASELINE_MEMORY_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_RecomputeBaselineMemoryCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_RECOMPUTE_BASELINE_MEMORY_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_EnableEntryIDMemoryCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_ENABLE_ENTRY_MEMORY_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_DisableEntryIDMemoryCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_DISABLE_ENTRY_MEMORY_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_GetEntryIDMemoryCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_GET_ENTRY_ID_MEMORY_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_EnableTablesCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_ENABLE_TABLES_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_DisableTablesCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_DISABLE_TABLES_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_ReportBaselineTablesCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_REPORT_BASELINE_TABLE_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_RecomputeBaselineTablesCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_RECOMPUTE_BASELINE_TABLE_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_EnableNameTablesCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_ENABLE_NAME_TABLE_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_DisableNameTablesCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_DISABLE_NAME_TABLE_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_EnableAppCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_ENABLE_APPS_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_DisableAppCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_DISABLE_APPS_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_ReportBaselineAppCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_REPORT_BASELINE_APP_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_RecomputeBaselineAppCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_RECOMPUTE_BASELINE_APP_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_EnableNameAppCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_ENABLE_NAME_APP_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_DisableNameAppCmd(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = CS_DISABLE_NAME_APP_CC; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_InvalidCCError(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "Invalid ground command code: ID = 0x%%08lX, CC = %%d"); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - FcnCode = 99; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_CC_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_AppPipe_Test_InvalidMIDError(void) -{ - CFE_Status_t Result; - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - memset(&CmdBuf, 0, sizeof(CmdBuf)); - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Invalid command pipe message ID: 0x%%08lX"); - - CS_AppData.ChildTaskTable = -1; - - TestMsgId = CFE_SB_INVALID_MSG_ID; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - - /* Execute the function being tested */ - Result = CS_AppPipe(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_MID_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_HousekeepingCmd_Test_Nominal(void) -{ - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; - - memset(&CmdPacket, 0, sizeof(CmdPacket)); - - TestMsgId = CFE_SB_ValueToMsgId(CS_SEND_HK_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); - FcnCode = 99; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - - CS_AppData.HkPacket.Payload.CmdCounter = 1; - CS_AppData.HkPacket.Payload.CmdErrCounter = 2; - CS_AppData.HkPacket.Payload.ChecksumState = 3; - CS_AppData.HkPacket.Payload.EepromCSState = 4; - CS_AppData.HkPacket.Payload.MemoryCSState = 5; - CS_AppData.HkPacket.Payload.AppCSState = 6; - CS_AppData.HkPacket.Payload.TablesCSState = 7; - CS_AppData.HkPacket.Payload.OSCSState = 8; - CS_AppData.HkPacket.Payload.CfeCoreCSState = 9; - CS_AppData.HkPacket.Payload.RecomputeInProgress = 10; - CS_AppData.HkPacket.Payload.OneShotInProgress = 11; - CS_AppData.HkPacket.Payload.EepromCSErrCounter = 12; - CS_AppData.HkPacket.Payload.MemoryCSErrCounter = 13; - CS_AppData.HkPacket.Payload.AppCSErrCounter = 14; - CS_AppData.HkPacket.Payload.TablesCSErrCounter = 15; - CS_AppData.HkPacket.Payload.CfeCoreCSErrCounter = 16; - CS_AppData.HkPacket.Payload.OSCSErrCounter = 17; - CS_AppData.HkPacket.Payload.CurrentCSTable = 18; - CS_AppData.HkPacket.Payload.CurrentEntryInTable = 19; - CS_AppData.HkPacket.Payload.EepromBaseline = 20; - CS_AppData.HkPacket.Payload.OSBaseline = 21; - CS_AppData.HkPacket.Payload.CfeCoreBaseline = 22; - CS_AppData.HkPacket.Payload.LastOneShotAddress = 23; - CS_AppData.HkPacket.Payload.LastOneShotSize = 24; - CS_AppData.HkPacket.Payload.LastOneShotChecksum = 25; - CS_AppData.HkPacket.Payload.PassCounter = 26; - - /* Execute the function being tested */ - CS_HousekeepingCmd(&CmdPacket); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 1, "CS_AppData.HkPacket.Payload.CmdCounter == 1"); - UtAssert_True(CS_AppData.HkPacket.Payload.CmdErrCounter == 2, "CS_AppData.HkPacket.Payload.CmdErrCounter == 2"); - UtAssert_True(CS_AppData.HkPacket.Payload.ChecksumState == 3, "CS_AppData.HkPacket.Payload.ChecksumState == 3"); - UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSState == 4, "CS_AppData.HkPacket.Payload.EepromCSState == 4"); - UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == 5, "CS_AppData.HkPacket.Payload.MemoryCSState == 5"); - UtAssert_True(CS_AppData.HkPacket.Payload.AppCSState == 6, "CS_AppData.HkPacket.Payload.AppCSState == 6"); - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 7, "CS_AppData.HkPacket.Payload.TablesCSState == 7"); - UtAssert_True(CS_AppData.HkPacket.Payload.OSCSState == 8, "CS_AppData.HkPacket.Payload.OSCSState == 8"); - UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSState == 9, "CS_AppData.HkPacket.Payload.CfeCoreCSState == 9"); - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == 10, "CS_AppData.HkPacket.Payload.ChildTaskInUse == 10"); - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == 11, "CS_AppData.HkPacket.Payload.OneShotInProgress == 11"); - UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSErrCounter == 12, "CS_AppData.HkPacket.Payload.EepromCSErrCounter == 12"); - UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSErrCounter == 13, "CS_AppData.HkPacket.Payload.MemoryCSErrCounter == 13"); - UtAssert_True(CS_AppData.HkPacket.Payload.AppCSErrCounter == 14, "CS_AppData.HkPacket.Payload.AppCSErrCounter == 14"); - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSErrCounter == 15, "CS_AppData.HkPacket.Payload.TablesCSErrCounter == 15"); - UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSErrCounter == 16, "CS_AppData.HkPacket.Payload.CfeCoreCSErrCounter == 16"); - UtAssert_True(CS_AppData.HkPacket.Payload.OSCSErrCounter == 17, "CS_AppData.HkPacket.Payload.OSCSErrCounter == 17"); - UtAssert_True(CS_AppData.HkPacket.Payload.CurrentCSTable == 18, "CS_AppData.HkPacket.Payload.CurrentCSTable == 18"); - UtAssert_True(CS_AppData.HkPacket.Payload.CurrentEntryInTable == 19, "CS_AppData.HkPacket.Payload.CurrentEntryInTable == 19"); - UtAssert_True(CS_AppData.HkPacket.Payload.EepromBaseline == 20, "CS_AppData.HkPacket.Payload.EepromBaseline == 20"); - UtAssert_True(CS_AppData.HkPacket.Payload.OSBaseline == 21, "CS_AppData.HkPacket.Payload.OSBaseline == 21"); - UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreBaseline == 22, "CS_AppData.HkPacket.Payload.CfeCoreBaseline == 22"); - UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotAddress == 23, "CS_AppData.HkPacket.Payload.LastOneShotAddress == 23"); - UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotSize == 24, "CS_AppData.HkPacket.Payload.LastOneShotSize == 24"); - UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotChecksum == 25, "CS_AppData.HkPacket.Payload.LastOneShotChecksum == 25"); - UtAssert_True(CS_AppData.HkPacket.Payload.PassCounter == 26, "CS_AppData.HkPacket.Payload.PassCounter == 26"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_HousekeepingCmd_Test_InvalidMsgLength(void) -{ - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - memset(&CmdPacket, 0, sizeof(CmdPacket)); - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "Invalid msg length: ID = 0x%%08lX, CC = %%d, Len = %%lu, Expected = %%lu"); - - TestMsgId = CFE_SB_ValueToMsgId(CS_SEND_HK_MID); - MsgSize = 0; - FcnCode = 99; - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - - /* Execute the function being tested */ - CS_HousekeepingCmd(&CmdPacket); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_CMD_LEN_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessCmd_NoopCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_NOOP_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_NoopCmd, 1); -} - -void CS_ProcessCmd_ResetCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RESET_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ResetCmd, 1); -} - -void CS_ProcessCmd_DisableAllCSCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ALL_CS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableAllCSCmd, 1); -} - -void CS_ProcessCmd_EnableAllCSCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ALL_CS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableAllCSCmd, 1); -} - -void CS_ProcessCmd_DisableCfeCoreCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_CFE_CORE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableCfeCoreCmd, 1); -} - -void CS_ProcessCMD_EnableCfeCoreCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_CFE_CORE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableCfeCoreCmd, 1); -} - -void CS_ProcessCmd_DisableOSCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_OS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableOSCmd, 1); -} - -void CS_ProcessCmd_EnableOSCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_OS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableOSCmd, 1); -} - -void CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_CFE_CORE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ReportBaselineCfeCoreCmd, 1); -} - -void CS_ProcessCmd_ReportBaselineOSCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_OS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ReportBaselineOSCmd, 1); -} - -void CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_CFE_CORE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_RecomputeBaselineCfeCoreCmd, 1); -} - -void CS_ProcessCmd_RecomputeBaselineOSCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_OS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_RecomputeBaselineOSCmd, 1); -} - -void CS_ProcessCmd_OneShotCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ONE_SHOT_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_OneShotCmd, 1); -} - -void CS_ProcessCmd_CancelOneShotCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_CANCEL_ONE_SHOT_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_CancelOneShotCmd, 1); -} - -void CS_ProcessCmd_DisableTablesCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_TABLES_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableTablesCmd, 1); -} - -void CS_ProcessCmd_EnableTablesCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_TABLES_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableTablesCmd, 1); -} - -void CS_ProcessCmd_ReportBaselineTablesCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_TABLE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ReportBaselineTablesCmd, 1); -} - -void CS_ProcessCmd_RecomputeBaselineTablesCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_TABLE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_RecomputeBaselineTablesCmd, 1); -} - -void CS_ProcessCmd_DisableNameTablesCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_NAME_TABLE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableNameTablesCmd, 1); -} - -void CS_ProcessCmd_EnableNameTablesCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_NAME_TABLE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableNameTablesCmd, 1); -} - -void CS_ProcessCmd_DisableAppCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_APPS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableAppCmd, 1); -} - -void CS_ProcessCmd_EnableAppCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_APPS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableAppCmd, 1); -} - -void CS_ProcessCmd_ReportBaselineAppCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_APP_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ReportBaselineAppCmd, 1); -} - -void CS_ProcessCmd_RecomputeBaselineAppCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_APP_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_RecomputeBaselineAppCmd, 1); -} - -void CS_ProcessCmd_DisableNameAppCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_NAME_APP_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableNameAppCmd, 1); -} - -void CS_ProcessCmd_EnableNameAppCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_NAME_APP_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableNameAppCmd, 1); -} - -void CS_ProcessCmd_DisableMemoryCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableMemoryCmd, 1); -} - -void CS_ProcessCmd_EnableMemoryCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableMemoryCmd, 1); -} - -void CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ReportBaselineEntryIDMemoryCmd, 1); -} - -void CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_RecomputeBaselineMemoryCmd, 1); -} - -void CS_ProcessCmd_EnableEntryIDMemoryCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ENTRY_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableEntryIDMemoryCmd, 1); -} - -void CS_ProcessCmd_DisableEntryIDMemoryCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ENTRY_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableEntryIDMemoryCmd, 1); -} - -void CS_ProcessCmd_GetEntryIDMemoryCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_GET_ENTRY_ID_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_GetEntryIDMemoryCmd, 1); -} - -void CS_ProcessCmd_DisableEepromCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableEepromCmd, 1); -} - -void CS_ProcessCmd_EnableEepromCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableEepromCmd, 1); -} - -void CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ReportBaselineEntryIDEepromCmd, 1); -} - -void CS_ProcessCmd_RecomputeBaselineEepromCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_RecomputeBaselineEepromCmd, 1); -} - -void CS_ProcessCmd_EnableEntryIDEepromCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ENTRY_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableEntryIDEepromCmd, 1); -} - -void CS_ProcessCmd_DisableEntryIDEepromCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ENTRY_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableEntryIDEepromCmd, 1); -} - -void CS_ProcessCmd_GetEntryIDEepromCmd_Test(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_GET_ENTRY_ID_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_GetEntryIDEepromCmd, 1); -} - -void CS_ProcessCmd_NoopCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_NOOP_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_NoopCmd, 0); -} - -void CS_ProcessCmd_ResetCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RESET_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ResetCmd, 0); -} - -void CS_ProcessCmd_DisableAllCSCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ALL_CS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableAllCSCmd, 0); -} - -void CS_ProcessCmd_EnableAllCSCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ALL_CS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableAllCSCmd, 0); -} - -void CS_ProcessCmd_DisableCfeCoreCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_CFE_CORE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableCfeCoreCmd, 0); -} - -void CS_ProcessCMD_EnableCfeCoreCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_CFE_CORE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableCfeCoreCmd, 0); -} - -void CS_ProcessCmd_DisableOSCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_OS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableOSCmd, 0); -} - -void CS_ProcessCmd_EnableOSCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_OS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableOSCmd, 0); -} - -void CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_CFE_CORE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ReportBaselineCfeCoreCmd, 0); -} - -void CS_ProcessCmd_ReportBaselineOSCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_OS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ReportBaselineOSCmd, 0); -} - -void CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_CFE_CORE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_RecomputeBaselineCfeCoreCmd, 0); -} - -void CS_ProcessCmd_RecomputeBaselineOSCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_OS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_RecomputeBaselineOSCmd, 0); -} - -void CS_ProcessCmd_OneShotCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ONE_SHOT_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_OneShotCmd, 0); -} - -void CS_ProcessCmd_CancelOneShotCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_CANCEL_ONE_SHOT_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_CancelOneShotCmd, 0); -} - -void CS_ProcessCmd_DisableTablesCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_TABLES_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableTablesCmd, 0); -} - -void CS_ProcessCmd_EnableTablesCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_TABLES_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableTablesCmd, 0); -} - -void CS_ProcessCmd_ReportBaselineTablesCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_TABLE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ReportBaselineTablesCmd, 0); -} - -void CS_ProcessCmd_RecomputeBaselineTablesCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_TABLE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_RecomputeBaselineTablesCmd, 0); -} - -void CS_ProcessCmd_DisableNameTablesCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_NAME_TABLE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableNameTablesCmd, 0); -} - -void CS_ProcessCmd_EnableNameTablesCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_NAME_TABLE_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableNameTablesCmd, 0); -} - -void CS_ProcessCmd_DisableAppCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_APPS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableAppCmd, 0); -} - -void CS_ProcessCmd_EnableAppCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_APPS_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableAppCmd, 0); -} - -void CS_ProcessCmd_ReportBaselineAppCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_APP_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ReportBaselineAppCmd, 0); -} - -void CS_ProcessCmd_RecomputeBaselineAppCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_APP_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_RecomputeBaselineAppCmd, 0); -} - -void CS_ProcessCmd_DisableNameAppCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_NAME_APP_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableNameAppCmd, 0); -} - -void CS_ProcessCmd_EnableNameAppCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_NAME_APP_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableNameAppCmd, 0); -} - -void CS_ProcessCmd_DisableMemoryCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableMemoryCmd, 0); -} - -void CS_ProcessCmd_EnableMemoryCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableMemoryCmd, 0); -} - -void CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ReportBaselineEntryIDMemoryCmd, 0); -} - -void CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_RecomputeBaselineMemoryCmd, 0); -} - -void CS_ProcessCmd_EnableEntryIDMemoryCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ENTRY_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableEntryIDMemoryCmd, 0); -} - -void CS_ProcessCmd_DisableEntryIDMemoryCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ENTRY_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableEntryIDMemoryCmd, 0); -} - -void CS_ProcessCmd_GetEntryIDMemoryCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_GET_ENTRY_ID_MEMORY_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_GetEntryIDMemoryCmd, 0); -} - -void CS_ProcessCmd_DisableEepromCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableEepromCmd, 0); -} - -void CS_ProcessCmd_EnableEepromCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableEepromCmd, 0); -} - -void CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_ReportBaselineEntryIDEepromCmd, 0); -} - -void CS_ProcessCmd_RecomputeBaselineEepromCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_RecomputeBaselineEepromCmd, 0); -} - -void CS_ProcessCmd_EnableEntryIDEepromCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ENTRY_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_EnableEntryIDEepromCmd, 0); -} - -void CS_ProcessCmd_DisableEntryIDEepromCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ENTRY_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_DisableEntryIDEepromCmd, 0); -} - -void CS_ProcessCmd_GetEntryIDEepromCmd_Test_VerifyError(void) -{ - UT_CmdBuf_t CmdBuf; - CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = CS_GET_ENTRY_ID_EEPROM_CC; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, false); - - /* Execute the function being tested */ - CS_ProcessCmd(&CmdBuf.Buf); - - /* Verify results */ - UtAssert_STUB_COUNT(CS_GetEntryIDEepromCmd, 0); -} - -#if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) - -void CS_UpdateCDS_Test_Nominal(void) -{ - UT_SetDeferredRetcode(UT_KEY(CFE_ES_CopyToCDS), 1, CFE_SUCCESS); - - /* Set as valid CDS handle */ - CS_AppData.DataStoreHandle = UT_VALID_CDSID; - - /* Execute the function being tested */ - CS_UpdateCDS(); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_UpdateCDS_Test_CopyToCDSFail(void) -{ - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Critical Data Store access error = 0x%%08X"); - - UT_SetDeferredRetcode(UT_KEY(CFE_ES_CopyToCDS), 1, -1); - - /* Set a valid CDS handle */ - CS_AppData.DataStoreHandle = UT_VALID_CDSID; - - /* Execute the function being tested */ - CS_UpdateCDS(); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_UPDATE_CDS_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_UpdateCDS_Test_NullCDSHandle(void) -{ - CS_AppData.DataStoreHandle = CFE_ES_CDS_BAD_HANDLE; - - /* Execute the function being tested */ - CS_UpdateCDS(); - - /* Verify results */ - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} -#endif /* #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) */ - -void UtTest_Setup(void) -{ - UtTest_Add(CS_App_TestCmdTlmAlign, CS_Test_Setup, CS_Test_TearDown, "CS_App_TestCmdTlmAlign"); - - UtTest_Add(CS_AppMain_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_Nominal"); - UtTest_Add(CS_AppMain_Test_AppInitError, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_AppInitError"); - UtTest_Add(CS_AppMain_Test_SysException, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_SysException"); - UtTest_Add(CS_AppMain_Test_RcvMsgError, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_RcvMsgError"); - UtTest_Add(CS_AppMain_Test_RcvMsgTimeout, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_RcvMsgTimeout"); - UtTest_Add(CS_AppMain_Test_RcvNoMsg, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_RcvNoMsg"); - UtTest_Add(CS_AppMain_Test_RcvNullBufPtr, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_RcvNullBufPtr"); - UtTest_Add(CS_AppMain_Test_AppPipeError, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_AppPipeError"); + UtTest_Add(CS_AppMain_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_Nominal"); + UtTest_Add(CS_AppMain_Test_AppInitError, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_AppInitError"); + UtTest_Add(CS_AppMain_Test_SysException, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_SysException"); + UtTest_Add(CS_AppMain_Test_RcvMsgError, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_RcvMsgError"); + UtTest_Add(CS_AppMain_Test_RcvMsgTimeout, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_RcvMsgTimeout"); + UtTest_Add(CS_AppMain_Test_RcvNoMsg, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_RcvNoMsg"); + UtTest_Add(CS_AppMain_Test_RcvNullBufPtr, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_RcvNullBufPtr"); + UtTest_Add(CS_AppMain_Test_AppPipeError, CS_Test_Setup, CS_Test_TearDown, "CS_AppMain_Test_AppPipeError"); UtTest_Add(CS_AppInit_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_AppInit_Test_Nominal"); UtTest_Add(CS_AppInit_Test_EVSRegisterError, CS_Test_Setup, CS_Test_TearDown, "CS_AppInit_Test_EVSRegisterError"); - - UtTest_Add(CS_AppPipe_Test_TableUpdateErrors, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_TableUpdateErrors"); - UtTest_Add(CS_AppPipe_Test_BackgroundCycle, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_BackgroundCycle"); - UtTest_Add(CS_AppPipe_Test_NoopCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_NoopCmd"); - UtTest_Add(CS_AppPipe_Test_ResetCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_ResetCmd"); - UtTest_Add(CS_AppPipe_Test_OneShotCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_OneShotCmd"); - UtTest_Add(CS_AppPipe_Test_CancelOneShotCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_CancelOneShotCmd"); - UtTest_Add(CS_AppPipe_Test_EnableAllCSCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableAllCSCmd"); - UtTest_Add(CS_AppPipe_Test_DisableAllCSCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableAllCSCmd"); - UtTest_Add(CS_AppPipe_Test_EnableCfeCoreCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableCfeCoreCmd"); - UtTest_Add(CS_AppPipe_Test_DisableCfeCoreCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableCfeCoreCmd"); - UtTest_Add(CS_AppPipe_Test_ReportBaselineCfeCoreCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_ReportBaselineCfeCoreCmd"); - UtTest_Add(CS_AppPipe_Test_RecomputeBaselineCfeCoreCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_RecomputeBaselineCfeCoreCmd"); - UtTest_Add(CS_AppPipe_Test_EnableOSCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableOSCmd"); - UtTest_Add(CS_AppPipe_Test_DisableOSCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableOSCmd"); - UtTest_Add(CS_AppPipe_Test_ReportBaselineOSCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_ReportBaselineOSCmd"); - UtTest_Add(CS_AppPipe_Test_RecomputeBaselineOSCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_RecomputeBaselineOSCmd"); - UtTest_Add(CS_AppPipe_Test_EnableEepromCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableEepromCmd"); - UtTest_Add(CS_AppPipe_Test_DisableEepromCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableEepromCmd"); - UtTest_Add(CS_AppPipe_Test_ReportBaselineEntryIDEepromCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_ReportBaselineEntryIDEepromCmd"); - UtTest_Add(CS_AppPipe_Test_RecomputeBaselineEepromCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_RecomputeBaselineEepromCmd"); - UtTest_Add(CS_AppPipe_Test_EnableEntryIDEepromCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_EnableEntryIDEepromCmd"); - UtTest_Add(CS_AppPipe_Test_DisableEntryIDEepromCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_DisableEntryIDEepromCmd"); - UtTest_Add(CS_AppPipe_Test_GetEntryIDEepromCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_GetEntryIDEepromCmd"); - UtTest_Add(CS_AppPipe_Test_EnableMemoryCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableMemoryCmd"); - UtTest_Add(CS_AppPipe_Test_DisableMemoryCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableMemoryCmd"); - UtTest_Add(CS_AppPipe_Test_ReportBaselineEntryIDMemoryCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_ReportBaselineEntryIDMemoryCmd"); - UtTest_Add(CS_AppPipe_Test_RecomputeBaselineMemoryCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_RecomputeBaselineMemoryCmd"); - UtTest_Add(CS_AppPipe_Test_EnableEntryIDMemoryCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_EnableEntryIDMemoryCmd"); - UtTest_Add(CS_AppPipe_Test_DisableEntryIDMemoryCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_DisableEntryIDMemoryCmd"); - UtTest_Add(CS_AppPipe_Test_GetEntryIDMemoryCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_GetEntryIDMemoryCmd"); - UtTest_Add(CS_AppPipe_Test_EnableTablesCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableTablesCmd"); - UtTest_Add(CS_AppPipe_Test_DisableTablesCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableTablesCmd"); - UtTest_Add(CS_AppPipe_Test_ReportBaselineTablesCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_ReportBaselineTablesCmd"); - UtTest_Add(CS_AppPipe_Test_RecomputeBaselineTablesCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_RecomputeBaselineTablesCmd"); - UtTest_Add(CS_AppPipe_Test_EnableNameTablesCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_EnableNameTablesCmd"); - UtTest_Add(CS_AppPipe_Test_DisableNameTablesCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_DisableNameTablesCmd"); - UtTest_Add(CS_AppPipe_Test_EnableAppCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableAppCmd"); - UtTest_Add(CS_AppPipe_Test_DisableAppCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableAppCmd"); - UtTest_Add(CS_AppPipe_Test_ReportBaselineAppCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_ReportBaselineAppCmd"); - UtTest_Add(CS_AppPipe_Test_RecomputeBaselineAppCmd, CS_Test_Setup, CS_Test_TearDown, - "CS_AppPipe_Test_RecomputeBaselineAppCmd"); - UtTest_Add(CS_AppPipe_Test_EnableNameAppCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableNameAppCmd"); - UtTest_Add(CS_AppPipe_Test_DisableNameAppCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableNameAppCmd"); - UtTest_Add(CS_AppPipe_Test_InvalidCCError, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_InvalidCCError"); - UtTest_Add(CS_AppPipe_Test_InvalidMIDError, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_InvalidMIDError"); - - UtTest_Add(CS_HousekeepingCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_HousekeepingCmd_Test_Nominal"); - UtTest_Add(CS_HousekeepingCmd_Test_InvalidMsgLength, CS_Test_Setup, CS_Test_TearDown, - "CS_HousekeepingCmd_Test_InvalidMsgLength"); - UtTest_Add(CS_AppInit_Test_NominalPowerOnReset, CS_Test_Setup, CS_Test_TearDown, "CS_AppInit_Test_NominalPowerOnReset"); - UtTest_Add(CS_ProcessCmd_NoopCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_NoopCmd_Test"); - UtTest_Add(CS_ProcessCmd_ResetCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ResetCmd_Test"); - UtTest_Add(CS_ProcessCmd_DisableAllCSCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableAllCSCmd_Test"); - UtTest_Add(CS_ProcessCmd_EnableAllCSCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableAllCSCmd_Test"); - UtTest_Add(CS_ProcessCmd_DisableCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableCfeCoreCmd_Test"); - UtTest_Add(CS_ProcessCMD_EnableCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCMD_EnableCfeCoreCmd_Test"); - UtTest_Add(CS_ProcessCmd_DisableOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableOSCmd_Test"); - UtTest_Add(CS_ProcessCmd_EnableOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableOSCmd_Test"); - UtTest_Add(CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test"); - UtTest_Add(CS_ProcessCmd_ReportBaselineOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ReportBaselineOSCmd_Test"); - UtTest_Add(CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test"); - UtTest_Add(CS_ProcessCmd_RecomputeBaselineOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_RecomputeBaselineOSCmd_Test"); - UtTest_Add(CS_ProcessCmd_OneShotCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_OneShotCmd_Test"); - UtTest_Add(CS_ProcessCmd_CancelOneShotCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_CancelOneShotCmd_Test"); - UtTest_Add(CS_ProcessCmd_DisableTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableTablesCmd_Test"); - UtTest_Add(CS_ProcessCmd_EnableTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableTablesCmd_Test"); - UtTest_Add(CS_ProcessCmd_ReportBaselineTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ReportBaselineTablesCmd_Test"); - UtTest_Add(CS_ProcessCmd_RecomputeBaselineTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_RecomputeBaselineTablesCmd_Test"); - UtTest_Add(CS_ProcessCmd_DisableNameTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableNameTablesCmd_Test"); - UtTest_Add(CS_ProcessCmd_EnableNameTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableNameTablesCmd_Test"); - UtTest_Add(CS_ProcessCmd_DisableAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableAppCmd_Test"); - UtTest_Add(CS_ProcessCmd_EnableAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableAppCmd_Test"); - UtTest_Add(CS_ProcessCmd_ReportBaselineAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ReportBaselineAppCmd_Test"); - UtTest_Add(CS_ProcessCmd_RecomputeBaselineAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_RecomputeBaselineAppCmd_Test"); - UtTest_Add(CS_ProcessCmd_DisableNameAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableNameAppCmd_Test"); - UtTest_Add(CS_ProcessCmd_EnableNameAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableNameAppCmd_Test"); - UtTest_Add(CS_ProcessCmd_DisableMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableMemoryCmd_Test"); - UtTest_Add(CS_ProcessCmd_EnableMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableMemoryCmd_Test"); - UtTest_Add(CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test"); - UtTest_Add(CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test"); - UtTest_Add(CS_ProcessCmd_EnableEntryIDMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableEntryIDMemoryCmd_Test"); - UtTest_Add(CS_ProcessCmd_DisableEntryIDMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableEntryIDMemoryCmd_Test"); - UtTest_Add(CS_ProcessCmd_GetEntryIDMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_GetEntryIDMemoryCmd_Test"); - UtTest_Add(CS_ProcessCmd_DisableEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableEepromCmd_Test"); - UtTest_Add(CS_ProcessCmd_EnableEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableEepromCmd_Test"); - UtTest_Add(CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test"); - UtTest_Add(CS_ProcessCmd_RecomputeBaselineEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_RecomputeBaselineEepromCmd_Test"); - UtTest_Add(CS_ProcessCmd_EnableEntryIDEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableEntryIDEepromCmd_Test"); - UtTest_Add(CS_ProcessCmd_DisableEntryIDEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableEntryIDEepromCmd_Test"); - UtTest_Add(CS_ProcessCmd_GetEntryIDEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_GetEntryIDEepromCmd_Test"); - - UtTest_Add(CS_ProcessCmd_NoopCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_NoopCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_ResetCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ResetCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_DisableAllCSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableAllCSCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_EnableAllCSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableAllCSCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_DisableCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableCfeCoreCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCMD_EnableCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCMD_EnableCfeCoreCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_DisableOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableOSCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_EnableOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableOSCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_ReportBaselineOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ReportBaselineOSCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_RecomputeBaselineOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_RecomputeBaselineOSCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_OneShotCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_OneShotCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_CancelOneShotCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_CancelOneShotCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_DisableTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableTablesCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_EnableTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableTablesCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_ReportBaselineTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ReportBaselineTablesCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_RecomputeBaselineTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_RecomputeBaselineTablesCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_DisableNameTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableNameTablesCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_EnableNameTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableNameTablesCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_DisableAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableAppCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_EnableAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableAppCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_ReportBaselineAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ReportBaselineAppCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_RecomputeBaselineAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_RecomputeBaselineAppCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_DisableNameAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableNameAppCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_EnableNameAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableNameAppCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_DisableMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableMemoryCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_EnableMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableMemoryCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_EnableEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableEntryIDMemoryCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_DisableEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableEntryIDMemoryCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_GetEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_GetEntryIDMemoryCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_DisableEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableEepromCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_EnableEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableEepromCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_RecomputeBaselineEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_RecomputeBaselineEepromCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_EnableEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_EnableEntryIDEepromCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_DisableEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_DisableEntryIDEepromCmd_Test_VerifyError"); - UtTest_Add(CS_ProcessCmd_GetEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessCmd_GetEntryIDEepromCmd_Test_VerifyError"); - - #if (CS_PRESERVE_STATES_ON_PROCESSOR_RESET == true) UtTest_Add(CS_AppInit_Test_NominalProcReset, CS_Test_Setup, CS_Test_TearDown, "CS_AppInit_Test_NominalProcReset"); diff --git a/unit-test/cs_cmds_tests.c b/unit-test/cs_cmds_tests.c index 63de2cb..bc29c19 100644 --- a/unit-test/cs_cmds_tests.c +++ b/unit-test/cs_cmds_tests.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -24,7 +23,7 @@ #include "cs_cmds.h" #include "cs_msg.h" #include "cs_msgdefs.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_version.h" #include "cs_utils.h" #include "cs_test_utils.h" @@ -52,16 +51,107 @@ CFE_Status_t CS_CMDS_TEST_CFE_ES_CreateChildTaskHook(uint32 *TaskIdPtr, const ch return CFE_SUCCESS; } +void CS_SendHkCmd_Test_Nominal(void) +{ + CS_SendHkCmd_t CmdPacket; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + + memset(&CmdPacket, 0, sizeof(CmdPacket)); + + TestMsgId = CFE_SB_ValueToMsgId(CS_SEND_HK_MID); + MsgSize = sizeof(CmdPacket); + FcnCode = 99; + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); + + CS_AppData.HkPacket.Payload.CmdCounter = 1; + CS_AppData.HkPacket.Payload.CmdErrCounter = 2; + CS_AppData.HkPacket.Payload.ChecksumState = 3; + CS_AppData.HkPacket.Payload.EepromCSState = 4; + CS_AppData.HkPacket.Payload.MemoryCSState = 5; + CS_AppData.HkPacket.Payload.AppCSState = 6; + CS_AppData.HkPacket.Payload.TablesCSState = 7; + CS_AppData.HkPacket.Payload.OSCSState = 8; + CS_AppData.HkPacket.Payload.CfeCoreCSState = 9; + CS_AppData.HkPacket.Payload.RecomputeInProgress = 10; + CS_AppData.HkPacket.Payload.OneShotInProgress = 11; + CS_AppData.HkPacket.Payload.EepromCSErrCounter = 12; + CS_AppData.HkPacket.Payload.MemoryCSErrCounter = 13; + CS_AppData.HkPacket.Payload.AppCSErrCounter = 14; + CS_AppData.HkPacket.Payload.TablesCSErrCounter = 15; + CS_AppData.HkPacket.Payload.CfeCoreCSErrCounter = 16; + CS_AppData.HkPacket.Payload.OSCSErrCounter = 17; + CS_AppData.HkPacket.Payload.CurrentCSTable = 18; + CS_AppData.HkPacket.Payload.CurrentEntryInTable = 19; + CS_AppData.HkPacket.Payload.EepromBaseline = 20; + CS_AppData.HkPacket.Payload.OSBaseline = 21; + CS_AppData.HkPacket.Payload.CfeCoreBaseline = 22; + CS_AppData.HkPacket.Payload.LastOneShotAddress = 23; + CS_AppData.HkPacket.Payload.LastOneShotSize = 24; + CS_AppData.HkPacket.Payload.LastOneShotChecksum = 25; + CS_AppData.HkPacket.Payload.PassCounter = 26; + + /* Execute the function being tested */ + CS_SendHkCmd(&CmdPacket); + + /* Verify results */ + UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 1, "CS_AppData.HkPacket.Payload.CmdCounter == 1"); + UtAssert_True(CS_AppData.HkPacket.Payload.CmdErrCounter == 2, "CS_AppData.HkPacket.Payload.CmdErrCounter == 2"); + UtAssert_True(CS_AppData.HkPacket.Payload.ChecksumState == 3, "CS_AppData.HkPacket.Payload.ChecksumState == 3"); + UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSState == 4, "CS_AppData.HkPacket.Payload.EepromCSState == 4"); + UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == 5, "CS_AppData.HkPacket.Payload.MemoryCSState == 5"); + UtAssert_True(CS_AppData.HkPacket.Payload.AppCSState == 6, "CS_AppData.HkPacket.Payload.AppCSState == 6"); + UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 7, "CS_AppData.HkPacket.Payload.TablesCSState == 7"); + UtAssert_True(CS_AppData.HkPacket.Payload.OSCSState == 8, "CS_AppData.HkPacket.Payload.OSCSState == 8"); + UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSState == 9, "CS_AppData.HkPacket.Payload.CfeCoreCSState == 9"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == 10, + "CS_AppData.HkPacket.Payload.ChildTaskInUse == 10"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == 11, + "CS_AppData.HkPacket.Payload.OneShotInProgress == 11"); + UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSErrCounter == 12, + "CS_AppData.HkPacket.Payload.EepromCSErrCounter == 12"); + UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSErrCounter == 13, + "CS_AppData.HkPacket.Payload.MemoryCSErrCounter == 13"); + UtAssert_True(CS_AppData.HkPacket.Payload.AppCSErrCounter == 14, + "CS_AppData.HkPacket.Payload.AppCSErrCounter == 14"); + UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSErrCounter == 15, + "CS_AppData.HkPacket.Payload.TablesCSErrCounter == 15"); + UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSErrCounter == 16, + "CS_AppData.HkPacket.Payload.CfeCoreCSErrCounter == 16"); + UtAssert_True(CS_AppData.HkPacket.Payload.OSCSErrCounter == 17, "CS_AppData.HkPacket.Payload.OSCSErrCounter == 17"); + UtAssert_True(CS_AppData.HkPacket.Payload.CurrentCSTable == 18, "CS_AppData.HkPacket.Payload.CurrentCSTable == 18"); + UtAssert_True(CS_AppData.HkPacket.Payload.CurrentEntryInTable == 19, + "CS_AppData.HkPacket.Payload.CurrentEntryInTable == 19"); + UtAssert_True(CS_AppData.HkPacket.Payload.EepromBaseline == 20, "CS_AppData.HkPacket.Payload.EepromBaseline == 20"); + UtAssert_True(CS_AppData.HkPacket.Payload.OSBaseline == 21, "CS_AppData.HkPacket.Payload.OSBaseline == 21"); + UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreBaseline == 22, + "CS_AppData.HkPacket.Payload.CfeCoreBaseline == 22"); + UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotAddress == 23, + "CS_AppData.HkPacket.Payload.LastOneShotAddress == 23"); + UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotSize == 24, + "CS_AppData.HkPacket.Payload.LastOneShotSize == 24"); + UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotChecksum == 25, + "CS_AppData.HkPacket.Payload.LastOneShotChecksum == 25"); + UtAssert_True(CS_AppData.HkPacket.Payload.PassCounter == 26, "CS_AppData.HkPacket.Payload.PassCounter == 26"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + void CS_NoopCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_NoopCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "No-op command. Version %%d.%%d.%%d.%%d"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_NoopCmd(&CmdPacket); @@ -81,10 +171,11 @@ void CS_NoopCmd_Test(void) void CS_ResetCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ResetCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Reset Counters command recieved"); CS_AppData.HkPacket.Payload.CmdCounter = 1; @@ -97,19 +188,21 @@ void CS_ResetCmd_Test(void) CS_AppData.HkPacket.Payload.OSCSErrCounter = 8; CS_AppData.HkPacket.Payload.PassCounter = 9; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_ResetCmd(&CmdPacket); /* Verify results */ UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 0, "CS_AppData.HkPacket.Payload.CmdCounter == 0"); UtAssert_True(CS_AppData.HkPacket.Payload.CmdErrCounter == 0, "CS_AppData.HkPacket.Payload.CmdErrCounter == 0"); - UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSErrCounter == 0, "CS_AppData.HkPacket.Payload.EepromCSErrCounter == 0"); - UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSErrCounter == 0, "CS_AppData.HkPacket.Payload.MemoryCSErrCounter == 0"); - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSErrCounter == 0, "CS_AppData.HkPacket.Payload.TablesCSErrCounter == 0"); + UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSErrCounter == 0, + "CS_AppData.HkPacket.Payload.EepromCSErrCounter == 0"); + UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSErrCounter == 0, + "CS_AppData.HkPacket.Payload.MemoryCSErrCounter == 0"); + UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSErrCounter == 0, + "CS_AppData.HkPacket.Payload.TablesCSErrCounter == 0"); UtAssert_True(CS_AppData.HkPacket.Payload.AppCSErrCounter == 0, "CS_AppData.HkPacket.Payload.AppCSErrCounter == 0"); - UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSErrCounter == 0, "CS_AppData.HkPacket.Payload.CfeCoreCSErrCounter == 0"); + UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSErrCounter == 0, + "CS_AppData.HkPacket.Payload.CfeCoreCSErrCounter == 0"); UtAssert_True(CS_AppData.HkPacket.Payload.OSCSErrCounter == 0, "CS_AppData.HkPacket.Payload.OSCSErrCounter == 0"); UtAssert_True(CS_AppData.HkPacket.Payload.PassCounter == 0, "CS_AppData.HkPacket.Payload.PassCounter == 0"); @@ -126,83 +219,38 @@ void CS_ResetCmd_Test(void) call_count_CFE_EVS_SendEvent); } -void CS_BackgroundCheckCycle_Test_InvalidMsgLength(void) +void CS_BackgroundCheckCycleCmd_Test_BackgroundInProgress(void) { - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; - - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_BackgroundCheckCycleCmd_t CmdPacket; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; memset(&CmdPacket, 0, sizeof(CmdPacket)); - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "Invalid msg length: ID = 0x%%08lX, CC = %%d, Len = %%lu, Expected = %%lu"); - - /* Set size of packet to an invalid value (larger) and prevent InitMsg from writing past the end */ - CFE_MSG_SetFcnCode((CFE_MSG_Message_t *)&CmdPacket, 1); - - TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - MsgSize = sizeof(CS_NoArgsCmd_t) + 2; - FcnCode = 1; - - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - - /* Execute the function being tested */ - CS_BackgroundCheckCycle(&CmdPacket); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_CMD_LEN_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_BackgroundCheckCycle_Test_BackgroundInProgress(void) -{ - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Skipping background cycle. Recompute or oneshot in progress."); TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(CmdPacket); FcnCode = 1; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_ENABLED; - CS_AppData.HkPacket.Payload.CurrentCSTable = CS_CFECORE; - CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_STATE_ENABLED; - CS_AppData.CfeCoreCodeSeg.State = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.CurrentCSTable = CS_ChecksumType_CFECORE; + CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_ChecksumState_ENABLED; + CS_AppData.CfeCoreCodeSeg.State = CS_ChecksumState_ENABLED; CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_BackgroundCfeCore), 1, true); /* Execute the function being tested */ - CS_BackgroundCheckCycle(&CmdPacket); + CS_BackgroundCheckCycleCmd(&CmdPacket); /* Verify results */ UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_BKGND_COMPUTE_PROG_INF_EID); @@ -218,31 +266,31 @@ void CS_BackgroundCheckCycle_Test_BackgroundInProgress(void) call_count_CFE_EVS_SendEvent); } -void CS_BackgroundCheckCycle_Test_BackgroundCfeCore(void) +void CS_BackgroundCheckCycleCmd_Test_BackgroundCfeCore(void) { - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; + CS_BackgroundCheckCycleCmd_t CmdPacket; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + memset(&CmdPacket, 0, sizeof(CmdPacket)); TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(CmdPacket); FcnCode = 1; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_ENABLED; - CS_AppData.HkPacket.Payload.CurrentCSTable = CS_CFECORE; - CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_STATE_ENABLED; - CS_AppData.CfeCoreCodeSeg.State = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.CurrentCSTable = CS_ChecksumType_CFECORE; + CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_ChecksumState_ENABLED; + CS_AppData.CfeCoreCodeSeg.State = CS_ChecksumState_ENABLED; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_BackgroundCfeCore), 1, true); /* Execute the function being tested */ - CS_BackgroundCheckCycle(&CmdPacket); + CS_BackgroundCheckCycleCmd(&CmdPacket); /* Verify results */ call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -251,31 +299,31 @@ void CS_BackgroundCheckCycle_Test_BackgroundCfeCore(void) call_count_CFE_EVS_SendEvent); } -void CS_BackgroundCheckCycle_Test_BackgroundOS(void) +void CS_BackgroundCheckCycleCmd_Test_BackgroundOS(void) { - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; + CS_BackgroundCheckCycleCmd_t CmdPacket; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + memset(&CmdPacket, 0, sizeof(CmdPacket)); TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(CmdPacket); FcnCode = 1; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_ENABLED; - CS_AppData.HkPacket.Payload.CurrentCSTable = CS_OSCORE; - CS_AppData.HkPacket.Payload.OSCSState = CS_STATE_ENABLED; - CS_AppData.OSCodeSeg.State = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.CurrentCSTable = CS_ChecksumType_OSCORE; + CS_AppData.HkPacket.Payload.OSCSState = CS_ChecksumState_ENABLED; + CS_AppData.OSCodeSeg.State = CS_ChecksumState_ENABLED; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_BackgroundOS), 1, true); /* Execute the function being tested */ - CS_BackgroundCheckCycle(&CmdPacket); + CS_BackgroundCheckCycleCmd(&CmdPacket); /* Verify results */ call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -284,30 +332,30 @@ void CS_BackgroundCheckCycle_Test_BackgroundOS(void) call_count_CFE_EVS_SendEvent); } -void CS_BackgroundCheckCycle_Test_BackgroundEeprom(void) +void CS_BackgroundCheckCycleCmd_Test_BackgroundEeprom(void) { - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; + CS_BackgroundCheckCycleCmd_t CmdPacket; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + memset(&CmdPacket, 0, sizeof(CmdPacket)); TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(CmdPacket); FcnCode = 99; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_ENABLED; - CS_AppData.HkPacket.Payload.CurrentCSTable = CS_EEPROM_TABLE; - CS_AppData.HkPacket.Payload.EepromCSState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.CurrentCSTable = CS_ChecksumType_EEPROM_TABLE; + CS_AppData.HkPacket.Payload.EepromCSState = CS_ChecksumState_ENABLED; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_BackgroundEeprom), 1, true); /* Execute the function being tested */ - CS_BackgroundCheckCycle(&CmdPacket); + CS_BackgroundCheckCycleCmd(&CmdPacket); /* Verify results */ call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -316,30 +364,30 @@ void CS_BackgroundCheckCycle_Test_BackgroundEeprom(void) call_count_CFE_EVS_SendEvent); } -void CS_BackgroundCheckCycle_Test_BackgroundMemory(void) +void CS_BackgroundCheckCycleCmd_Test_BackgroundMemory(void) { - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; + CS_BackgroundCheckCycleCmd_t CmdPacket; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + memset(&CmdPacket, 0, sizeof(CmdPacket)); TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(CmdPacket); FcnCode = 99; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_ENABLED; - CS_AppData.HkPacket.Payload.CurrentCSTable = CS_MEMORY_TABLE; - CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.CurrentCSTable = CS_ChecksumType_MEMORY_TABLE; + CS_AppData.HkPacket.Payload.MemoryCSState = CS_ChecksumState_ENABLED; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_BackgroundMemory), 1, true); /* Execute the function being tested */ - CS_BackgroundCheckCycle(&CmdPacket); + CS_BackgroundCheckCycleCmd(&CmdPacket); /* Verify results */ call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -348,30 +396,30 @@ void CS_BackgroundCheckCycle_Test_BackgroundMemory(void) call_count_CFE_EVS_SendEvent); } -void CS_BackgroundCheckCycle_Test_BackgroundTables(void) +void CS_BackgroundCheckCycleCmd_Test_BackgroundTables(void) { - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; + CS_BackgroundCheckCycleCmd_t CmdPacket; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + memset(&CmdPacket, 0, sizeof(CmdPacket)); TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(CmdPacket); FcnCode = 1; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_ENABLED; - CS_AppData.HkPacket.Payload.CurrentCSTable = CS_TABLES_TABLE; - CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.CurrentCSTable = CS_ChecksumType_TABLES_TABLE; + CS_AppData.HkPacket.Payload.TablesCSState = CS_ChecksumState_ENABLED; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_BackgroundTables), 1, true); /* Execute the function being tested */ - CS_BackgroundCheckCycle(&CmdPacket); + CS_BackgroundCheckCycleCmd(&CmdPacket); /* Verify results */ call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -380,30 +428,30 @@ void CS_BackgroundCheckCycle_Test_BackgroundTables(void) call_count_CFE_EVS_SendEvent); } -void CS_BackgroundCheckCycle_Test_BackgroundApp(void) +void CS_BackgroundCheckCycleCmd_Test_BackgroundApp(void) { - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; + CS_BackgroundCheckCycleCmd_t CmdPacket; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + memset(&CmdPacket, 0, sizeof(CmdPacket)); TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(CmdPacket); FcnCode = 1; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_ENABLED; - CS_AppData.HkPacket.Payload.CurrentCSTable = CS_APP_TABLE; - CS_AppData.HkPacket.Payload.AppCSState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.CurrentCSTable = CS_ChecksumType_APP_TABLE; + CS_AppData.HkPacket.Payload.AppCSState = CS_ChecksumState_ENABLED; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_BackgroundApp), 1, true); /* Execute the function being tested */ - CS_BackgroundCheckCycle(&CmdPacket); + CS_BackgroundCheckCycleCmd(&CmdPacket); /* Verify results */ call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -412,32 +460,32 @@ void CS_BackgroundCheckCycle_Test_BackgroundApp(void) call_count_CFE_EVS_SendEvent); } -void CS_BackgroundCheckCycle_Test_Default(void) +void CS_BackgroundCheckCycleCmd_Test_Default(void) { - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; + CS_BackgroundCheckCycleCmd_t CmdPacket; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + memset(&CmdPacket, 0, sizeof(CmdPacket)); TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(CmdPacket); FcnCode = 1; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_ENABLED; CS_AppData.HkPacket.Payload.CurrentCSTable = 99; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ - CS_BackgroundCheckCycle(&CmdPacket); + CS_BackgroundCheckCycleCmd(&CmdPacket); /* Verify results */ UtAssert_True(CS_AppData.HkPacket.Payload.CurrentCSTable == 0, "CS_AppData.HkPacket.Payload.CurrentCSTable == 0"); - UtAssert_True(CS_AppData.HkPacket.Payload.CurrentEntryInTable == 0, "CS_AppData.HkPacket.Payload.CurrentEntryInTable == 0"); + UtAssert_True(CS_AppData.HkPacket.Payload.CurrentEntryInTable == 0, + "CS_AppData.HkPacket.Payload.CurrentEntryInTable == 0"); UtAssert_True(CS_AppData.HkPacket.Payload.PassCounter == 1, "CS_AppData.HkPacket.Payload.PassCounter == 1"); call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -446,27 +494,26 @@ void CS_BackgroundCheckCycle_Test_Default(void) call_count_CFE_EVS_SendEvent); } -void CS_BackgroundCheckCycle_Test_Disabled(void) +void CS_BackgroundCheckCycleCmd_Test_Disabled(void) { - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; + CS_BackgroundCheckCycleCmd_t CmdPacket; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + memset(&CmdPacket, 0, sizeof(CmdPacket)); TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(CmdPacket); FcnCode = 1; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_DISABLED; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_DISABLED; /* Execute the function being tested */ - CS_BackgroundCheckCycle(&CmdPacket); + CS_BackgroundCheckCycleCmd(&CmdPacket); /* Verify results */ UtAssert_True(CS_AppData.HkPacket.Payload.PassCounter == 0, "CS_AppData.HkPacket.Payload.PassCounter == 0"); @@ -477,39 +524,39 @@ void CS_BackgroundCheckCycle_Test_Disabled(void) call_count_CFE_EVS_SendEvent); } -void CS_BackgroundCheckCycle_Test_OneShot(void) +void CS_BackgroundCheckCycleCmd_Test_OneShot(void) { - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_BackgroundCheckCycleCmd_t CmdPacket; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Skipping background cycle. Recompute or oneshot in progress."); TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(CmdPacket); FcnCode = 1; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_ENABLED; - CS_AppData.HkPacket.Payload.CurrentCSTable = CS_CFECORE; - CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_STATE_ENABLED; - CS_AppData.CfeCoreCodeSeg.State = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.CurrentCSTable = CS_ChecksumType_CFECORE; + CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_ChecksumState_ENABLED; + CS_AppData.CfeCoreCodeSeg.State = CS_ChecksumState_ENABLED; CS_AppData.HkPacket.Payload.RecomputeInProgress = false; CS_AppData.HkPacket.Payload.OneShotInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_BackgroundCfeCore), 1, true); /* Execute the function being tested */ - CS_BackgroundCheckCycle(&CmdPacket); + CS_BackgroundCheckCycleCmd(&CmdPacket); /* Verify results */ UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_BKGND_COMPUTE_PROG_INF_EID); @@ -525,34 +572,34 @@ void CS_BackgroundCheckCycle_Test_OneShot(void) call_count_CFE_EVS_SendEvent); } -void CS_BackgroundCheckCycle_Test_EndOfList(void) +void CS_BackgroundCheckCycleCmd_Test_EndOfList(void) { - CS_NoArgsCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId; - CFE_MSG_FcnCode_t FcnCode; - size_t MsgSize; + CS_BackgroundCheckCycleCmd_t CmdPacket; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + size_t MsgSize; + memset(&CmdPacket, 0, sizeof(CmdPacket)); TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); - MsgSize = sizeof(CS_NoArgsCmd_t); + MsgSize = sizeof(CmdPacket); FcnCode = 1; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - CS_AppData.HkPacket.Payload.ChecksumState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.ChecksumState = CS_ChecksumState_ENABLED; CS_AppData.HkPacket.Payload.CurrentCSTable = CS_NUM_TABLES - 1; - CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_STATE_ENABLED; - CS_AppData.CfeCoreCodeSeg.State = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_ChecksumState_ENABLED; + CS_AppData.CfeCoreCodeSeg.State = CS_ChecksumState_ENABLED; CS_AppData.HkPacket.Payload.RecomputeInProgress = false; CS_AppData.HkPacket.Payload.OneShotInProgress = false; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_BackgroundCfeCore), 1, true); /* Execute the function being tested */ - CS_BackgroundCheckCycle(&CmdPacket); + CS_BackgroundCheckCycleCmd(&CmdPacket); /* Verify results */ call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -563,20 +610,19 @@ void CS_BackgroundCheckCycle_Test_EndOfList(void) void CS_DisableAllCSCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableAllCSCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Background Checksumming Disabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_DisableAllCSCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.ChecksumState == CS_STATE_DISABLED, - "CS_AppData.HkPacket.Payload.ChecksumState == CS_STATE_DISABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.ChecksumState == CS_ChecksumState_DISABLED, + "CS_AppData.HkPacket.Payload.ChecksumState == CS_ChecksumState_DISABLED"); UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 1, "CS_AppData.HkPacket.Payload.CmdCounter == 1"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_ALL_INF_EID); @@ -594,20 +640,19 @@ void CS_DisableAllCSCmd_Test(void) void CS_EnableAllCSCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableAllCSCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Background Checksumming Enabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_EnableAllCSCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.ChecksumState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.ChecksumState == CS_STATE_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.ChecksumState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.ChecksumState == CS_ChecksumState_ENABLED"); UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 1, "CS_AppData.HkPacket.Payload.CmdCounter == 1"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ENABLE_ALL_INF_EID); @@ -625,20 +670,19 @@ void CS_EnableAllCSCmd_Test(void) void CS_DisableCfeCoreCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableCfeCoreCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of cFE Core is Disabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_DisableCfeCoreCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_STATE_DISABLED, - "CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_STATE_DISABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_ChecksumState_DISABLED, + "CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_ChecksumState_DISABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_CFECORE_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -657,20 +701,19 @@ void CS_DisableCfeCoreCmd_Test(void) void CS_EnableCfeCoreCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableCfeCoreCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of cFE Core is Enabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_EnableCfeCoreCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_STATE_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.CfeCoreCSState == CS_ChecksumState_ENABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ENABLE_CFECORE_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -689,20 +732,19 @@ void CS_EnableCfeCoreCmd_Test(void) void CS_DisableOSCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableOSCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of OS code segment is Disabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_DisableOSCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.OSCSState == CS_STATE_DISABLED, - "CS_AppData.HkPacket.Payload.OSCSState == CS_STATE_DISABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.OSCSState == CS_ChecksumState_DISABLED, + "CS_AppData.HkPacket.Payload.OSCSState == CS_ChecksumState_DISABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_OS_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -721,20 +763,19 @@ void CS_DisableOSCmd_Test(void) void CS_EnableOSCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableOSCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of OS code segment is Enabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_EnableOSCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.OSCSState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.OSCSState == CS_STATE_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.OSCSState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.OSCSState == CS_ChecksumState_ENABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ENABLE_OS_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -753,17 +794,16 @@ void CS_EnableOSCmd_Test(void) void CS_ReportBaselineCfeCoreCmd_Test_Nominal(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineCfeCoreCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Baseline of cFE Core is 0x%%08X"); CS_AppData.CfeCoreCodeSeg.ComputedYet = true; CS_AppData.CfeCoreCodeSeg.ComparisonValue = -1; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_ReportBaselineCfeCoreCmd(&CmdPacket); @@ -785,16 +825,15 @@ void CS_ReportBaselineCfeCoreCmd_Test_Nominal(void) void CS_ReportBaselineCfeCoreCmd_Test_NotComputedYet(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineCfeCoreCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Baseline of cFE Core has not been computed yet"); CS_AppData.CfeCoreCodeSeg.ComputedYet = false; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_ReportBaselineCfeCoreCmd(&CmdPacket); @@ -816,17 +855,16 @@ void CS_ReportBaselineCfeCoreCmd_Test_NotComputedYet(void) void CS_ReportBaselineOSCmd_Test_Nominal(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineOSCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Baseline of OS code segment is 0x%%08X"); CS_AppData.OSCodeSeg.ComputedYet = true; CS_AppData.OSCodeSeg.ComparisonValue = -1; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_ReportBaselineOSCmd(&CmdPacket); @@ -848,17 +886,16 @@ void CS_ReportBaselineOSCmd_Test_Nominal(void) void CS_ReportBaselineOSCmd_Test_NotComputedYet(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineOSCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Baseline of OS code segment has not been computed yet"); CS_AppData.OSCodeSeg.ComputedYet = false; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_ReportBaselineOSCmd(&CmdPacket); @@ -880,23 +917,25 @@ void CS_ReportBaselineOSCmd_Test_NotComputedYet(void) void CS_RecomputeBaselineCfeCoreCmd_Test_Nominal(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineCfeCoreCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute of cFE core started"); CS_AppData.HkPacket.Payload.RecomputeInProgress = false; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineCfeCoreCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == true, "CS_AppData.HkPacket.Payload.RecomputeInProgress == true"); - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); - UtAssert_True(CS_AppData.ChildTaskTable == CS_CFECORE, "CS_AppData.ChildTaskTable == CS_CFECORE"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == true, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == true"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, + "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); + UtAssert_True(CS_AppData.ChildTaskTable == CS_ChecksumType_CFECORE, + "CS_AppData.ChildTaskTable == CS_ChecksumType_CFECORE"); UtAssert_True(CS_AppData.ChildTaskEntryID == 0, "CS_AppData.ChildTaskEntryID == 0"); UtAssert_True(CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.CfeCoreCodeSeg, "CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.CfeCoreCodeSeg"); @@ -918,10 +957,11 @@ void CS_RecomputeBaselineCfeCoreCmd_Test_Nominal(void) void CS_RecomputeBaselineCfeCoreCmd_Test_CreateChildTaskError(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineCfeCoreCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute cFE core failed, CFE_ES_CreateChildTask returned: 0x%%08X"); @@ -930,14 +970,14 @@ void CS_RecomputeBaselineCfeCoreCmd_Test_CreateChildTaskError(void) /* Set to generate error message CS_RECOMPUTE_CFECORE_CREATE_CHDTASK_ERR_EID */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CreateChildTask), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineCfeCoreCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); - UtAssert_True(CS_AppData.ChildTaskTable == CS_CFECORE, "CS_AppData.ChildTaskTable == CS_CFECORE"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, + "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); + UtAssert_True(CS_AppData.ChildTaskTable == CS_ChecksumType_CFECORE, + "CS_AppData.ChildTaskTable == CS_ChecksumType_CFECORE"); UtAssert_True(CS_AppData.ChildTaskEntryID == 0, "CS_AppData.ChildTaskEntryID == 0"); UtAssert_True(CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.CfeCoreCodeSeg, "CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.CfeCoreCodeSeg"); @@ -950,7 +990,8 @@ void CS_RecomputeBaselineCfeCoreCmd_Test_CreateChildTaskError(void) UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); UtAssert_True(CS_AppData.HkPacket.Payload.CmdErrCounter == 1, "CS_AppData.HkPacket.Payload.CmdErrCounter == 1"); - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -960,16 +1001,15 @@ void CS_RecomputeBaselineCfeCoreCmd_Test_CreateChildTaskError(void) void CS_RecomputeBaselineCfeCoreCmd_Test_ChildTaskError(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineCfeCoreCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute cFE core failed: child task in use"); CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineCfeCoreCmd(&CmdPacket); @@ -991,18 +1031,17 @@ void CS_RecomputeBaselineCfeCoreCmd_Test_ChildTaskError(void) void CS_RecomputeBaselineCfeCoreCmd_Test_OneShot(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineCfeCoreCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute cFE core failed: child task in use"); CS_AppData.HkPacket.Payload.RecomputeInProgress = false; CS_AppData.HkPacket.Payload.OneShotInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineCfeCoreCmd(&CmdPacket); @@ -1024,23 +1063,25 @@ void CS_RecomputeBaselineCfeCoreCmd_Test_OneShot(void) void CS_RecomputeBaselineOSCmd_Test_Nominal(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineOSCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute of OS code segment started"); CS_AppData.HkPacket.Payload.RecomputeInProgress = false; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineOSCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == true, "CS_AppData.HkPacket.Payload.RecomputeInProgress == true"); - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); - UtAssert_True(CS_AppData.ChildTaskTable == CS_OSCORE, "CS_AppData.ChildTaskTable == CS_OSCORE"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == true, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == true"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, + "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); + UtAssert_True(CS_AppData.ChildTaskTable == CS_ChecksumType_OSCORE, + "CS_AppData.ChildTaskTable == CS_ChecksumType_OSCORE"); UtAssert_True(CS_AppData.ChildTaskEntryID == 0, "CS_AppData.OSCodeSeg == 0"); UtAssert_True(CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.OSCodeSeg, "CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.OSCodeSeg"); @@ -1062,10 +1103,11 @@ void CS_RecomputeBaselineOSCmd_Test_Nominal(void) void CS_RecomputeBaselineOSCmd_Test_CreateChildTaskError(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineOSCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute OS code segment failed, CFE_ES_CreateChildTask returned: 0x%%08X"); @@ -1074,14 +1116,14 @@ void CS_RecomputeBaselineOSCmd_Test_CreateChildTaskError(void) /* Set to generate error message CS_RECOMPUTE_OS_CREATE_CHDTASK_ERR_EID */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CreateChildTask), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineOSCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); - UtAssert_True(CS_AppData.ChildTaskTable == CS_OSCORE, "CS_AppData.ChildTaskTable == CS_OSCORE"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, + "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); + UtAssert_True(CS_AppData.ChildTaskTable == CS_ChecksumType_OSCORE, + "CS_AppData.ChildTaskTable == CS_ChecksumType_OSCORE"); UtAssert_True(CS_AppData.ChildTaskEntryID == 0, "CS_AppData.OSCodeSeg == 0"); UtAssert_True(CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.OSCodeSeg, "CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.OSCodeSeg"); @@ -1094,7 +1136,8 @@ void CS_RecomputeBaselineOSCmd_Test_CreateChildTaskError(void) UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); UtAssert_True(CS_AppData.HkPacket.Payload.CmdErrCounter == 1, "CS_AppData.HkPacket.Payload.CmdErrCounter == 1"); - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -1104,17 +1147,16 @@ void CS_RecomputeBaselineOSCmd_Test_CreateChildTaskError(void) void CS_RecomputeBaselineOSCmd_Test_ChildTaskError(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineOSCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute OS code segment failed: child task in use"); CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineOSCmd(&CmdPacket); @@ -1136,10 +1178,11 @@ void CS_RecomputeBaselineOSCmd_Test_ChildTaskError(void) void CS_RecomputeBaselineOSCmd_Test_OneShot(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineOSCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute OS code segment failed: child task in use"); @@ -1147,8 +1190,6 @@ void CS_RecomputeBaselineOSCmd_Test_OneShot(void) CS_AppData.HkPacket.Payload.OneShotInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineOSCmd(&CmdPacket); @@ -1174,6 +1215,7 @@ void CS_OneShotCmd_Test_Nominal(void) int32 strCmpResult; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "OneShot checksum started on address: 0x%%08X, size: %%d"); @@ -1182,22 +1224,23 @@ void CS_OneShotCmd_Test_Nominal(void) CmdPacket.Payload.MaxBytesPerCycle = 0; CS_AppData.HkPacket.Payload.RecomputeInProgress = false; - CS_AppData.MaxBytesPerCycle = 8; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_AppData.MaxBytesPerCycle = 8; /* Execute the function being tested */ CS_OneShotCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == true, "CS_AppData.HkPacket.Payload.OneShotInProgress == true"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == true, + "CS_AppData.HkPacket.Payload.OneShotInProgress == true"); UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotAddress == CmdPacket.Payload.Address, "CS_AppData.HkPacket.Payload.LastOneShotAddress == CmdPacket.Payload.Address"); UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotSize == CmdPacket.Payload.Size, "CS_AppData.HkPacket.Payload.LastOneShotSize == CmdPacket.Payload.Size"); - UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotChecksum == 0, "CS_AppData.HkPacket.Payload.LastOneShotChecksum == 0"); + UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotChecksum == 0, + "CS_AppData.HkPacket.Payload.LastOneShotChecksum == 0"); UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotMaxBytesPerCycle == CS_AppData.MaxBytesPerCycle, "CS_AppData.HkPacket.Payload.LastOneShotMaxBytesPerCycle == CS_AppData.MaxBytesPerCycle"); @@ -1223,6 +1266,7 @@ void CS_OneShotCmd_Test_MaxBytesPerCycleNonZero(void) int32 strCmpResult; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "OneShot checksum started on address: 0x%%08X, size: %%d"); @@ -1231,22 +1275,23 @@ void CS_OneShotCmd_Test_MaxBytesPerCycleNonZero(void) CmdPacket.Payload.MaxBytesPerCycle = 1; CS_AppData.HkPacket.Payload.RecomputeInProgress = false; - CS_AppData.MaxBytesPerCycle = 8; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_AppData.MaxBytesPerCycle = 8; /* Execute the function being tested */ CS_OneShotCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == true, "CS_AppData.HkPacket.Payload.OneShotInProgress == true"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == true, + "CS_AppData.HkPacket.Payload.OneShotInProgress == true"); UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotAddress == CmdPacket.Payload.Address, "CS_AppData.HkPacket.Payload.LastOneShotAddress == CmdPacket.Payload.Address"); UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotSize == CmdPacket.Payload.Size, "CS_AppData.HkPacket.Payload.LastOneShotSize == CmdPacket.Payload.Size"); - UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotChecksum == 0, "CS_AppData.HkPacket.Payload.LastOneShotChecksum == 0"); + UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotChecksum == 0, + "CS_AppData.HkPacket.Payload.LastOneShotChecksum == 0"); UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotMaxBytesPerCycle == CmdPacket.Payload.MaxBytesPerCycle, "CS_AppData.HkPacket.Payload.LastOneShotMaxBytesPerCycle == CmdPacket.Payload.MaxBytesPerCycle"); @@ -1282,8 +1327,6 @@ void CS_OneShotCmd_Test_CreateChildTaskError(void) /* Set to generate error message CS_RECOMPUTE_OS_CREATE_CHDTASK_ERR_EID */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CreateChildTask), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_OneShotCmd(&CmdPacket); @@ -1292,7 +1335,8 @@ void CS_OneShotCmd_Test_CreateChildTaskError(void) "CS_AppData.HkPacket.Payload.LastOneShotAddress == CmdPacket.Payload.Address"); UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotSize == CmdPacket.Payload.Size, "CS_AppData.HkPacket.Payload.LastOneShotSize == CmdPacket.Payload.Size"); - UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotChecksum == 0, "CS_AppData.HkPacket.Payload.LastOneShotChecksum == 0"); + UtAssert_True(CS_AppData.HkPacket.Payload.LastOneShotChecksum == 0, + "CS_AppData.HkPacket.Payload.LastOneShotChecksum == 0"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ONESHOT_CREATE_CHDTASK_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); @@ -1302,8 +1346,10 @@ void CS_OneShotCmd_Test_CreateChildTaskError(void) UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); UtAssert_True(CS_AppData.HkPacket.Payload.CmdErrCounter == 1, "CS_AppData.HkPacket.Payload.CmdErrCounter == 1"); - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, + "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -1317,12 +1363,11 @@ void CS_OneShotCmd_Test_ChildTaskError(void) int32 strCmpResult; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "OneShot checksum failed: child task in use"); CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_OneShotCmd(&CmdPacket); @@ -1348,6 +1393,7 @@ void CS_OneShotCmd_Test_MemValidateRangeError(void) int32 strCmpResult; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "OneShot checksum failed, CFE_PSP_MemValidateRange returned: 0x%%08X"); @@ -1356,8 +1402,6 @@ void CS_OneShotCmd_Test_MemValidateRangeError(void) /* Set to generate error message CS_ONESHOT_MEMVALIDATE_ERR_EID */ UT_SetDeferredRetcode(UT_KEY(CFE_PSP_MemValidateRange), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_OneShotCmd(&CmdPacket); @@ -1383,14 +1427,13 @@ void CS_OneShotCmd_Test_OneShot(void) int32 strCmpResult; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "OneShot checksum failed: child task in use"); CS_AppData.HkPacket.Payload.RecomputeInProgress = false; CS_AppData.HkPacket.Payload.OneShotInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_OneShotCmd(&CmdPacket); @@ -1412,25 +1455,26 @@ void CS_OneShotCmd_Test_OneShot(void) void CS_CancelOneShotCmd_Test_Nominal(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_CancelOneShotCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "OneShot checksum calculation has been cancelled"); CS_AppData.HkPacket.Payload.RecomputeInProgress = false; CS_AppData.HkPacket.Payload.OneShotInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_CancelOneShotCmd(&CmdPacket); /* Verify results */ UtAssert_BOOL_FALSE(CFE_RESOURCEID_TEST_DEFINED(CS_AppData.ChildTaskID)); - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, + "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 1, "CS_AppData.HkPacket.Payload.CmdCounter == 1"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ONESHOT_CANCELLED_INF_EID); @@ -1448,10 +1492,11 @@ void CS_CancelOneShotCmd_Test_Nominal(void) void CS_CancelOneShotCmd_Test_DeleteChildTaskError(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_CancelOneShotCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Cancel OneShot checksum failed, CFE_ES_DeleteChildTask returned: 0x%%08X"); @@ -1461,8 +1506,6 @@ void CS_CancelOneShotCmd_Test_DeleteChildTaskError(void) /* Set to generate error message CS_ONESHOT_CANCEL_DELETE_CHDTASK_ERR_EID */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_DeleteChildTask), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_CancelOneShotCmd(&CmdPacket); @@ -1484,10 +1527,11 @@ void CS_CancelOneShotCmd_Test_DeleteChildTaskError(void) void CS_CancelOneShotCmd_Test_NoChildTaskError(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_CancelOneShotCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Cancel OneShot checksum failed. No OneShot active"); @@ -1497,8 +1541,6 @@ void CS_CancelOneShotCmd_Test_NoChildTaskError(void) /* Set to generate error message CS_ONESHOT_CANCEL_NO_CHDTASK_ERR_EID */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_DeleteChildTask), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_CancelOneShotCmd(&CmdPacket); @@ -1520,10 +1562,11 @@ void CS_CancelOneShotCmd_Test_NoChildTaskError(void) void CS_CancelOneShotCmd_Test_OneShot(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_CancelOneShotCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Cancel OneShot checksum failed. No OneShot active"); @@ -1533,8 +1576,6 @@ void CS_CancelOneShotCmd_Test_OneShot(void) /* Set to generate error message CS_ONESHOT_CANCEL_NO_CHDTASK_ERR_EID */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_DeleteChildTask), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_CancelOneShotCmd(&CmdPacket); @@ -1556,34 +1597,34 @@ void CS_CancelOneShotCmd_Test_OneShot(void) void UtTest_Setup(void) { + UtTest_Add(CS_SendHkCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, "CS_SendHkCmd_Test_Nominal"); + UtTest_Add(CS_NoopCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_NoopCmd_Test"); UtTest_Add(CS_ResetCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_ResetCmd_Test"); - UtTest_Add(CS_BackgroundCheckCycle_Test_InvalidMsgLength, CS_Test_Setup, CS_Test_TearDown, - "CS_BackgroundCheckCycle_Test_InvalidMsgLength"); - UtTest_Add(CS_BackgroundCheckCycle_Test_BackgroundInProgress, CS_Test_Setup, CS_Test_TearDown, - "CS_BackgroundCheckCycle_Test_BackgroundInProgress"); - UtTest_Add(CS_BackgroundCheckCycle_Test_BackgroundCfeCore, CS_Test_Setup, CS_Test_TearDown, - "CS_BackgroundCheckCycle_Test_BackgroundCfeCore"); - UtTest_Add(CS_BackgroundCheckCycle_Test_BackgroundOS, CS_Test_Setup, CS_Test_TearDown, - "CS_BackgroundCheckCycle_Test_BackgroundOS"); - UtTest_Add(CS_BackgroundCheckCycle_Test_BackgroundEeprom, CS_Test_Setup, CS_Test_TearDown, - "CS_BackgroundCheckCycle_Test_BackgroundEeprom"); - UtTest_Add(CS_BackgroundCheckCycle_Test_BackgroundMemory, CS_Test_Setup, CS_Test_TearDown, - "CS_BackgroundCheckCycle_Test_BackgroundMemory"); - UtTest_Add(CS_BackgroundCheckCycle_Test_BackgroundTables, CS_Test_Setup, CS_Test_TearDown, - "CS_BackgroundCheckCycle_Test_BackgroundTables"); - UtTest_Add(CS_BackgroundCheckCycle_Test_BackgroundApp, CS_Test_Setup, CS_Test_TearDown, - "CS_BackgroundCheckCycle_Test_BackgroundApp"); - UtTest_Add(CS_BackgroundCheckCycle_Test_Default, CS_Test_Setup, CS_Test_TearDown, - "CS_BackgroundCheckCycle_Test_Default"); - UtTest_Add(CS_BackgroundCheckCycle_Test_Disabled, CS_Test_Setup, CS_Test_TearDown, - "CS_BackgroundCheckCycle_Test_Disabled"); - UtTest_Add(CS_BackgroundCheckCycle_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, - "CS_BackgroundCheckCycle_Test_OneShot"); - UtTest_Add(CS_BackgroundCheckCycle_Test_EndOfList, CS_Test_Setup, CS_Test_TearDown, - "CS_BackgroundCheckCycle_Test_EndOfList"); + UtTest_Add(CS_BackgroundCheckCycleCmd_Test_BackgroundInProgress, CS_Test_Setup, CS_Test_TearDown, + "CS_BackgroundCheckCycleCmd_Test_BackgroundInProgress"); + UtTest_Add(CS_BackgroundCheckCycleCmd_Test_BackgroundCfeCore, CS_Test_Setup, CS_Test_TearDown, + "CS_BackgroundCheckCycleCmd_Test_BackgroundCfeCore"); + UtTest_Add(CS_BackgroundCheckCycleCmd_Test_BackgroundOS, CS_Test_Setup, CS_Test_TearDown, + "CS_BackgroundCheckCycleCmd_Test_BackgroundOS"); + UtTest_Add(CS_BackgroundCheckCycleCmd_Test_BackgroundEeprom, CS_Test_Setup, CS_Test_TearDown, + "CS_BackgroundCheckCycleCmd_Test_BackgroundEeprom"); + UtTest_Add(CS_BackgroundCheckCycleCmd_Test_BackgroundMemory, CS_Test_Setup, CS_Test_TearDown, + "CS_BackgroundCheckCycleCmd_Test_BackgroundMemory"); + UtTest_Add(CS_BackgroundCheckCycleCmd_Test_BackgroundTables, CS_Test_Setup, CS_Test_TearDown, + "CS_BackgroundCheckCycleCmd_Test_BackgroundTables"); + UtTest_Add(CS_BackgroundCheckCycleCmd_Test_BackgroundApp, CS_Test_Setup, CS_Test_TearDown, + "CS_BackgroundCheckCycleCmd_Test_BackgroundApp"); + UtTest_Add(CS_BackgroundCheckCycleCmd_Test_Default, CS_Test_Setup, CS_Test_TearDown, + "CS_BackgroundCheckCycleCmd_Test_Default"); + UtTest_Add(CS_BackgroundCheckCycleCmd_Test_Disabled, CS_Test_Setup, CS_Test_TearDown, + "CS_BackgroundCheckCycleCmd_Test_Disabled"); + UtTest_Add(CS_BackgroundCheckCycleCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, + "CS_BackgroundCheckCycleCmd_Test_OneShot"); + UtTest_Add(CS_BackgroundCheckCycleCmd_Test_EndOfList, CS_Test_Setup, CS_Test_TearDown, + "CS_BackgroundCheckCycleCmd_Test_EndOfList"); UtTest_Add(CS_DisableAllCSCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_DisableAllCSCmd_Test"); diff --git a/unit-test/cs_compute_tests.c b/unit-test/cs_compute_tests.c index 8dc60da..f1b375d 100644 --- a/unit-test/cs_compute_tests.c +++ b/unit-test/cs_compute_tests.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -24,7 +23,7 @@ #include "cs_compute.h" #include "cs_msg.h" #include "cs_msgdefs.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_version.h" #include "cs_utils.h" #include "cs_test_utils.h" @@ -66,7 +65,7 @@ void CS_COMPUTE_TEST_CFE_TBL_ShareHandler(void *UserObj, UT_EntryKey_t FuncKey, CFE_TBL_Handle_t *TblHandlePtr = (CFE_TBL_Handle_t *)UT_Hook_GetArgValueByName(Context, "TblHandlePtr", CFE_TBL_Handle_t *); - *TblHandlePtr = 99; + *TblHandlePtr = CFE_TBL_HandleFromID(CFE_TBL_HANDLEID_C(CFE_ResourceId_FromInteger(99))); } void CS_COMPUTE_TEST_CFE_ES_GetModuleInfoHandler1(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context) @@ -87,6 +86,22 @@ void CS_COMPUTE_TEST_CFE_ES_GetModuleInfoHandler2(void *UserObj, UT_EntryKey_t F AppInfo->AddressesAreValid = false; } +void CS_COMPUTE_TEST_CS_GetDefTblEntryByName(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context) +{ + void **EntryPtr = UT_Hook_GetArgValueByName(Context, "EntryPtr", void **); + bool Retval; + + if (EntryPtr != NULL) + { + *EntryPtr = UserObj; + } + if (!UT_Stub_GetInt32StatusCode(Context, NULL)) + { + Retval = (UserObj != NULL); + UT_Stub_SetReturnValue(FuncKey, Retval); + } +} + void CS_ComputeEepromMemory_Test_Nominal(void) { CS_Res_EepromMemory_Table_Entry_t ResultsEntry; @@ -166,8 +181,8 @@ void CS_ComputeEepromMemory_Test_FirstTimeThrough(void) UtAssert_BOOL_TRUE(ResultsEntry.ComputedYet); UtAssert_UINT32_EQ(ResultsEntry.ComparisonValue, 1); UtAssert_UINT32_EQ(ComputedCSValue, 1); - UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 0); - UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, 0); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, ResultsEntry.NumBytesToChecksum); + UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, ComputedCSValue); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } @@ -198,30 +213,60 @@ void CS_ComputeEepromMemory_Test_NotFinished(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } +void CS_ComputeEepromMemory_Test_OffsetlargerThanBytesCheck(void) +{ + CS_Res_EepromMemory_Table_Entry_t ResultsEntry; + uint32 ComputedCSValue = 0; + bool DoneWithEntry = false; + + memset(&ResultsEntry, 0, sizeof(ResultsEntry)); + + ResultsEntry.NumBytesToChecksum = 2; + ResultsEntry.ByteOffset = 3; + CS_AppData.MaxBytesPerCycle = 5; + + ResultsEntry.ComputedYet = false; + + /* ComputedCSValue and ResultsEntry.TempChecksumValue will be set to value returned by this function */ + UT_SetDeferredRetcode(UT_KEY(CFE_ES_CalculateCRC), 1, 1); + + /* Execute the function being tested */ + UtAssert_UINT32_EQ(CS_ComputeEepromMemory(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CFE_SUCCESS); + + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, ResultsEntry.NumBytesToChecksum); + UtAssert_UINT32_EQ(ResultsEntry.ComparisonValue, 1); + UtAssert_BOOL_TRUE(DoneWithEntry); +} + void CS_ComputeTables_Test_TableNeverLoaded(void) { CS_Res_Tables_Table_Entry_t ResultsEntry; uint32 ComputedCSValue = 0; bool DoneWithEntry = true; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + uint8 TblData[5]; + void * TblAddr; memset(&ResultsEntry, 0, sizeof(ResultsEntry)); - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables: Problem Getting table %%s info Share: 0x%%08X, GetInfo: 0x%%08X, GetAddress: 0x%%08X"); + CS_AppData.MaxBytesPerCycle = sizeof(TblData) - 1; + TblAddr = TblData; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_C(CFE_ResourceId_FromInteger(99)); + ResultsEntry.NumBytesToChecksum = sizeof(TblData); + ResultsEntry.StartAddress = CFE_ES_MEMADDRESS_C(TblAddr); - ResultsEntry.TblHandle = 99; + snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, + "CS Tables: Problem Getting table %%s: Status=0x%%08X"); strncpy(ResultsEntry.Name, "name", 10); - /* Set to satisfy first instance of condition "ResultGetAddress == CFE_TBL_ERR_NEVER_LOADED" */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 1, CFE_TBL_ERR_NEVER_LOADED); + UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_TBL_ERR_NEVER_LOADED); /* Execute the function being tested */ UtAssert_UINT32_EQ(CS_ComputeTables(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CS_ERR_NOT_FOUND); /* Verify results */ - UtAssert_BOOL_FALSE(DoneWithEntry); + UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_COMPUTE_TABLES_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); @@ -230,6 +275,128 @@ void CS_ComputeTables_Test_TableNeverLoaded(void) CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_STUB_COUNT(CFE_TBL_Unregister, 1); +} + +void CS_ComputeTables_Test_TableAddressChange(void) +{ + CS_Res_Tables_Table_Entry_t ResultsEntry; + uint32 ComputedCSValue = 0; + bool DoneWithEntry = true; + uint8 TblData[6]; + void * TblAddr; + + memset(&ResultsEntry, 0, sizeof(ResultsEntry)); + + /* This test case represents the situation where a table checksum needs multiple cycles, + * and the address and size do NOT change in the interim between cycles. */ + memset(&ResultsEntry, 0, sizeof(ResultsEntry)); + + CS_AppData.MaxBytesPerCycle = sizeof(TblData) / 2; + TblAddr = &TblData[1]; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_C(CFE_ResourceId_FromInteger(99)); + ResultsEntry.NumBytesToChecksum = sizeof(TblData) - 1; + ResultsEntry.StartAddress = CFE_ES_MEMADDRESS_C(TblAddr); + ResultsEntry.ByteOffset = 1; + + strncpy(ResultsEntry.Name, "name", 10); + + /* Note this is setting up a _different_ address for the table */ + TblAddr = TblData; + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); + + /* Execute the function being tested */ + UtAssert_UINT32_EQ(CS_ComputeTables(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CFE_SUCCESS); + + /* Verify results */ + UtAssert_BOOL_FALSE(DoneWithEntry); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), TblAddr); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, CS_AppData.MaxBytesPerCycle); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); + UtAssert_STUB_COUNT(CFE_TBL_Unregister, 0); + UtAssert_STUB_COUNT(CFE_TBL_GetAddress, 1); + UtAssert_STUB_COUNT(CFE_TBL_ReleaseAddress, 1); +} + +void CS_ComputeTables_Test_TableResume(void) +{ + CS_Res_Tables_Table_Entry_t ResultsEntry; + uint32 ComputedCSValue = 0; + bool DoneWithEntry = true; + uint8 TblData[6]; + void * TblAddr; + + memset(&ResultsEntry, 0, sizeof(ResultsEntry)); + + /* This test case represents the situation where a table checksum needs multiple cycles, + * and the address and size do NOT change in the interim between cycles. */ + memset(&ResultsEntry, 0, sizeof(ResultsEntry)); + + CS_AppData.MaxBytesPerCycle = sizeof(TblData) / 2; + TblAddr = TblData; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_C(CFE_ResourceId_FromInteger(99)); + ResultsEntry.NumBytesToChecksum = sizeof(TblData); + ResultsEntry.StartAddress = CFE_ES_MEMADDRESS_C(TblAddr); + ResultsEntry.ByteOffset = 1; + + strncpy(ResultsEntry.Name, "name", 10); + + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); + + /* Execute the function being tested */ + UtAssert_UINT32_EQ(CS_ComputeTables(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CFE_SUCCESS); + + /* Verify results */ + UtAssert_BOOL_FALSE(DoneWithEntry); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), TblAddr); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 1 + CS_AppData.MaxBytesPerCycle); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); + UtAssert_STUB_COUNT(CFE_TBL_Unregister, 0); + UtAssert_STUB_COUNT(CFE_TBL_GetAddress, 1); + UtAssert_STUB_COUNT(CFE_TBL_ReleaseAddress, 1); +} + +void CS_ComputeTables_Test_TableAddressNULL(void) +{ + CS_Res_Tables_Table_Entry_t ResultsEntry; + uint32 ComputedCSValue = 0; + bool DoneWithEntry = true; + uint8 TblData[6]; + void * TblAddr; + + memset(&ResultsEntry, 0, sizeof(ResultsEntry)); + + /* This test case represents the situation where a table checksum needs multiple cycles, + * and the address and size do NOT change in the interim between cycles. */ + memset(&ResultsEntry, 0, sizeof(ResultsEntry)); + + CS_AppData.MaxBytesPerCycle = sizeof(TblData) / 2; + TblAddr = &TblData[1]; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_C(CFE_ResourceId_FromInteger(99)); + ResultsEntry.NumBytesToChecksum = sizeof(TblData) - 1; + ResultsEntry.StartAddress = CFE_ES_MEMADDRESS_C(TblAddr); + ResultsEntry.ByteOffset = 1; + + strncpy(ResultsEntry.Name, "name", 10); + + /* Note this is not a valid case, the address should never really be NULL */ + TblAddr = NULL; + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); + + /* Execute the function being tested */ + UtAssert_UINT32_EQ(CS_ComputeTables(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CS_ERR_NOT_FOUND); + + /* Verify results */ + UtAssert_BOOL_TRUE(DoneWithEntry); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), TblAddr); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 0); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_COMPUTE_TABLES_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); } void CS_ComputeTables_Test_TableUnregisteredAndNeverLoaded(void) @@ -242,9 +409,9 @@ void CS_ComputeTables_Test_TableUnregisteredAndNeverLoaded(void) memset(&ResultsEntry, 0, sizeof(ResultsEntry)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables: Problem Getting table %%s info Share: 0x%%08X, GetInfo: 0x%%08X, GetAddress: 0x%%08X"); + "CS Tables: Problem Getting table %%s: Status=0x%%08X"); - ResultsEntry.TblHandle = 99; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_C(CFE_ResourceId_FromInteger(99)); strncpy(ResultsEntry.Name, "name", 10); @@ -255,16 +422,15 @@ void CS_ComputeTables_Test_TableUnregisteredAndNeverLoaded(void) * CFE_TBL_ERR_NEVER_LOADED" */ UT_SetHookFunction(UT_KEY(CFE_TBL_GetAddress), &CS_COMPUTE_TEST_CFE_TBL_GetAddressHook, NULL); UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_ERR_NEVER_LOADED); - UT_SetDeferredRetcode(UT_KEY(CS_AttemptTableReshare), 1, -1); /* Execute the function being tested */ UtAssert_UINT32_EQ(CS_ComputeTables(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CS_ERR_NOT_FOUND); /* Verify results */ - UtAssert_BOOL_FALSE(DoneWithEntry); + UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_UINT32_EQ(ResultsEntry.ComparisonValue, 0); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 0); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), 0); UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, 0); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_COMPUTE_TABLES_ERR_EID); @@ -286,9 +452,9 @@ void CS_ComputeTables_Test_ResultShareNotSuccess(void) memset(&ResultsEntry, 0, sizeof(ResultsEntry)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables: Problem Getting table %%s info Share: 0x%%08X, GetInfo: 0x%%08X, GetAddress: 0x%%08X"); + "CS Tables: Problem Getting table %%s: Status=0x%%08X"); - ResultsEntry.TblHandle = CFE_TBL_BAD_TABLE_HANDLE; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_UNDEFINED; strncpy(ResultsEntry.Name, "name", 10); @@ -297,7 +463,6 @@ void CS_ComputeTables_Test_ResultShareNotSuccess(void) /* Set to fail subsequent condition "ResultShare == CFE_SUCCESS" */ UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Share), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_AttemptTableReshare), 1, -1); /* Set to satisfy second instance of condition "ResultGetAddress == CFE_TBL_ERR_NEVER_LOADED" */ UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 1, CFE_TBL_ERR_UNREGISTERED); @@ -306,9 +471,7 @@ void CS_ComputeTables_Test_ResultShareNotSuccess(void) UtAssert_UINT32_EQ(CS_ComputeTables(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CS_ERR_NOT_FOUND); /* Verify results */ - UtAssert_BOOL_FALSE(DoneWithEntry); - - UtAssert_INT32_EQ(ResultsEntry.TblHandle, CFE_TBL_BAD_TABLE_HANDLE); + UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_COMPUTE_TABLES_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); @@ -325,15 +488,20 @@ void CS_ComputeTables_Test_TblInfoUpdated(void) uint32 ComputedCSValue = 0; bool DoneWithEntry = true; CFE_TBL_Info_t TblInfo; + uint8 TblData[6]; + void * TblAddr; memset(&ResultsEntry, 0, sizeof(ResultsEntry)); memset(&TblInfo, 0, sizeof(TblInfo)); - ResultsEntry.TblHandle = 99; - CS_AppData.MaxBytesPerCycle = 5; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_C(CFE_ResourceId_FromInteger(99)); + ResultsEntry.StartAddress = (cpuaddr)TblData; + ResultsEntry.NumBytesToChecksum = sizeof(TblData) - 1; + ResultsEntry.ByteOffset = 1; + CS_AppData.MaxBytesPerCycle = sizeof(TblData) / 2; /* Sets TblInfo.Size = 5 and returns CFE_TBL_INFO_UPDATED */ - TblInfo.Size = 5; + TblInfo.Size = sizeof(TblData); UT_SetDataBuffer(UT_KEY(CFE_TBL_GetInfo), &TblInfo, sizeof(TblInfo), false); @@ -341,6 +509,8 @@ void CS_ComputeTables_Test_TblInfoUpdated(void) /* Set to satisfy subsequent condition "Result == CFE_TBL_INFO_UPDATED" */ UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_TBL_INFO_UPDATED); + TblAddr = TblData; + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); /* Execute the function being tested */ UtAssert_UINT32_EQ(CS_ComputeTables(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CFE_SUCCESS); @@ -348,12 +518,12 @@ void CS_ComputeTables_Test_TblInfoUpdated(void) /* Verify results */ UtAssert_BOOL_FALSE(DoneWithEntry); - UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, 5); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 0); + UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, TblInfo.Size); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), TblAddr); UtAssert_UINT32_EQ(ComputedCSValue, 0); UtAssert_BOOL_FALSE(ResultsEntry.ComputedYet); UtAssert_UINT32_EQ(ResultsEntry.ComparisonValue, 0); - UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 0); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, CS_AppData.MaxBytesPerCycle); UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, 0); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); @@ -365,16 +535,18 @@ void CS_ComputeTables_Test_GetInfoResult(void) uint32 ComputedCSValue = 0; bool DoneWithEntry = true; CFE_TBL_Info_t TblInfo; + uint8 TblData[5]; + void * TblAddr; memset(&ResultsEntry, 0, sizeof(ResultsEntry)); memset(&TblInfo, 0, sizeof(TblInfo)); - ResultsEntry.TblHandle = 99; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_C(CFE_ResourceId_FromInteger(99)); - CS_AppData.MaxBytesPerCycle = 5; + CS_AppData.MaxBytesPerCycle = sizeof(TblData); /* Sets TblInfo.Size = 5 and returns CFE_TBL_INFO_UPDATED */ - TblInfo.Size = 5; + TblInfo.Size = sizeof(TblData); UT_SetDataBuffer(UT_KEY(CFE_TBL_GetInfo), &TblInfo, sizeof(TblInfo), false); @@ -382,22 +554,26 @@ void CS_ComputeTables_Test_GetInfoResult(void) /* Set to satisfy subsequent condition "Result == CFE_TBL_INFO_UPDATED" */ UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_TBL_INFO_UPDATED); + TblAddr = TblData; + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); /* Execute the function being tested */ - UtAssert_UINT32_EQ(CS_ComputeTables(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CFE_SUCCESS); + UtAssert_UINT32_EQ(CS_ComputeTables(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CS_ERR_NOT_FOUND); /* Verify results */ - UtAssert_BOOL_FALSE(DoneWithEntry); + UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, 0); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 0); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), 0); UtAssert_UINT32_EQ(ComputedCSValue, 0); UtAssert_BOOL_FALSE(ResultsEntry.ComputedYet); UtAssert_UINT32_EQ(ResultsEntry.ComparisonValue, 0); UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 0); UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, 0); - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_COMPUTE_TABLES_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); } void CS_ComputeTables_Test_CSError(void) @@ -406,26 +582,30 @@ void CS_ComputeTables_Test_CSError(void) uint32 ComputedCSValue = 0; bool DoneWithEntry = false; CFE_TBL_Info_t TblInfo; + uint8 TblData[5]; + void * TblAddr; memset(&ResultsEntry, 0, sizeof(ResultsEntry)); memset(&TblInfo, 0, sizeof(TblInfo)); - ResultsEntry.TblHandle = 99; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_C(CFE_ResourceId_FromInteger(99)); - CS_AppData.MaxBytesPerCycle = 5; + CS_AppData.MaxBytesPerCycle = sizeof(TblData); ResultsEntry.ComputedYet = true; ResultsEntry.ComparisonValue = 1; /* Sets TblInfo.Size = 5 and returns CFE_SUCCESS */ - TblInfo.Size = 5; + TblInfo.Size = sizeof(TblData); UT_SetDataBuffer(UT_KEY(CFE_TBL_GetInfo), &TblInfo, sizeof(TblInfo), false); /* Set to satisfy condition "Result == CFE_SUCCESS" and to fail other conditions that check for other values of * Result */ UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); + TblAddr = TblData; + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); /* Set to fail condition "NewChecksumValue != ResultsEntry -> ComparisonValue" */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CalculateCRC), 1, 2); @@ -437,10 +617,10 @@ void CS_ComputeTables_Test_CSError(void) UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, 5); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 0); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), TblAddr); UtAssert_UINT32_EQ(ComputedCSValue, 2); - UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 0); - UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, 0); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, TblInfo.Size); + UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, ComputedCSValue); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } @@ -451,13 +631,15 @@ void CS_ComputeTables_Test_NominalBadTableHandle(void) uint32 ComputedCSValue = 0; bool DoneWithEntry = false; CFE_TBL_Info_t TblInfo; + uint8 TblData[5]; + void * TblAddr; memset(&ResultsEntry, 0, sizeof(ResultsEntry)); memset(&TblInfo, 0, sizeof(TblInfo)); - ResultsEntry.TblHandle = CFE_TBL_BAD_TABLE_HANDLE; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_UNDEFINED; - CS_AppData.MaxBytesPerCycle = 5; + CS_AppData.MaxBytesPerCycle = sizeof(TblData); ResultsEntry.ComputedYet = true; @@ -467,13 +649,15 @@ void CS_ComputeTables_Test_NominalBadTableHandle(void) UT_SetHandlerFunction(UT_KEY(CFE_TBL_Share), CS_COMPUTE_TEST_CFE_TBL_ShareHandler, NULL); /* Sets TblInfo.Size = 5 and returns CFE_SUCCESS */ - TblInfo.Size = 5; + TblInfo.Size = sizeof(TblData); UT_SetDataBuffer(UT_KEY(CFE_TBL_GetInfo), &TblInfo, sizeof(TblInfo), false); /* Set to satisfy condition "Result == CFE_SUCCESS" and to fail other conditions that check for other values of * Result */ UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); + TblAddr = TblData; + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); /* Set to fail condition "NewChecksumValue != ResultsEntry -> ComparisonValue" */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CalculateCRC), 1, 2); @@ -484,13 +668,11 @@ void CS_ComputeTables_Test_NominalBadTableHandle(void) /* Verify results */ UtAssert_BOOL_TRUE(DoneWithEntry); - UtAssert_INT32_EQ(ResultsEntry.TblHandle, 99); - UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, 5); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 0); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), TblAddr); UtAssert_UINT32_EQ(ComputedCSValue, 2); - UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 0); - UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, 0); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, TblInfo.Size); + UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, ComputedCSValue); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } @@ -501,13 +683,15 @@ void CS_ComputeTables_Test_FirstTimeThrough(void) uint32 ComputedCSValue = 0; bool DoneWithEntry = false; CFE_TBL_Info_t TblInfo; + uint8 TblData[5]; + void * TblAddr; memset(&ResultsEntry, 0, sizeof(ResultsEntry)); memset(&TblInfo, 0, sizeof(TblInfo)); - ResultsEntry.TblHandle = CFE_TBL_BAD_TABLE_HANDLE; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_UNDEFINED; - CS_AppData.MaxBytesPerCycle = 5; + CS_AppData.MaxBytesPerCycle = sizeof(TblData); ResultsEntry.ComputedYet = false; @@ -517,13 +701,15 @@ void CS_ComputeTables_Test_FirstTimeThrough(void) UT_SetHandlerFunction(UT_KEY(CFE_TBL_Share), CS_COMPUTE_TEST_CFE_TBL_ShareHandler, NULL); /* Sets TblInfo.Size = 5 and returns CFE_SUCCESS */ - TblInfo.Size = 5; + TblInfo.Size = sizeof(TblData); UT_SetDataBuffer(UT_KEY(CFE_TBL_GetInfo), &TblInfo, sizeof(TblInfo), false); /* Set to satisfy condition "Result == CFE_SUCCESS" and to fail other conditions that check for other values of * Result */ UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); + TblAddr = TblData; + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); /* Set to cause ResultsEntry->ComparisonValue to be set to 3 */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CalculateCRC), 1, 3); @@ -534,17 +720,15 @@ void CS_ComputeTables_Test_FirstTimeThrough(void) /* Verify results */ UtAssert_BOOL_TRUE(DoneWithEntry); - UtAssert_INT32_EQ(ResultsEntry.TblHandle, 99); - UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, 5); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 0); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), TblAddr); UtAssert_BOOL_TRUE(ResultsEntry.ComputedYet); UtAssert_UINT32_EQ(ResultsEntry.ComparisonValue, 3); UtAssert_UINT32_EQ(ComputedCSValue, 3); - UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 0); - UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, 0); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, TblInfo.Size); + UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, ComputedCSValue); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } @@ -555,13 +739,15 @@ void CS_ComputeTables_Test_EntryNotFinished(void) uint32 ComputedCSValue = 0; bool DoneWithEntry = true; CFE_TBL_Info_t TblInfo; + uint8 TblData[5]; + void * TblAddr; memset(&ResultsEntry, 0, sizeof(ResultsEntry)); memset(&TblInfo, 0, sizeof(TblInfo)); - ResultsEntry.TblHandle = CFE_TBL_BAD_TABLE_HANDLE; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_UNDEFINED; - CS_AppData.MaxBytesPerCycle = 3; + CS_AppData.MaxBytesPerCycle = sizeof(TblData) - 2; ResultsEntry.ComputedYet = false; @@ -571,13 +757,15 @@ void CS_ComputeTables_Test_EntryNotFinished(void) UT_SetHandlerFunction(UT_KEY(CFE_TBL_Share), CS_COMPUTE_TEST_CFE_TBL_ShareHandler, NULL); /* Sets TblInfo.Size = 5 and returns CFE_SUCCESS */ - TblInfo.Size = 5; + TblInfo.Size = sizeof(TblData); UT_SetDataBuffer(UT_KEY(CFE_TBL_GetInfo), &TblInfo, sizeof(TblInfo), false); /* Set to satisfy condition "Result == CFE_SUCCESS" and to fail other conditions that check for other values of * Result */ UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); + TblAddr = TblData; + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); /* Set to cause ResultsEntry->ComparisonValue to be set to 3 */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CalculateCRC), 1, 3); @@ -588,14 +776,11 @@ void CS_ComputeTables_Test_EntryNotFinished(void) /* Verify results */ UtAssert_BOOL_FALSE(DoneWithEntry); - UtAssert_INT32_EQ(ResultsEntry.TblHandle, 99); - UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, 5); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 0); - + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), TblAddr); UtAssert_UINT32_EQ(ComputedCSValue, 3); - UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 3); - UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, 3); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, CS_AppData.MaxBytesPerCycle); + UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, ComputedCSValue); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } @@ -607,6 +792,8 @@ void CS_ComputeTables_Test_ComputeTablesReleaseError(void) bool DoneWithEntry = true; CFE_TBL_Info_t TblInfo; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + uint8 TblData[5]; + void * TblAddr; memset(&ResultsEntry, 0, sizeof(ResultsEntry)); memset(&TblInfo, 0, sizeof(TblInfo)); @@ -614,9 +801,9 @@ void CS_ComputeTables_Test_ComputeTablesReleaseError(void) snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "CS Tables: Could not release addresss for table %%s, returned: 0x%%08X"); - ResultsEntry.TblHandle = CFE_TBL_BAD_TABLE_HANDLE; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_UNDEFINED; - CS_AppData.MaxBytesPerCycle = 3; + CS_AppData.MaxBytesPerCycle = sizeof(TblData) - 2; ResultsEntry.ComputedYet = false; @@ -628,13 +815,15 @@ void CS_ComputeTables_Test_ComputeTablesReleaseError(void) UT_SetHandlerFunction(UT_KEY(CFE_TBL_Share), CS_COMPUTE_TEST_CFE_TBL_ShareHandler, NULL); /* Sets TblInfo.Size = 5 and returns CFE_SUCCESS */ - TblInfo.Size = 5; + TblInfo.Size = sizeof(TblData); UT_SetDataBuffer(UT_KEY(CFE_TBL_GetInfo), &TblInfo, sizeof(TblInfo), false); /* Set to satisfy condition "Result == CFE_SUCCESS" and to fail other conditions that check for other values of * Result */ UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); + TblAddr = TblData; + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); /* Set to cause ResultsEntry->ComparisonValue to be set to 3 */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CalculateCRC), 1, 3); @@ -648,14 +837,11 @@ void CS_ComputeTables_Test_ComputeTablesReleaseError(void) /* Verify results */ UtAssert_BOOL_FALSE(DoneWithEntry); - UtAssert_INT32_EQ(ResultsEntry.TblHandle, 99); - UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, 5); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 0); - - UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 3); - UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, 3); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), TblAddr); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, CS_AppData.MaxBytesPerCycle); UtAssert_UINT32_EQ(ComputedCSValue, 3); + UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, ComputedCSValue); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_COMPUTE_TABLES_RELEASE_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); @@ -678,9 +864,9 @@ void CS_ComputeTables_Test_ComputeTablesError(void) memset(&TblInfo, 0, sizeof(TblInfo)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables: Problem Getting table %%s info Share: 0x%%08X, GetInfo: 0x%%08X, GetAddress: 0x%%08X"); + "CS Tables: Problem Getting table %%s: Status=0x%%08X"); - ResultsEntry.TblHandle = CFE_TBL_BAD_TABLE_HANDLE; + ResultsEntry.TblHandleID = CFE_TBL_HANDLEID_UNDEFINED; strncpy(ResultsEntry.Name, "name", 10); @@ -699,7 +885,7 @@ void CS_ComputeTables_Test_ComputeTablesError(void) UtAssert_UINT32_EQ(CS_ComputeTables(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CS_ERR_NOT_FOUND); /* Verify results */ - UtAssert_BOOL_FALSE(DoneWithEntry); + UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_COMPUTE_TABLES_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); @@ -710,6 +896,42 @@ void CS_ComputeTables_Test_ComputeTablesError(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } +void CS_ComputeTables_Test_OffsetlargerThanBytesCheck(void) +{ + CS_Res_Tables_Table_Entry_t ResultsEntry; + uint32 ComputedCSValue = 0; + bool DoneWithEntry = false; + CFE_TBL_Info_t TblInfo; + uint8 TblData[5]; + void * TblAddr; + + memset(&TblInfo, 0, sizeof(TblInfo)); + memset(&ResultsEntry, 0, sizeof(ResultsEntry)); + + CS_AppData.MaxBytesPerCycle = sizeof(TblData); + + ResultsEntry.ComputedYet = true; + + /* Sets TblInfo.Size = 5 and returns CFE_SUCCESS */ + TblInfo.Size = sizeof(TblData); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetInfo), &TblInfo, sizeof(TblInfo), false); + + UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); + TblAddr = TblData; + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); + + ResultsEntry.ByteOffset = TblInfo.Size + 1; /* Set Byte offset larger than CodeSize. */ + + /* Execute the function being tested */ + UtAssert_UINT32_EQ(CS_ComputeTables(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CFE_SUCCESS); + + /* Verify results */ + UtAssert_BOOL_TRUE(DoneWithEntry); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), TblAddr); + UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, TblInfo.Size); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, TblInfo.Size); +} + void CS_ComputeApp_Test_NominalApp(void) { CS_Res_App_Table_Entry_t ResultsEntry; @@ -738,11 +960,11 @@ void CS_ComputeApp_Test_NominalApp(void) UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, 5); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 1); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), 1); UtAssert_UINT32_EQ(ComputedCSValue, 2); - UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 0); - UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, 0); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, CS_AppData.MaxBytesPerCycle); + UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, ComputedCSValue); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } @@ -778,11 +1000,11 @@ void CS_ComputeApp_Test_NominalLib(void) UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, 5); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 1); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), 1); UtAssert_UINT32_EQ(ComputedCSValue, 2); - UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 0); - UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, 0); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, CS_AppData.MaxBytesPerCycle); + UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, ComputedCSValue); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } @@ -796,9 +1018,8 @@ void CS_ComputeApp_Test_GetAppAndLibIDByNameError(void) memset(&ResultsEntry, 0, sizeof(ResultsEntry)); - snprintf( - ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps: Problems getting module %%s info, GetResourceID: 0x%%08X, GetModuleInfo: 0x%%08X, AddressValid: %%d"); + snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, + "CS Apps: Problems getting module %%s info, Result: 0x%%08X, AddressValid: %%d"); strncpy(ResultsEntry.Name, "name", 10); @@ -812,7 +1033,7 @@ void CS_ComputeApp_Test_GetAppAndLibIDByNameError(void) UtAssert_UINT32_EQ(CS_ComputeApp(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CS_ERR_NOT_FOUND); /* Verify results */ - UtAssert_BOOL_FALSE(DoneWithEntry); + UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_COMPUTE_APP_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); @@ -832,9 +1053,8 @@ void CS_ComputeApp_Test_GetModuleInfoError(void) memset(&ResultsEntry, 0, sizeof(ResultsEntry)); - snprintf( - ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps: Problems getting module %%s info, GetResourceID: 0x%%08X, GetModuleInfo: 0x%%08X, AddressValid: %%d"); + snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, + "CS Apps: Problems getting module %%s info, Result: 0x%%08X, AddressValid: %%d"); strncpy(ResultsEntry.Name, "name", 10); @@ -845,7 +1065,7 @@ void CS_ComputeApp_Test_GetModuleInfoError(void) UtAssert_UINT32_EQ(CS_ComputeApp(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CS_ERR_NOT_FOUND); /* Verify results */ - UtAssert_BOOL_FALSE(DoneWithEntry); + UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_COMPUTE_APP_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); @@ -868,9 +1088,8 @@ void CS_ComputeApp_Test_ComputeAppPlatformError(void) snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "CS cannot get a valid address for %%s, due to the platform"); - snprintf( - ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps: Problems getting module %%s info, GetResourceID: 0x%%08X, GetModuleInfo: 0x%%08X, AddressValid: %%d"); + snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, + "CS Apps: Problems getting module %%s info, Result: 0x%%08X, AddressValid: %%d"); strncpy(ResultsEntry.Name, "name", 10); @@ -881,7 +1100,7 @@ void CS_ComputeApp_Test_ComputeAppPlatformError(void) UtAssert_UINT32_EQ(CS_ComputeApp(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CS_ERR_NOT_FOUND); /* Verify results */ - UtAssert_BOOL_FALSE(DoneWithEntry); + UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_COMPUTE_APP_PLATFORM_DBG_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_DEBUG); @@ -926,7 +1145,7 @@ void CS_ComputeApp_Test_DifferFromSavedValue(void) UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, 5); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 1); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), 1); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } @@ -959,27 +1178,51 @@ void CS_ComputeApp_Test_FirstTimeThrough(void) UtAssert_BOOL_TRUE(DoneWithEntry); UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, 5); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 1); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), 1); UtAssert_BOOL_TRUE(ResultsEntry.ComputedYet); UtAssert_UINT32_EQ(ResultsEntry.ComparisonValue, 2); UtAssert_UINT32_EQ(ComputedCSValue, 2); - UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 0); - UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, 0); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, CS_AppData.MaxBytesPerCycle); + UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, ComputedCSValue); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } +void CS_ComputeApp_Test_OffsetlargerThanBytesCheck(void) +{ + CS_Res_App_Table_Entry_t ResultsEntry; + uint32 ComputedCSValue = 0; + bool DoneWithEntry = false; + + memset(&ResultsEntry, 0, sizeof(ResultsEntry)); + + CS_AppData.MaxBytesPerCycle = 5; + + ResultsEntry.ComputedYet = false; + + /* Sets AppInfo.CodeSize = 5, sets AppInfo.CodeAddress = 1, AppInfo.AddressesAreValid = true, and returns + * CFE_SUCCESS */ + UT_SetHandlerFunction(UT_KEY(CFE_ES_GetModuleInfo), CS_COMPUTE_TEST_CFE_ES_GetModuleInfoHandler1, NULL); + ResultsEntry.ByteOffset = 6; /* offset larger than codesize */ + + /* Execute the function being tested */ + UtAssert_UINT32_EQ(CS_ComputeApp(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CFE_SUCCESS); + + /* Verify results */ + UtAssert_BOOL_TRUE(DoneWithEntry); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, CS_AppData.MaxBytesPerCycle); + UtAssert_UINT32_EQ(ResultsEntry.NumBytesToChecksum, CS_AppData.MaxBytesPerCycle); +} + void CS_ComputeApp_Test_EntryNotFinished(void) { CS_Res_App_Table_Entry_t ResultsEntry; uint32 ComputedCSValue = 0; bool DoneWithEntry = true; - CFE_TBL_Info_t TblInfo; memset(&ResultsEntry, 0, sizeof(ResultsEntry)); - memset(&TblInfo, 0, sizeof(TblInfo)); CS_AppData.MaxBytesPerCycle = 3; @@ -991,12 +1234,6 @@ void CS_ComputeApp_Test_EntryNotFinished(void) * CFE_SUCCESS */ UT_SetHandlerFunction(UT_KEY(CFE_ES_GetModuleInfo), CS_COMPUTE_TEST_CFE_ES_GetModuleInfoHandler1, NULL); - TblInfo.Size = 5; - - UT_SetDataBuffer(UT_KEY(CFE_TBL_GetInfo), &TblInfo, sizeof(TblInfo), false); - - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetInfo), CFE_TBL_INFO_UPDATED); - /* Set to fail condition "NewChecksumValue != ResultsEntry -> ComparisonValue" */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CalculateCRC), 1, 2); @@ -1006,7 +1243,7 @@ void CS_ComputeApp_Test_EntryNotFinished(void) /* Verify results */ UtAssert_BOOL_FALSE(DoneWithEntry); - UtAssert_UINT32_EQ(ResultsEntry.StartAddress, 1); + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), 1); UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, 3); UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, 2); @@ -1015,6 +1252,41 @@ void CS_ComputeApp_Test_EntryNotFinished(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } +void CS_ComputeApp_Test_EntryFinished(void) +{ + CS_Res_App_Table_Entry_t ResultsEntry; + uint32 ComputedCSValue = 0; + bool DoneWithEntry = true; + + memset(&ResultsEntry, 0, sizeof(ResultsEntry)); + + CS_AppData.MaxBytesPerCycle = 3; + + ResultsEntry.ComputedYet = true; + + ResultsEntry.ComparisonValue = 3; + ResultsEntry.StartAddress = 2; + ResultsEntry.NumBytesToChecksum = 2; + ResultsEntry.ByteOffset = 2; + + /* Sets AppInfo.CodeSize = 5, sets AppInfo.CodeAddress = 1, AppInfo.AddressesAreValid = true, and returns + * CFE_SUCCESS */ + UT_SetHandlerFunction(UT_KEY(CFE_ES_GetModuleInfo), CS_COMPUTE_TEST_CFE_ES_GetModuleInfoHandler1, NULL); + UT_SetDeferredRetcode(UT_KEY(CFE_ES_CalculateCRC), 1, 3); + + /* Execute the function being tested */ + UtAssert_UINT32_EQ(CS_ComputeApp(&ResultsEntry, &ComputedCSValue, &DoneWithEntry), CFE_SUCCESS); + + /* Verify results */ + UtAssert_BOOL_FALSE(DoneWithEntry); + + UtAssert_ADDRESS_EQ(CFE_ES_MEMADDRESS_TO_PTR(ResultsEntry.StartAddress), 1); + UtAssert_UINT32_EQ(ResultsEntry.ByteOffset, CS_AppData.MaxBytesPerCycle); + UtAssert_UINT32_EQ(ComputedCSValue, 3); + UtAssert_UINT32_EQ(ResultsEntry.TempChecksumValue, ComputedCSValue); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); +} + void CS_RecomputeEepromMemoryChildTask_Test_EEPROMTable(void) { CS_Res_EepromMemory_Table_Entry_t RecomputeEepromMemoryEntry; @@ -1027,16 +1299,16 @@ void CS_RecomputeEepromMemoryChildTask_Test_EEPROMTable(void) snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "%%s entry %%d recompute finished. New baseline is 0X%%08X"); - CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; - CS_AppData.DefEepromTblPtr = DefEepromTbl; + CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; + CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].DefAddr = DefEepromTbl; - CS_AppData.ChildTaskTable = CS_EEPROM_TABLE; + CS_AppData.ChildTaskTable = CS_ChecksumType_EEPROM_TABLE; CS_AppData.ChildTaskEntryID = 1; - CS_AppData.DefEepromTblPtr[1].StartAddress = 1; + DefEepromTbl[1].StartAddress = 1; - RecomputeEepromMemoryEntry.StartAddress = CS_AppData.DefEepromTblPtr[1].StartAddress; + RecomputeEepromMemoryEntry.StartAddress = DefEepromTbl[1].StartAddress; DefEepromTbl[1].State = 1; @@ -1054,11 +1326,11 @@ void CS_RecomputeEepromMemoryChildTask_Test_EEPROMTable(void) /* Verify results */ UtAssert_BOOL_FALSE(CS_AppData.HkPacket.Payload.RecomputeInProgress); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 0); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 0); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 1); UtAssert_BOOL_TRUE(CS_AppData.RecomputeEepromMemoryEntryPtr->ComputedYet); UtAssert_UINT16_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->State, 99); - UtAssert_UINT16_EQ(CS_AppData.DefEepromTblPtr[CS_AppData.ChildTaskEntryID].State, 1); + UtAssert_UINT16_EQ(DefEepromTbl[CS_AppData.ChildTaskEntryID].State, 1); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_FINISH_EEPROM_MEMORY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -1081,16 +1353,16 @@ void CS_RecomputeEepromMemoryChildTask_Test_MemoryTable(void) snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "%%s entry %%d recompute finished. New baseline is 0X%%08X"); - CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; - CS_AppData.DefMemoryTblPtr = DefMemoryTbl; + CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; + CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].DefAddr = DefMemoryTbl; - CS_AppData.ChildTaskTable = CS_MEMORY_TABLE; + CS_AppData.ChildTaskTable = CS_ChecksumType_MEMORY_TABLE; CS_AppData.ChildTaskEntryID = 1; - CS_AppData.DefMemoryTblPtr[1].StartAddress = 1; + DefMemoryTbl[1].StartAddress = 1; - RecomputeEepromMemoryEntry.StartAddress = CS_AppData.DefMemoryTblPtr[1].StartAddress; + RecomputeEepromMemoryEntry.StartAddress = DefMemoryTbl[1].StartAddress; DefMemoryTbl[1].State = 1; @@ -1108,11 +1380,11 @@ void CS_RecomputeEepromMemoryChildTask_Test_MemoryTable(void) /* Verify results */ UtAssert_BOOL_FALSE(CS_AppData.HkPacket.Payload.RecomputeInProgress); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 0); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 0); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 1); UtAssert_BOOL_TRUE(CS_AppData.RecomputeEepromMemoryEntryPtr->ComputedYet); UtAssert_UINT16_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->State, 99); - UtAssert_UINT16_EQ(CS_AppData.DefMemoryTblPtr[CS_AppData.ChildTaskEntryID].State, 1); + UtAssert_UINT16_EQ(DefMemoryTbl[CS_AppData.ChildTaskEntryID].State, 1); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_FINISH_EEPROM_MEMORY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -1135,16 +1407,16 @@ void CS_RecomputeEepromMemoryChildTask_Test_CFECore(void) snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "%%s entry %%d recompute finished. New baseline is 0X%%08X"); - CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; - CS_AppData.DefMemoryTblPtr = DefMemoryTbl; + CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; + CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].DefAddr = DefMemoryTbl; - CS_AppData.ChildTaskTable = CS_CFECORE; + CS_AppData.ChildTaskTable = CS_ChecksumType_CFECORE; CS_AppData.ChildTaskEntryID = 1; - CS_AppData.DefMemoryTblPtr[1].StartAddress = 1; + DefMemoryTbl[1].StartAddress = 1; - RecomputeEepromMemoryEntry.StartAddress = CS_AppData.DefMemoryTblPtr[1].StartAddress; + RecomputeEepromMemoryEntry.StartAddress = DefMemoryTbl[1].StartAddress; DefMemoryTbl[1].State = 1; @@ -1162,11 +1434,11 @@ void CS_RecomputeEepromMemoryChildTask_Test_CFECore(void) /* Verify results */ UtAssert_BOOL_FALSE(CS_AppData.HkPacket.Payload.RecomputeInProgress); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 0); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 0); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 1); UtAssert_BOOL_TRUE(CS_AppData.RecomputeEepromMemoryEntryPtr->ComputedYet); UtAssert_UINT16_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->State, 99); - UtAssert_UINT16_EQ(CS_AppData.DefMemoryTblPtr[CS_AppData.ChildTaskEntryID].State, 1); + UtAssert_UINT16_EQ(DefMemoryTbl[CS_AppData.ChildTaskEntryID].State, 1); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_FINISH_EEPROM_MEMORY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -1191,16 +1463,16 @@ void CS_RecomputeEepromMemoryChildTask_Test_OSCore(void) snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "%%s entry %%d recompute finished. New baseline is 0X%%08X"); - CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; - CS_AppData.DefMemoryTblPtr = DefMemoryTbl; + CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; + CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].DefAddr = DefMemoryTbl; - CS_AppData.ChildTaskTable = CS_OSCORE; + CS_AppData.ChildTaskTable = CS_ChecksumType_OSCORE; CS_AppData.ChildTaskEntryID = 1; - CS_AppData.DefMemoryTblPtr[1].StartAddress = 1; + DefMemoryTbl[1].StartAddress = 1; - RecomputeEepromMemoryEntry.StartAddress = CS_AppData.DefMemoryTblPtr[1].StartAddress; + RecomputeEepromMemoryEntry.StartAddress = DefMemoryTbl[1].StartAddress; DefMemoryTbl[1].State = 1; @@ -1218,11 +1490,11 @@ void CS_RecomputeEepromMemoryChildTask_Test_OSCore(void) /* Verify results */ UtAssert_BOOL_FALSE(CS_AppData.HkPacket.Payload.RecomputeInProgress); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 0); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 0); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 1); UtAssert_BOOL_TRUE(CS_AppData.RecomputeEepromMemoryEntryPtr->ComputedYet); UtAssert_UINT16_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->State, 99); - UtAssert_UINT16_EQ(CS_AppData.DefMemoryTblPtr[CS_AppData.ChildTaskEntryID].State, 1); + UtAssert_UINT16_EQ(DefMemoryTbl[CS_AppData.ChildTaskEntryID].State, 1); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_FINISH_EEPROM_MEMORY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -1235,7 +1507,7 @@ void CS_RecomputeEepromMemoryChildTask_Test_OSCore(void) UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); } -void CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableEntryId(void) +void CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableEntryID(void) { CS_Res_EepromMemory_Table_Entry_t RecomputeEepromMemoryEntry; CS_Def_EepromMemory_Table_Entry_t DefEepromTbl[10]; @@ -1247,16 +1519,16 @@ void CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableEntryId(void) snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "%%s entry %%d recompute finished. New baseline is 0X%%08X"); - CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; - CS_AppData.DefEepromTblPtr = DefEepromTbl; + CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; + CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].DefAddr = DefEepromTbl; - CS_AppData.ChildTaskTable = CS_EEPROM_TABLE; + CS_AppData.ChildTaskTable = CS_ChecksumType_EEPROM_TABLE; CS_AppData.ChildTaskEntryID = CS_MAX_NUM_EEPROM_TABLE_ENTRIES; - CS_AppData.DefEepromTblPtr[1].StartAddress = 1; + DefEepromTbl[1].StartAddress = 1; - RecomputeEepromMemoryEntry.StartAddress = CS_AppData.DefEepromTblPtr[1].StartAddress; + RecomputeEepromMemoryEntry.StartAddress = DefEepromTbl[1].StartAddress; DefEepromTbl[1].State = 1; @@ -1274,8 +1546,8 @@ void CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableEntryId(void) /* Verify results */ UtAssert_BOOL_FALSE(CS_AppData.HkPacket.Payload.RecomputeInProgress); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 0); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 0); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 1); UtAssert_BOOL_TRUE(CS_AppData.RecomputeEepromMemoryEntryPtr->ComputedYet); UtAssert_UINT16_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->State, 99); @@ -1300,14 +1572,14 @@ void CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableStartAddress(void) snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "%%s entry %%d recompute finished. New baseline is 0X%%08X"); - CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; - CS_AppData.DefEepromTblPtr = DefEepromTbl; + CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; + CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].DefAddr = DefEepromTbl; - CS_AppData.ChildTaskTable = CS_EEPROM_TABLE; + CS_AppData.ChildTaskTable = CS_ChecksumType_EEPROM_TABLE; CS_AppData.ChildTaskEntryID = 1; - CS_AppData.DefEepromTblPtr[1].StartAddress = 1; + DefEepromTbl[1].StartAddress = 1; RecomputeEepromMemoryEntry.StartAddress = 0; @@ -1327,11 +1599,11 @@ void CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableStartAddress(void) /* Verify results */ UtAssert_BOOL_FALSE(CS_AppData.HkPacket.Payload.RecomputeInProgress); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 0); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 0); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 1); UtAssert_BOOL_TRUE(CS_AppData.RecomputeEepromMemoryEntryPtr->ComputedYet); UtAssert_UINT16_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->State, 99); - UtAssert_UINT16_EQ(CS_AppData.DefEepromTblPtr[CS_AppData.ChildTaskEntryID].State, 1); + UtAssert_UINT16_EQ(DefEepromTbl[CS_AppData.ChildTaskEntryID].State, 1); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_FINISH_EEPROM_MEMORY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -1354,18 +1626,18 @@ void CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableState(void) snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "%%s entry %%d recompute finished. New baseline is 0X%%08X"); - CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; - CS_AppData.DefEepromTblPtr = DefEepromTbl; + CS_AppData.RecomputeEepromMemoryEntryPtr = &RecomputeEepromMemoryEntry; + CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].DefAddr = DefEepromTbl; - CS_AppData.ChildTaskTable = CS_EEPROM_TABLE; + CS_AppData.ChildTaskTable = CS_ChecksumType_EEPROM_TABLE; CS_AppData.ChildTaskEntryID = 1; - CS_AppData.DefEepromTblPtr[1].StartAddress = 1; + DefEepromTbl[1].StartAddress = 1; RecomputeEepromMemoryEntry.StartAddress = 1; - DefEepromTbl[1].State = CS_STATE_EMPTY; + DefEepromTbl[1].State = CS_ChecksumState_EMPTY; CS_AppData.RecomputeEepromMemoryEntryPtr->NumBytesToChecksum = 1; CS_AppData.MaxBytesPerCycle = 2; @@ -1381,11 +1653,11 @@ void CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableState(void) /* Verify results */ UtAssert_BOOL_FALSE(CS_AppData.HkPacket.Payload.RecomputeInProgress); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 0); - UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 0); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->TempChecksumValue, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->ByteOffset, 1); UtAssert_BOOL_TRUE(CS_AppData.RecomputeEepromMemoryEntryPtr->ComputedYet); UtAssert_UINT16_EQ(CS_AppData.RecomputeEepromMemoryEntryPtr->State, 99); - UtAssert_UINT16_EQ(CS_AppData.DefEepromTblPtr[CS_AppData.ChildTaskEntryID].State, CS_STATE_EMPTY); + UtAssert_UINT16_EQ(DefEepromTbl[CS_AppData.ChildTaskEntryID].State, CS_ChecksumState_EMPTY); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_FINISH_EEPROM_MEMORY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -1408,10 +1680,10 @@ void CS_RecomputeAppChildTask_Test_Nominal(void) snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "App %%s recompute finished. New baseline is 0x%%08X"); - CS_AppData.RecomputeAppEntryPtr = &RecomputeAppEntry; - CS_AppData.DefAppTblPtr = DefAppTbl; + CS_AppData.RecomputeAppEntryPtr = &RecomputeAppEntry; + CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].DefAddr = DefAppTbl; - CS_AppData.ChildTaskTable = CS_OSCORE; + CS_AppData.ChildTaskTable = CS_ChecksumType_OSCORE; CS_AppData.ChildTaskEntryID = 1; @@ -1425,21 +1697,19 @@ void CS_RecomputeAppChildTask_Test_Nominal(void) CS_AppData.RecomputeAppEntryPtr->State = 99; - strncpy(CS_AppData.RecomputeAppEntryPtr->Name, "name", 10); - strncpy(DefAppTbl[1].Name, "name", 10); - /* Sets AppInfo.CodeSize = 5, sets AppInfo.CodeAddress = 1, AppInfo.AddressesAreValid = true, and returns * CFE_SUCCESS */ UT_SetHandlerFunction(UT_KEY(CFE_ES_GetModuleInfo), CS_COMPUTE_TEST_CFE_ES_GetModuleInfoHandler1, NULL); + UT_SetHandlerFunction(UT_KEY(CS_GetAppDefTblEntryByName), CS_COMPUTE_TEST_CS_GetDefTblEntryByName, &DefAppTbl[1]); /* Execute the function being tested */ CS_RecomputeAppChildTask(); /* Verify results */ UtAssert_UINT16_EQ(CS_AppData.RecomputeAppEntryPtr->State, 99); - UtAssert_UINT16_EQ(CS_AppData.DefAppTblPtr[CS_AppData.ChildTaskEntryID].State, 1); - UtAssert_UINT32_EQ(CS_AppData.RecomputeAppEntryPtr->TempChecksumValue, 0); - UtAssert_UINT32_EQ(CS_AppData.RecomputeAppEntryPtr->ByteOffset, 0); + UtAssert_UINT16_EQ(DefAppTbl[CS_AppData.ChildTaskEntryID].State, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeAppEntryPtr->TempChecksumValue, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeAppEntryPtr->ByteOffset, 5); UtAssert_BOOL_TRUE(CS_AppData.RecomputeAppEntryPtr->ComputedYet); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_FINISH_APP_INF_EID); @@ -1451,6 +1721,7 @@ void CS_RecomputeAppChildTask_Test_Nominal(void) UtAssert_BOOL_FALSE(CS_AppData.HkPacket.Payload.RecomputeInProgress); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_STUB_COUNT(CS_SetDefEntryState, 2); } void CS_RecomputeAppChildTask_Test_CouldNotGetAddress(void) @@ -1461,15 +1732,15 @@ void CS_RecomputeAppChildTask_Test_CouldNotGetAddress(void) memset(&RecomputeAppEntry, 0, sizeof(RecomputeAppEntry)); memset(&DefAppTbl, 0, sizeof(DefAppTbl)); - CS_AppData.RecomputeAppEntryPtr = &RecomputeAppEntry; - CS_AppData.DefAppTblPtr = DefAppTbl; + CS_AppData.RecomputeAppEntryPtr = &RecomputeAppEntry; + CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].DefAddr = DefAppTbl; - CS_AppData.ChildTaskTable = CS_OSCORE; + CS_AppData.ChildTaskTable = CS_ChecksumType_OSCORE; CS_AppData.ChildTaskEntryID = 1; /* No matching non-empty state entry */ - DefAppTbl[1].State = CS_STATE_EMPTY; + DefAppTbl[1].State = CS_ChecksumState_EMPTY; CS_AppData.RecomputeAppEntryPtr->State = 99; @@ -1489,7 +1760,7 @@ void CS_RecomputeAppChildTask_Test_CouldNotGetAddress(void) /* Verify results */ UtAssert_UINT32_EQ(CS_AppData.RecomputeAppEntryPtr->State, 99); - UtAssert_UINT32_EQ(CS_AppData.DefAppTblPtr[CS_AppData.ChildTaskEntryID].State, CS_STATE_EMPTY); + UtAssert_UINT32_EQ(DefAppTbl[CS_AppData.ChildTaskEntryID].State, CS_ChecksumState_EMPTY); UtAssert_UINT32_EQ(CS_AppData.RecomputeAppEntryPtr->TempChecksumValue, 0); UtAssert_UINT32_EQ(CS_AppData.RecomputeAppEntryPtr->ByteOffset, 0); @@ -1515,10 +1786,10 @@ void CS_RecomputeAppChildTask_Test_DefEntryId(void) snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "App %%s recompute finished. New baseline is 0x%%08X"); - CS_AppData.RecomputeAppEntryPtr = &RecomputeAppEntry; - CS_AppData.DefAppTblPtr = DefAppTbl; + CS_AppData.RecomputeAppEntryPtr = &RecomputeAppEntry; + CS_AppData.Tbl[CS_ChecksumType_APP_TABLE].DefAddr = DefAppTbl; - CS_AppData.ChildTaskTable = CS_OSCORE; + CS_AppData.ChildTaskTable = CS_ChecksumType_OSCORE; CS_AppData.ChildTaskEntryID = 1; @@ -1532,7 +1803,7 @@ void CS_RecomputeAppChildTask_Test_DefEntryId(void) strncpy(CS_AppData.RecomputeAppEntryPtr->Name, "name", 10); strncpy(DefAppTbl[1].Name, "name", 10); - DefAppTbl[1].State = CS_STATE_ENABLED; + DefAppTbl[1].State = CS_ChecksumState_ENABLED; /* Sets AppInfo.CodeSize = 5, sets AppInfo.CodeAddress = 1, AppInfo.AddressesAreValid = true, and returns * CFE_SUCCESS */ @@ -1543,9 +1814,9 @@ void CS_RecomputeAppChildTask_Test_DefEntryId(void) /* Verify results */ UtAssert_UINT32_EQ(CS_AppData.RecomputeAppEntryPtr->State, 99); - UtAssert_UINT32_EQ(CS_AppData.DefAppTblPtr[CS_AppData.ChildTaskEntryID].State, CS_STATE_ENABLED); - UtAssert_UINT32_EQ(CS_AppData.RecomputeAppEntryPtr->TempChecksumValue, 0); - UtAssert_UINT32_EQ(CS_AppData.RecomputeAppEntryPtr->ByteOffset, 0); + UtAssert_UINT32_EQ(DefAppTbl[CS_AppData.ChildTaskEntryID].State, CS_ChecksumState_ENABLED); + UtAssert_UINT32_EQ(CS_AppData.RecomputeAppEntryPtr->TempChecksumValue, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeAppEntryPtr->ByteOffset, 5); UtAssert_BOOL_TRUE(CS_AppData.RecomputeAppEntryPtr->ComputedYet); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_FINISH_APP_INF_EID); @@ -1565,6 +1836,8 @@ void CS_RecomputeTablesChildTask_Test_Nominal(void) CS_Def_Tables_Table_Entry_t DefTablesTbl[10]; CFE_TBL_Info_t TblInfo; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + uint8 TblData[5]; + void * TblAddr; memset(&RecomputeTablesEntry, 0, sizeof(RecomputeTablesEntry)); memset(&DefTablesTbl, 0, sizeof(DefTablesTbl)); @@ -1572,10 +1845,10 @@ void CS_RecomputeTablesChildTask_Test_Nominal(void) snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Table %%s recompute finished. New baseline is 0x%%08X"); - CS_AppData.RecomputeTablesEntryPtr = &RecomputeTablesEntry; - CS_AppData.DefTablesTblPtr = DefTablesTbl; + CS_AppData.RecomputeTablesEntryPtr = &RecomputeTablesEntry; + CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].DefAddr = DefTablesTbl; - CS_AppData.ChildTaskTable = CS_OSCORE; + CS_AppData.ChildTaskTable = CS_ChecksumType_OSCORE; CS_AppData.ChildTaskEntryID = 1; @@ -1592,10 +1865,10 @@ void CS_RecomputeTablesChildTask_Test_Nominal(void) strncpy(CS_AppData.RecomputeTablesEntryPtr->Name, "name", 10); strncpy(DefTablesTbl[1].Name, "name", 10); - RecomputeTablesEntry.TblHandle = CFE_TBL_BAD_TABLE_HANDLE; + RecomputeTablesEntry.TblHandleID = CFE_TBL_HANDLEID_UNDEFINED; RecomputeTablesEntry.ByteOffset = 0; - CS_AppData.MaxBytesPerCycle = 5; + CS_AppData.MaxBytesPerCycle = sizeof(TblData); RecomputeTablesEntry.ComputedYet = true; @@ -1603,24 +1876,28 @@ void CS_RecomputeTablesChildTask_Test_Nominal(void) /* Sets ResultsEntry->TblHandle to 99 and returns CFE_SUCCESS */ UT_SetHandlerFunction(UT_KEY(CFE_TBL_Share), CS_COMPUTE_TEST_CFE_TBL_ShareHandler, NULL); + UT_SetHandlerFunction(UT_KEY(CS_GetTableDefTblEntryByName), CS_COMPUTE_TEST_CS_GetDefTblEntryByName, + &DefTablesTbl[1]); /* Sets TblInfo.Size = 5 and returns CFE_SUCCESS */ - TblInfo.Size = 5; + TblInfo.Size = sizeof(TblData); UT_SetDataBuffer(UT_KEY(CFE_TBL_GetInfo), &TblInfo, sizeof(TblInfo), false); /* Set to satisfy condition "Result == CFE_SUCCESS" and to fail other conditions that check for other values of * Result */ UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); + TblAddr = TblData; + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); /* Execute the function being tested */ CS_RecomputeTablesChildTask(); /* Verify results */ UtAssert_UINT16_EQ(CS_AppData.RecomputeTablesEntryPtr->State, 99); - UtAssert_UINT16_EQ(CS_AppData.DefTablesTblPtr[CS_AppData.ChildTaskEntryID].State, 1); - UtAssert_UINT32_EQ(CS_AppData.RecomputeTablesEntryPtr->TempChecksumValue, 0); - UtAssert_UINT32_EQ(CS_AppData.RecomputeTablesEntryPtr->ByteOffset, 0); + UtAssert_UINT16_EQ(DefTablesTbl[CS_AppData.ChildTaskEntryID].State, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeTablesEntryPtr->TempChecksumValue, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeTablesEntryPtr->ByteOffset, 1); UtAssert_BOOL_TRUE(CS_AppData.RecomputeTablesEntryPtr->ComputedYet); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_FINISH_TABLES_INF_EID); @@ -1632,6 +1909,7 @@ void CS_RecomputeTablesChildTask_Test_Nominal(void) UtAssert_BOOL_FALSE(CS_AppData.HkPacket.Payload.RecomputeInProgress); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_STUB_COUNT(CS_SetDefEntryState, 2); } void CS_RecomputeTablesChildTask_Test_CouldNotGetAddress(void) @@ -1642,15 +1920,15 @@ void CS_RecomputeTablesChildTask_Test_CouldNotGetAddress(void) memset(&RecomputeTablesEntry, 0, sizeof(RecomputeTablesEntry)); memset(&DefTablesTbl, 0, sizeof(DefTablesTbl)); - CS_AppData.RecomputeTablesEntryPtr = &RecomputeTablesEntry; - CS_AppData.DefTablesTblPtr = DefTablesTbl; + CS_AppData.RecomputeTablesEntryPtr = &RecomputeTablesEntry; + CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].DefAddr = DefTablesTbl; - CS_AppData.ChildTaskTable = CS_OSCORE; + CS_AppData.ChildTaskTable = CS_ChecksumType_OSCORE; CS_AppData.ChildTaskEntryID = 1; /* No matching non-empty state entry */ - DefTablesTbl[1].State = CS_STATE_EMPTY; + DefTablesTbl[1].State = CS_ChecksumState_EMPTY; CS_AppData.RecomputeTablesEntryPtr->State = 99; @@ -1659,7 +1937,6 @@ void CS_RecomputeTablesChildTask_Test_CouldNotGetAddress(void) /* Set to make CS_ComputeTables return CS_ERR_NOT_FOUND */ UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Share), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_AttemptTableReshare), 1, -1); UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 1, -1); /* Execute the function being tested */ @@ -1667,7 +1944,7 @@ void CS_RecomputeTablesChildTask_Test_CouldNotGetAddress(void) /* Verify results */ UtAssert_UINT32_EQ(CS_AppData.RecomputeTablesEntryPtr->State, 99); - UtAssert_UINT32_EQ(CS_AppData.DefTablesTblPtr[CS_AppData.ChildTaskEntryID].State, CS_STATE_EMPTY); + UtAssert_UINT32_EQ(DefTablesTbl[CS_AppData.ChildTaskEntryID].State, CS_ChecksumState_EMPTY); UtAssert_UINT32_EQ(CS_AppData.RecomputeTablesEntryPtr->TempChecksumValue, 0); UtAssert_UINT32_EQ(CS_AppData.RecomputeTablesEntryPtr->ByteOffset, 0); @@ -1687,6 +1964,8 @@ void CS_RecomputeTablesChildTask_Test_DefEntryId(void) CS_Def_Tables_Table_Entry_t DefTablesTbl[10]; CFE_TBL_Info_t TblInfo; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + uint8 TblData[5]; + void * TblAddr; memset(&RecomputeTablesEntry, 0, sizeof(RecomputeTablesEntry)); memset(&DefTablesTbl, 0, sizeof(DefTablesTbl)); @@ -1694,10 +1973,10 @@ void CS_RecomputeTablesChildTask_Test_DefEntryId(void) snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Table %%s recompute finished. New baseline is 0x%%08X"); - CS_AppData.RecomputeTablesEntryPtr = &RecomputeTablesEntry; - CS_AppData.DefTablesTblPtr = DefTablesTbl; + CS_AppData.RecomputeTablesEntryPtr = &RecomputeTablesEntry; + CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].DefAddr = DefTablesTbl; - CS_AppData.ChildTaskTable = CS_OSCORE; + CS_AppData.ChildTaskTable = CS_ChecksumType_OSCORE; CS_AppData.ChildTaskEntryID = 1; @@ -1711,12 +1990,12 @@ void CS_RecomputeTablesChildTask_Test_DefEntryId(void) strncpy(CS_AppData.RecomputeTablesEntryPtr->Name, "name", 10); strncpy(DefTablesTbl[1].Name, "name", 10); - DefTablesTbl[1].State = CS_STATE_ENABLED; + DefTablesTbl[1].State = CS_ChecksumState_ENABLED; - RecomputeTablesEntry.TblHandle = CFE_TBL_BAD_TABLE_HANDLE; + RecomputeTablesEntry.TblHandleID = CFE_TBL_HANDLEID_UNDEFINED; RecomputeTablesEntry.ByteOffset = 0; - CS_AppData.MaxBytesPerCycle = 5; + CS_AppData.MaxBytesPerCycle = sizeof(TblData); RecomputeTablesEntry.ComputedYet = true; @@ -1726,22 +2005,24 @@ void CS_RecomputeTablesChildTask_Test_DefEntryId(void) UT_SetHandlerFunction(UT_KEY(CFE_TBL_Share), CS_COMPUTE_TEST_CFE_TBL_ShareHandler, NULL); /* Sets TblInfo.Size = 5 and returns CFE_SUCCESS */ - TblInfo.Size = 5; + TblInfo.Size = sizeof(TblData); UT_SetDataBuffer(UT_KEY(CFE_TBL_GetInfo), &TblInfo, sizeof(TblInfo), false); /* Set to satisfy condition "Result == CFE_SUCCESS" and to fail other conditions that check for other values of * Result */ UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); + TblAddr = TblData; + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &TblAddr, sizeof(TblAddr), false); /* Execute the function being tested */ CS_RecomputeTablesChildTask(); /* Verify results */ UtAssert_UINT32_EQ(CS_AppData.RecomputeTablesEntryPtr->State, 99); - UtAssert_UINT32_EQ(CS_AppData.DefTablesTblPtr[CS_AppData.ChildTaskEntryID].State, CS_STATE_ENABLED); - UtAssert_UINT32_EQ(CS_AppData.RecomputeTablesEntryPtr->TempChecksumValue, 0); - UtAssert_UINT32_EQ(CS_AppData.RecomputeTablesEntryPtr->ByteOffset, 0); + UtAssert_UINT32_EQ(DefTablesTbl[CS_AppData.ChildTaskEntryID].State, CS_ChecksumState_ENABLED); + UtAssert_UINT32_EQ(CS_AppData.RecomputeTablesEntryPtr->TempChecksumValue, 1); + UtAssert_UINT32_EQ(CS_AppData.RecomputeTablesEntryPtr->ByteOffset, 1); UtAssert_BOOL_TRUE(CS_AppData.RecomputeTablesEntryPtr->ComputedYet); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_FINISH_TABLES_INF_EID); @@ -1798,9 +2079,16 @@ void UtTest_Setup(void) "CS_ComputeEepromMemory_Test_FirstTimeThrough"); UtTest_Add(CS_ComputeEepromMemory_Test_NotFinished, CS_Test_Setup, CS_Test_TearDown, "CS_ComputeEepromMemory_Test_NotFinished"); + UtTest_Add(CS_ComputeEepromMemory_Test_OffsetlargerThanBytesCheck, CS_Test_Setup, CS_Test_TearDown, + "CS_ComputeEepromMemory_Test_OffsetlargerThanBytesCheck"); UtTest_Add(CS_ComputeTables_Test_TableNeverLoaded, CS_Test_Setup, CS_Test_TearDown, "CS_ComputeTables_Test_TableNeverLoaded"); + UtTest_Add(CS_ComputeTables_Test_TableAddressChange, CS_Test_Setup, CS_Test_TearDown, + "CS_ComputeTables_Test_TableAddressChange"); + UtTest_Add(CS_ComputeTables_Test_TableResume, CS_Test_Setup, CS_Test_TearDown, "CS_ComputeTables_Test_TableResume"); + UtTest_Add(CS_ComputeTables_Test_TableAddressNULL, CS_Test_Setup, CS_Test_TearDown, + "CS_ComputeTables_Test_TableAddressNULL"); UtTest_Add(CS_ComputeTables_Test_TableUnregisteredAndNeverLoaded, CS_Test_Setup, CS_Test_TearDown, "CS_ComputeTables_Test_TableUnregisteredAndNeverLoaded"); UtTest_Add(CS_ComputeTables_Test_ResultShareNotSuccess, CS_Test_Setup, CS_Test_TearDown, @@ -1820,6 +2108,8 @@ void UtTest_Setup(void) "CS_ComputeTables_Test_ComputeTablesReleaseError"); UtTest_Add(CS_ComputeTables_Test_ComputeTablesError, CS_Test_Setup, CS_Test_TearDown, "CS_ComputeTables_Test_ComputeTablesError"); + UtTest_Add(CS_ComputeTables_Test_OffsetlargerThanBytesCheck, CS_Test_Setup, CS_Test_TearDown, + "CS_ComputeTables_Test_OffsetlargerThanBytesCheck"); UtTest_Add(CS_ComputeApp_Test_NominalApp, CS_Test_Setup, CS_Test_TearDown, "CS_ComputeApp_Test_NominalApp"); UtTest_Add(CS_ComputeApp_Test_NominalLib, CS_Test_Setup, CS_Test_TearDown, "CS_ComputeApp_Test_NominalLib"); @@ -1835,6 +2125,9 @@ void UtTest_Setup(void) "CS_ComputeApp_Test_FirstTimeThrough"); UtTest_Add(CS_ComputeApp_Test_EntryNotFinished, CS_Test_Setup, CS_Test_TearDown, "CS_ComputeApp_Test_EntryNotFinished"); + UtTest_Add(CS_ComputeApp_Test_EntryFinished, CS_Test_Setup, CS_Test_TearDown, "CS_ComputeApp_Test_EntryFinished"); + UtTest_Add(CS_ComputeApp_Test_OffsetlargerThanBytesCheck, CS_Test_Setup, CS_Test_TearDown, + "CS_ComputeApp_Test_OffsetlargerThanBytesCheck"); UtTest_Add(CS_RecomputeEepromMemoryChildTask_Test_EEPROMTable, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeEepromMemoryChildTask_Test_EEPROMTable"); @@ -1844,8 +2137,8 @@ void UtTest_Setup(void) "CS_RecomputeEepromMemoryChildTask_Test_CFECore"); UtTest_Add(CS_RecomputeEepromMemoryChildTask_Test_OSCore, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeEepromMemoryChildTask_Test_OSCore"); - UtTest_Add(CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableEntryId, CS_Test_Setup, CS_Test_TearDown, - "CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableEntryId"); + UtTest_Add(CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableEntryID, CS_Test_Setup, CS_Test_TearDown, + "CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableEntryID"); UtTest_Add(CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableStartAddress, CS_Test_Setup, CS_Test_TearDown, "CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableStartAddress"); UtTest_Add(CS_RecomputeEepromMemoryChildTask_Test_EEPROMTableState, CS_Test_Setup, CS_Test_TearDown, diff --git a/unit-test/cs_dispatch_tests.c b/unit-test/cs_dispatch_tests.c new file mode 100644 index 0000000..74e9d41 --- /dev/null +++ b/unit-test/cs_dispatch_tests.c @@ -0,0 +1,2822 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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. + ************************************************************************/ + +/* + * Includes + */ + +#include "cs_app.h" +#include "cs_app_cmds.h" +#include "cs_cmds.h" +#include "cs_eeprom_cmds.h" +#include "cs_memory_cmds.h" +#include "cs_table_cmds.h" +#include "cs_msg.h" +#include "cs_msgdefs.h" +#include "cs_eventids.h" +#include "cs_version.h" +#include "cs_init.h" +#include "cs_utils.h" +#include "cs_dispatch.h" +#include "cs_test_utils.h" +#include +#include + +/* UT includes */ +#include "uttest.h" +#include "utassert.h" +#include "utstubs.h" + +#define CS_NUM_DATA_STORE_STATES 6 + +/* Define a CDS ID that will return TRUE for CFE_RESOURCEID_TEST_DEFINED, basically nonzero */ +#define UT_VALID_CDSID CFE_ES_CDSHANDLE_C(CFE_RESOURCEID_WRAP(1)) + +/* Command buffer typedef for any handler */ +typedef union +{ + CFE_SB_Buffer_t Buf; + + CS_SendHkCmd_t SendHkCmd; + CS_NoopCmd_t NoopCmd; + CS_ResetCmd_t ResetCmd; + CS_BackgroundCheckCycleCmd_t BackgroundCheckCycle; + CS_DisableAllCSCmd_t DisableAllCSCmd; + CS_EnableAllCSCmd_t EnableAllCSCmd; + CS_DisableCfeCoreCmd_t DisableCfeCoreCmd; + CS_EnableCfeCoreCmd_t EnableCfeCoreCmd; + CS_DisableOSCmd_t DisableOSCmd; + CS_EnableOSCmd_t EnableOSCmd; + CS_ReportBaselineCfeCoreCmd_t ReportBaselineCfeCoreCmd; + CS_ReportBaselineOSCmd_t ReportBaselineOSCmd; + CS_RecomputeBaselineCfeCoreCmd_t RecomputeBaselineCfeCoreCmd; + CS_RecomputeBaselineOSCmd_t RecomputeBaselineOSCmd; + CS_CancelOneShotCmd_t CancelOneShotCmd; + CS_DisableAppsCmd_t DisableAppsCmd; + CS_EnableAppsCmd_t EnableAppsCmd; + CS_DisableEepromCmd_t DisableEepromCmd; + CS_EnableEepromCmd_t EnableEepromCmd; + CS_DisableMemoryCmd_t DisableMemoryCmd; + CS_EnableMemoryCmd_t EnableMemoryCmd; + CS_DisableTablesCmd_t DisableTablesCmd; + CS_EnableTablesCmd_t EnableTablesCmd; + CS_GetEntryIDEepromCmd_t GetEntryIDEepromCmd; + CS_GetEntryIDMemoryCmd_t GetEntryIDMemoryCmd; + CS_ReportBaselineEntryIDEepromCmd_t ReportBaselineEntryIDEepromCmd; + CS_DisableEntryIDEepromCmd_t DisableEntryIDEepromCmd; + CS_RecomputeBaselineEepromCmd_t RecomputeBaselineEepromCmd; + CS_EnableEntryIDEepromCmd_t EnableEntryIDEepromCmd; + CS_ReportBaselineEntryIDMemoryCmd_t ReportBaselineEntryIDMemoryCmd; + CS_DisableEntryIDMemoryCmd_t DisableEntryIDMemoryCmd; + CS_RecomputeBaselineMemoryCmd_t RecomputeBaselineMemoryCmd; + CS_EnableEntryIDMemoryCmd_t EnableEntryIDMemoryCmd; + CS_ReportBaselineTableCmd_t ReportBaselineTableCmd; + CS_RecomputeBaselineTableCmd_t RecomputeBaselineTableCmd; + CS_DisableNameTableCmd_t DisableNameTableCmd; + CS_EnableNameTableCmd_t EnableNameTableCmd; + CS_ReportBaselineAppCmd_t ReportBaselineAppCmd; + CS_RecomputeBaselineAppCmd_t RecomputeBaselineAppCmd; + CS_DisableNameAppCmd_t DisableNameAppCmd; + CS_EnableNameAppCmd_t EnableNameAppCmd; + CS_OneShotCmd_t OneShotCmd; + +} UT_CmdBuf_t; + +const size_t UT_CMD_SIZE[] = { + [CS_NOOP_CC] = sizeof(CS_NoopCmd_t), + [CS_RESET_CC] = sizeof(CS_ResetCmd_t), + [CS_ONE_SHOT_CC] = sizeof(CS_OneShotCmd_t), + [CS_CANCEL_ONE_SHOT_CC] = sizeof(CS_CancelOneShotCmd_t), + [CS_ENABLE_ALL_CS_CC] = sizeof(CS_EnableAllCSCmd_t), + [CS_DISABLE_ALL_CS_CC] = sizeof(CS_DisableAllCSCmd_t), + [CS_ENABLE_CFE_CORE_CC] = sizeof(CS_EnableCfeCoreCmd_t), + [CS_DISABLE_CFE_CORE_CC] = sizeof(CS_DisableCfeCoreCmd_t), + [CS_REPORT_BASELINE_CFE_CORE_CC] = sizeof(CS_ReportBaselineCfeCoreCmd_t), + [CS_RECOMPUTE_BASELINE_CFE_CORE_CC] = sizeof(CS_RecomputeBaselineCfeCoreCmd_t), + [CS_ENABLE_OS_CC] = sizeof(CS_EnableOSCmd_t), + [CS_DISABLE_OS_CC] = sizeof(CS_DisableOSCmd_t), + [CS_REPORT_BASELINE_OS_CC] = sizeof(CS_ReportBaselineOSCmd_t), + [CS_RECOMPUTE_BASELINE_OS_CC] = sizeof(CS_RecomputeBaselineOSCmd_t), + [CS_ENABLE_EEPROM_CC] = sizeof(CS_EnableEepromCmd_t), + [CS_DISABLE_EEPROM_CC] = sizeof(CS_DisableEepromCmd_t), + [CS_REPORT_BASELINE_ENTRY_ID_EEPROM_CC] = sizeof(CS_ReportBaselineEntryIDEepromCmd_t), + [CS_RECOMPUTE_BASELINE_EEPROM_CC] = sizeof(CS_RecomputeBaselineEepromCmd_t), + [CS_ENABLE_ENTRY_ID_EEPROM_CC] = sizeof(CS_EnableEntryIDEepromCmd_t), + [CS_DISABLE_ENTRY_ID_EEPROM_CC] = sizeof(CS_DisableEntryIDEepromCmd_t), + [CS_GET_ENTRY_ID_EEPROM_CC] = sizeof(CS_GetEntryIDEepromCmd_t), + [CS_ENABLE_MEMORY_CC] = sizeof(CS_EnableMemoryCmd_t), + [CS_DISABLE_MEMORY_CC] = sizeof(CS_DisableMemoryCmd_t), + [CS_REPORT_BASELINE_ENTRY_ID_MEMORY_CC] = sizeof(CS_ReportBaselineEntryIDMemoryCmd_t), + [CS_RECOMPUTE_BASELINE_MEMORY_CC] = sizeof(CS_RecomputeBaselineMemoryCmd_t), + [CS_ENABLE_ENTRY_ID_MEMORY_CC] = sizeof(CS_EnableEntryIDMemoryCmd_t), + [CS_DISABLE_ENTRY_ID_MEMORY_CC] = sizeof(CS_DisableEntryIDMemoryCmd_t), + [CS_GET_ENTRY_ID_MEMORY_CC] = sizeof(CS_GetEntryIDMemoryCmd_t), + [CS_ENABLE_TABLES_CC] = sizeof(CS_EnableTablesCmd_t), + [CS_DISABLE_TABLES_CC] = sizeof(CS_DisableTablesCmd_t), + [CS_REPORT_BASELINE_TABLE_CC] = sizeof(CS_ReportBaselineTableCmd_t), + [CS_RECOMPUTE_BASELINE_TABLE_CC] = sizeof(CS_RecomputeBaselineTableCmd_t), + [CS_ENABLE_NAME_TABLE_CC] = sizeof(CS_EnableNameTableCmd_t), + [CS_DISABLE_NAME_TABLE_CC] = sizeof(CS_DisableNameTableCmd_t), + [CS_ENABLE_APPS_CC] = sizeof(CS_EnableAppsCmd_t), + [CS_DISABLE_APPS_CC] = sizeof(CS_DisableAppsCmd_t), + [CS_REPORT_BASELINE_APP_CC] = sizeof(CS_ReportBaselineAppCmd_t), + [CS_RECOMPUTE_BASELINE_APP_CC] = sizeof(CS_RecomputeBaselineAppCmd_t), + [CS_ENABLE_NAME_APP_CC] = sizeof(CS_EnableNameAppCmd_t), + [CS_DISABLE_NAME_APP_CC] = sizeof(CS_DisableNameAppCmd_t), +}; + +/* cs_app_tests globals */ +uint8 call_count_CFE_EVS_SendEvent; + +/* + * Function Definitions + */ + +void UT_CS_SetupDispatchCheck(CFE_SB_MsgId_t TestMsgId, CFE_MSG_FcnCode_t FcnCode, bool length_ok) +{ + CFE_MSG_Size_t MsgSize; + CFE_SB_MsgId_t SEND_HK = CFE_SB_ValueToMsgId(CS_SEND_HK_MID); + CFE_SB_MsgId_t BACKGROUND_CYCLE = CFE_SB_ValueToMsgId(CS_BACKGROUND_CYCLE_MID); + CFE_SB_MsgId_t CMD = CFE_SB_ValueToMsgId(CS_CMD_MID); + + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), true); + + if (CFE_SB_MsgId_Equal(TestMsgId, SEND_HK)) + { + MsgSize = sizeof(CS_SendHkCmd_t); + } + else if (CFE_SB_MsgId_Equal(TestMsgId, BACKGROUND_CYCLE)) + { + MsgSize = sizeof(CS_BackgroundCheckCycleCmd_t); + } + else if (CFE_SB_MsgId_Equal(TestMsgId, CMD)) + { + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), true); + if (FcnCode < (sizeof(UT_CMD_SIZE) / sizeof(UT_CMD_SIZE[0]))) + { + MsgSize = UT_CMD_SIZE[FcnCode]; + } + else + { + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), true); + MsgSize = 0; + } + } + else + { + MsgSize = 0; + } + if (!length_ok) + { + /* Make it wrong */ + ++MsgSize; + + /* The event report will call these again */ + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), true); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), true); + } + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), true); +} + +void CS_AppPipe_Test_TableUpdateErrors(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_SEND_HK_MID); + UT_CS_SetupDispatchCheck(TestMsgId, 0, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); + /* Generates 5 event messages we don't care about in this test */ +} + +void CS_AppPipe_Test_BackgroundCycle(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_BACKGROUND_CYCLE_MID); + UT_CS_SetupDispatchCheck(TestMsgId, 0, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_NoopCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_NOOP_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_ResetCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_RESET_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_OneShotCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_ONE_SHOT_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_CancelOneShotCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_CANCEL_ONE_SHOT_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_EnableAllCSCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_ENABLE_ALL_CS_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_DisableAllCSCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_DISABLE_ALL_CS_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_EnableCfeCoreCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_ENABLE_CFE_CORE_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_DisableCfeCoreCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_DISABLE_CFE_CORE_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_ReportBaselineCfeCoreCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_REPORT_BASELINE_CFE_CORE_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_RecomputeBaselineCfeCoreCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_RECOMPUTE_BASELINE_CFE_CORE_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_EnableOSCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_ENABLE_OS_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_DisableOSCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_DISABLE_OS_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_ReportBaselineOSCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_REPORT_BASELINE_OS_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_RecomputeBaselineOSCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_RECOMPUTE_BASELINE_OS_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_EnableEepromCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_ENABLE_EEPROM_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_DisableEepromCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_DISABLE_EEPROM_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_ReportBaselineEntryIDEepromCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_REPORT_BASELINE_ENTRY_ID_EEPROM_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_RecomputeBaselineEepromCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_RECOMPUTE_BASELINE_EEPROM_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_EnableEntryIDEepromCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_ENABLE_ENTRY_ID_EEPROM_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_DisableEntryIDEepromCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_DISABLE_ENTRY_ID_EEPROM_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_GetEntryIDEepromCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_GET_ENTRY_ID_EEPROM_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_EnableMemoryCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_ENABLE_MEMORY_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_DisableMemoryCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_DISABLE_MEMORY_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_ReportBaselineEntryIDMemoryCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_REPORT_BASELINE_ENTRY_ID_MEMORY_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_RecomputeBaselineMemoryCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_RECOMPUTE_BASELINE_MEMORY_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_EnableEntryIDMemoryCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_ENABLE_ENTRY_ID_MEMORY_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_DisableEntryIDMemoryCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_DISABLE_ENTRY_ID_MEMORY_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_GetEntryIDMemoryCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_GET_ENTRY_ID_MEMORY_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_EnableTablesCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_ENABLE_TABLES_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_DisableTablesCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_DISABLE_TABLES_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_ReportBaselineTableCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_REPORT_BASELINE_TABLE_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_RecomputeBaselineTableCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_RECOMPUTE_BASELINE_TABLE_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_EnableNameTableCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_ENABLE_NAME_TABLE_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_DisableNameTableCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_DISABLE_NAME_TABLE_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_EnableAppsCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_ENABLE_APPS_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_DisableAppsCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_DISABLE_APPS_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_ReportBaselineAppCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_REPORT_BASELINE_APP_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_RecomputeBaselineAppCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_RECOMPUTE_BASELINE_APP_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_EnableNameAppCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_ENABLE_NAME_APP_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_DisableNameAppCmd(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = CS_DISABLE_NAME_APP_CC; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_InvalidCCError(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, + "Invalid ground command code: ID = 0x%%08lX, CC = %%d"); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + FcnCode = 99; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_CC_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); + + strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); + + UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_InvalidMIDError(void) +{ + CFE_Status_t Result; + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Invalid command pipe message ID: 0x%%08lX"); + + CS_AppData.ChildTaskTable = -1; + + TestMsgId = CFE_SB_INVALID_MSG_ID; + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); + + /* Execute the function being tested */ + Result = CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_MID_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); + + strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); + + UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); + + call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + + UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", + call_count_CFE_EVS_SendEvent); +} + +void CS_AppPipe_Test_SendHkCmd(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + TestMsgId = CFE_SB_ValueToMsgId(CS_SEND_HK_MID); + FcnCode = 99; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_SendHkCmd, 1); +} + +void CS_AppPipe_Test_SendHkVerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + TestMsgId = CFE_SB_ValueToMsgId(CS_SEND_HK_MID); + FcnCode = 99; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_SendHkCmd, 0); +} + +void CS_AppPipe_Test_BackgroundCheckCycleCmd(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + TestMsgId = CFE_SB_ValueToMsgId(CS_BACKGROUND_CYCLE_MID); + FcnCode = 99; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_BackgroundCheckCycleCmd, 1); +} + +void CS_AppPipe_Test_BackgroundCheckCycleVerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId; + CFE_MSG_FcnCode_t FcnCode; + + memset(&CmdBuf, 0, sizeof(CmdBuf)); + + TestMsgId = CFE_SB_ValueToMsgId(CS_BACKGROUND_CYCLE_MID); + FcnCode = 99; + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_AppPipe(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_BackgroundCheckCycleCmd, 0); +} + +void CS_ProcessCmd_NoopCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_NOOP_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_NoopCmd, 1); +} + +void CS_ProcessCmd_ResetCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RESET_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ResetCmd, 1); +} + +void CS_ProcessCmd_DisableAllCSCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ALL_CS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableAllCSCmd, 1); +} + +void CS_ProcessCmd_EnableAllCSCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ALL_CS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableAllCSCmd, 1); +} + +void CS_ProcessCmd_DisableCfeCoreCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_CFE_CORE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableCfeCoreCmd, 1); +} + +void CS_ProcessCMD_EnableCfeCoreCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_CFE_CORE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableCfeCoreCmd, 1); +} + +void CS_ProcessCmd_DisableOSCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_OS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableOSCmd, 1); +} + +void CS_ProcessCmd_EnableOSCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_OS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableOSCmd, 1); +} + +void CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_CFE_CORE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineCfeCoreCmd, 1); +} + +void CS_ProcessCmd_ReportBaselineOSCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_OS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineOSCmd, 1); +} + +void CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_CFE_CORE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineCfeCoreCmd, 1); +} + +void CS_ProcessCmd_RecomputeBaselineOSCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_OS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineOSCmd, 1); +} + +void CS_ProcessCmd_OneShotCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ONE_SHOT_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_OneShotCmd, 1); +} + +void CS_ProcessCmd_CancelOneShotCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_CANCEL_ONE_SHOT_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_CancelOneShotCmd, 1); +} + +void CS_ProcessCmd_DisableTablesCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_TABLES_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableTablesCmd, 1); +} + +void CS_ProcessCmd_EnableTablesCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_TABLES_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableTablesCmd, 1); +} + +void CS_ProcessCmd_ReportBaselineTableCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_TABLE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineTableCmd, 1); +} + +void CS_ProcessCmd_RecomputeBaselineTableCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_TABLE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineTableCmd, 1); +} + +void CS_ProcessCmd_DisableNameTableCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_NAME_TABLE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableNameTableCmd, 1); +} + +void CS_ProcessCmd_EnableNameTableCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_NAME_TABLE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableNameTableCmd, 1); +} + +void CS_ProcessCmd_DisableAppsCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_APPS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableAppsCmd, 1); +} + +void CS_ProcessCmd_EnableAppsCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_APPS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableAppsCmd, 1); +} + +void CS_ProcessCmd_ReportBaselineAppCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_APP_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineAppCmd, 1); +} + +void CS_ProcessCmd_RecomputeBaselineAppCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_APP_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineAppCmd, 1); +} + +void CS_ProcessCmd_DisableNameAppCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_NAME_APP_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableNameAppCmd, 1); +} + +void CS_ProcessCmd_EnableNameAppCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_NAME_APP_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableNameAppCmd, 1); +} + +void CS_ProcessCmd_DisableMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableMemoryCmd, 1); +} + +void CS_ProcessCmd_EnableMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableMemoryCmd, 1); +} + +void CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_ENTRY_ID_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineEntryIDMemoryCmd, 1); +} + +void CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineMemoryCmd, 1); +} + +void CS_ProcessCmd_EnableEntryIDMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ENTRY_ID_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableEntryIDMemoryCmd, 1); +} + +void CS_ProcessCmd_DisableEntryIDMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ENTRY_ID_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableEntryIDMemoryCmd, 1); +} + +void CS_ProcessCmd_GetEntryIDMemoryCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_GET_ENTRY_ID_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_GetEntryIDMemoryCmd, 1); +} + +void CS_ProcessCmd_DisableEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableEepromCmd, 1); +} + +void CS_ProcessCmd_EnableEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableEepromCmd, 1); +} + +void CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_ENTRY_ID_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineEntryIDEepromCmd, 1); +} + +void CS_ProcessCmd_RecomputeBaselineEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineEepromCmd, 1); +} + +void CS_ProcessCmd_EnableEntryIDEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ENTRY_ID_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableEntryIDEepromCmd, 1); +} + +void CS_ProcessCmd_DisableEntryIDEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ENTRY_ID_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableEntryIDEepromCmd, 1); +} + +void CS_ProcessCmd_GetEntryIDEepromCmd_Test(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_GET_ENTRY_ID_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, true); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_GetEntryIDEepromCmd, 1); +} + +void CS_ProcessCmd_NoopCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_NOOP_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_NoopCmd, 0); +} + +void CS_ProcessCmd_ResetCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RESET_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ResetCmd, 0); +} + +void CS_ProcessCmd_DisableAllCSCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ALL_CS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableAllCSCmd, 0); +} + +void CS_ProcessCmd_EnableAllCSCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ALL_CS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableAllCSCmd, 0); +} + +void CS_ProcessCmd_DisableCfeCoreCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_CFE_CORE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableCfeCoreCmd, 0); +} + +void CS_ProcessCMD_EnableCfeCoreCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_CFE_CORE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableCfeCoreCmd, 0); +} + +void CS_ProcessCmd_DisableOSCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_OS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableOSCmd, 0); +} + +void CS_ProcessCmd_EnableOSCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_OS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableOSCmd, 0); +} + +void CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_CFE_CORE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineCfeCoreCmd, 0); +} + +void CS_ProcessCmd_ReportBaselineOSCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_OS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineOSCmd, 0); +} + +void CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_CFE_CORE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineCfeCoreCmd, 0); +} + +void CS_ProcessCmd_RecomputeBaselineOSCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_OS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineOSCmd, 0); +} + +void CS_ProcessCmd_OneShotCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ONE_SHOT_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_OneShotCmd, 0); +} + +void CS_ProcessCmd_CancelOneShotCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_CANCEL_ONE_SHOT_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_CancelOneShotCmd, 0); +} + +void CS_ProcessCmd_DisableTablesCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_TABLES_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableTablesCmd, 0); +} + +void CS_ProcessCmd_EnableTablesCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_TABLES_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableTablesCmd, 0); +} + +void CS_ProcessCmd_ReportBaselineTableCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_TABLE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineTableCmd, 0); +} + +void CS_ProcessCmd_RecomputeBaselineTableCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_TABLE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineTableCmd, 0); +} + +void CS_ProcessCmd_DisableNameTableCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_NAME_TABLE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableNameTableCmd, 0); +} + +void CS_ProcessCmd_EnableNameTableCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_NAME_TABLE_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableNameTableCmd, 0); +} + +void CS_ProcessCmd_DisableAppsCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_APPS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableAppsCmd, 0); +} + +void CS_ProcessCmd_EnableAppsCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_APPS_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableAppsCmd, 0); +} + +void CS_ProcessCmd_ReportBaselineAppCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_APP_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineAppCmd, 0); +} + +void CS_ProcessCmd_RecomputeBaselineAppCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_APP_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineAppCmd, 0); +} + +void CS_ProcessCmd_DisableNameAppCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_NAME_APP_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableNameAppCmd, 0); +} + +void CS_ProcessCmd_EnableNameAppCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_NAME_APP_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableNameAppCmd, 0); +} + +void CS_ProcessCmd_DisableMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableMemoryCmd, 0); +} + +void CS_ProcessCmd_EnableMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableMemoryCmd, 0); +} + +void CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_ENTRY_ID_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineEntryIDMemoryCmd, 0); +} + +void CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineMemoryCmd, 0); +} + +void CS_ProcessCmd_EnableEntryIDMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ENTRY_ID_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableEntryIDMemoryCmd, 0); +} + +void CS_ProcessCmd_DisableEntryIDMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ENTRY_ID_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableEntryIDMemoryCmd, 0); +} + +void CS_ProcessCmd_GetEntryIDMemoryCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_GET_ENTRY_ID_MEMORY_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_GetEntryIDMemoryCmd, 0); +} + +void CS_ProcessCmd_DisableEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableEepromCmd, 0); +} + +void CS_ProcessCmd_EnableEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableEepromCmd, 0); +} + +void CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_REPORT_BASELINE_ENTRY_ID_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_ReportBaselineEntryIDEepromCmd, 0); +} + +void CS_ProcessCmd_RecomputeBaselineEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_RECOMPUTE_BASELINE_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_RecomputeBaselineEepromCmd, 0); +} + +void CS_ProcessCmd_EnableEntryIDEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_ENABLE_ENTRY_ID_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_EnableEntryIDEepromCmd, 0); +} + +void CS_ProcessCmd_DisableEntryIDEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_DISABLE_ENTRY_ID_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_DisableEntryIDEepromCmd, 0); +} + +void CS_ProcessCmd_GetEntryIDEepromCmd_Test_VerifyError(void) +{ + UT_CmdBuf_t CmdBuf; + CFE_SB_MsgId_t TestMsgId = CFE_SB_ValueToMsgId(CS_CMD_MID); + CFE_MSG_FcnCode_t FcnCode = CS_GET_ENTRY_ID_EEPROM_CC; + + UT_CS_SetupDispatchCheck(TestMsgId, FcnCode, false); + /* Execute the function being tested */ + CS_ProcessCmd(&CmdBuf.Buf); + + /* Verify results */ + UtAssert_STUB_COUNT(CS_GetEntryIDEepromCmd, 0); +} + +void UtTest_Setup(void) +{ + UtTest_Add(CS_AppPipe_Test_TableUpdateErrors, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_TableUpdateErrors"); + UtTest_Add(CS_AppPipe_Test_BackgroundCycle, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_BackgroundCycle"); + UtTest_Add(CS_AppPipe_Test_NoopCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_NoopCmd"); + UtTest_Add(CS_AppPipe_Test_ResetCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_ResetCmd"); + UtTest_Add(CS_AppPipe_Test_OneShotCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_OneShotCmd"); + UtTest_Add(CS_AppPipe_Test_CancelOneShotCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_CancelOneShotCmd"); + UtTest_Add(CS_AppPipe_Test_EnableAllCSCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableAllCSCmd"); + UtTest_Add(CS_AppPipe_Test_DisableAllCSCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableAllCSCmd"); + UtTest_Add(CS_AppPipe_Test_EnableCfeCoreCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableCfeCoreCmd"); + UtTest_Add(CS_AppPipe_Test_DisableCfeCoreCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableCfeCoreCmd"); + UtTest_Add(CS_AppPipe_Test_ReportBaselineCfeCoreCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_ReportBaselineCfeCoreCmd"); + UtTest_Add(CS_AppPipe_Test_RecomputeBaselineCfeCoreCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_RecomputeBaselineCfeCoreCmd"); + UtTest_Add(CS_AppPipe_Test_EnableOSCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableOSCmd"); + UtTest_Add(CS_AppPipe_Test_DisableOSCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableOSCmd"); + UtTest_Add(CS_AppPipe_Test_ReportBaselineOSCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_ReportBaselineOSCmd"); + UtTest_Add(CS_AppPipe_Test_RecomputeBaselineOSCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_RecomputeBaselineOSCmd"); + UtTest_Add(CS_AppPipe_Test_EnableEepromCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableEepromCmd"); + UtTest_Add(CS_AppPipe_Test_DisableEepromCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableEepromCmd"); + UtTest_Add(CS_AppPipe_Test_ReportBaselineEntryIDEepromCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_ReportBaselineEntryIDEepromCmd"); + UtTest_Add(CS_AppPipe_Test_RecomputeBaselineEepromCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_RecomputeBaselineEepromCmd"); + UtTest_Add(CS_AppPipe_Test_EnableEntryIDEepromCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_EnableEntryIDEepromCmd"); + UtTest_Add(CS_AppPipe_Test_DisableEntryIDEepromCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_DisableEntryIDEepromCmd"); + UtTest_Add(CS_AppPipe_Test_GetEntryIDEepromCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_GetEntryIDEepromCmd"); + UtTest_Add(CS_AppPipe_Test_EnableMemoryCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableMemoryCmd"); + UtTest_Add(CS_AppPipe_Test_DisableMemoryCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableMemoryCmd"); + UtTest_Add(CS_AppPipe_Test_ReportBaselineEntryIDMemoryCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_ReportBaselineEntryIDMemoryCmd"); + UtTest_Add(CS_AppPipe_Test_RecomputeBaselineMemoryCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_RecomputeBaselineMemoryCmd"); + UtTest_Add(CS_AppPipe_Test_EnableEntryIDMemoryCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_EnableEntryIDMemoryCmd"); + UtTest_Add(CS_AppPipe_Test_DisableEntryIDMemoryCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_DisableEntryIDMemoryCmd"); + UtTest_Add(CS_AppPipe_Test_GetEntryIDMemoryCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_GetEntryIDMemoryCmd"); + UtTest_Add(CS_AppPipe_Test_EnableTablesCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableTablesCmd"); + UtTest_Add(CS_AppPipe_Test_DisableTablesCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableTablesCmd"); + UtTest_Add(CS_AppPipe_Test_ReportBaselineTableCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_ReportBaselineTableCmd"); + UtTest_Add(CS_AppPipe_Test_RecomputeBaselineTableCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_RecomputeBaselineTableCmd"); + UtTest_Add(CS_AppPipe_Test_EnableNameTableCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_EnableNameTableCmd"); + UtTest_Add(CS_AppPipe_Test_DisableNameTableCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_DisableNameTableCmd"); + UtTest_Add(CS_AppPipe_Test_EnableAppsCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableAppsCmd"); + UtTest_Add(CS_AppPipe_Test_DisableAppsCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableAppsCmd"); + UtTest_Add(CS_AppPipe_Test_ReportBaselineAppCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_ReportBaselineAppCmd"); + UtTest_Add(CS_AppPipe_Test_RecomputeBaselineAppCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_RecomputeBaselineAppCmd"); + UtTest_Add(CS_AppPipe_Test_EnableNameAppCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_EnableNameAppCmd"); + UtTest_Add(CS_AppPipe_Test_DisableNameAppCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_DisableNameAppCmd"); + UtTest_Add(CS_AppPipe_Test_InvalidCCError, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_InvalidCCError"); + UtTest_Add(CS_AppPipe_Test_InvalidMIDError, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_InvalidMIDError"); + + UtTest_Add(CS_AppPipe_Test_SendHkCmd, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_SendHkVerifyError"); + UtTest_Add(CS_AppPipe_Test_SendHkVerifyError, CS_Test_Setup, CS_Test_TearDown, "CS_AppPipe_Test_SendHkVerifyError"); + UtTest_Add(CS_AppPipe_Test_BackgroundCheckCycleCmd, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_BackgroundCheckCycleCmd"); + UtTest_Add(CS_AppPipe_Test_BackgroundCheckCycleVerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_AppPipe_Test_BackgroundCheckCycleVerifyError"); + + UtTest_Add(CS_ProcessCmd_NoopCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_ProcessCmd_NoopCmd_Test"); + UtTest_Add(CS_ProcessCmd_ResetCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_ProcessCmd_ResetCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableAllCSCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableAllCSCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableAllCSCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_ProcessCmd_EnableAllCSCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableCfeCoreCmd_Test"); + UtTest_Add(CS_ProcessCMD_EnableCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCMD_EnableCfeCoreCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_ProcessCmd_DisableOSCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_ProcessCmd_EnableOSCmd_Test"); + UtTest_Add(CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test"); + UtTest_Add(CS_ProcessCmd_ReportBaselineOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineOSCmd_Test"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineOSCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineOSCmd_Test"); + UtTest_Add(CS_ProcessCmd_OneShotCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_ProcessCmd_OneShotCmd_Test"); + UtTest_Add(CS_ProcessCmd_CancelOneShotCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_CancelOneShotCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableTablesCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableTablesCmd_Test"); + UtTest_Add(CS_ProcessCmd_ReportBaselineTableCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineTableCmd_Test"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineTableCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineTableCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableNameTableCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableNameTableCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableNameTableCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableNameTableCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableAppsCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_ProcessCmd_DisableAppsCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableAppsCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_ProcessCmd_EnableAppsCmd_Test"); + UtTest_Add(CS_ProcessCmd_ReportBaselineAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineAppCmd_Test"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineAppCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableNameAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableNameAppCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableNameAppCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableNameAppCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableEntryIDMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableEntryIDMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableEntryIDMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableEntryIDMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_GetEntryIDMemoryCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_GetEntryIDMemoryCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableEepromCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableEepromCmd_Test"); + UtTest_Add(CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineEepromCmd_Test"); + UtTest_Add(CS_ProcessCmd_EnableEntryIDEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableEntryIDEepromCmd_Test"); + UtTest_Add(CS_ProcessCmd_DisableEntryIDEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableEntryIDEepromCmd_Test"); + UtTest_Add(CS_ProcessCmd_GetEntryIDEepromCmd_Test, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_GetEntryIDEepromCmd_Test"); + + UtTest_Add(CS_ProcessCmd_NoopCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_NoopCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ResetCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ResetCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableAllCSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableAllCSCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableAllCSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableAllCSCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableCfeCoreCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCMD_EnableCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCMD_EnableCfeCoreCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableOSCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableOSCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineCfeCoreCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ReportBaselineOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineOSCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineCfeCoreCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineOSCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineOSCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_OneShotCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_OneShotCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_CancelOneShotCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_CancelOneShotCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableTablesCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableTablesCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableTablesCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ReportBaselineTableCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineTableCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineTableCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineTableCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableNameTableCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableNameTableCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableNameTableCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableNameTableCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableAppsCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableAppsCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableAppsCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableAppsCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ReportBaselineAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineAppCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineAppCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableNameAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableNameAppCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableNameAppCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableNameAppCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineEntryIDMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableEntryIDMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableEntryIDMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_GetEntryIDMemoryCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_GetEntryIDMemoryCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableEepromCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableEepromCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_ReportBaselineEntryIDEepromCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_RecomputeBaselineEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_RecomputeBaselineEepromCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_EnableEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_EnableEntryIDEepromCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_DisableEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_DisableEntryIDEepromCmd_Test_VerifyError"); + UtTest_Add(CS_ProcessCmd_GetEntryIDEepromCmd_Test_VerifyError, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessCmd_GetEntryIDEepromCmd_Test_VerifyError"); +} diff --git a/unit-test/cs_eds_dispatch_tests.c b/unit-test/cs_eds_dispatch_tests.c new file mode 100644 index 0000000..06f41f9 --- /dev/null +++ b/unit-test/cs_eds_dispatch_tests.c @@ -0,0 +1,72 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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. + ************************************************************************/ + +/* + * Includes + */ + +#include "cs_app.h" +#include "cs_app_cmds.h" +#include "cs_cmds.h" +#include "cs_eeprom_cmds.h" +#include "cs_memory_cmds.h" +#include "cs_table_cmds.h" +#include "cs_msg.h" +#include "cs_msgdefs.h" +#include "cs_eventids.h" +#include "cs_version.h" +#include "cs_init.h" +#include "cs_utils.h" +#include "cs_dispatch.h" +#include "cs_test_utils.h" +#include "cs_eds_dispatcher.h" +#include +#include + +/* UT includes */ +#include "uttest.h" +#include "utassert.h" +#include "utstubs.h" + +/* +********************************************************************************** +** TEST CASE FUNCTIONS +********************************************************************************** +*/ + +void Test_CS_AppPipe(void) +{ + /* + * Test Case For: + * void CS_AppPipe + */ + CFE_SB_Buffer_t UtBuf; + + UT_SetDeferredRetcode(UT_KEY(CFE_EDSMSG_Dispatch), 1, CFE_SUCCESS); + + memset(&UtBuf, 0, sizeof(UtBuf)); + UtAssert_VOIDCALL(CS_AppPipe(&UtBuf)); +} + +/* + * Register the test cases to execute with the unit test tool + */ +void UtTest_Setup(void) +{ + UtTest_Add(Test_CS_AppPipe, CS_Test_Setup, CS_Test_TearDown, "Test_CS_AppPipe"); +} diff --git a/unit-test/cs_eeprom_cmds_tests.c b/unit-test/cs_eeprom_cmds_tests.c index 582fa20..a294a7a 100644 --- a/unit-test/cs_eeprom_cmds_tests.c +++ b/unit-test/cs_eeprom_cmds_tests.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -24,7 +23,7 @@ #include "cs_eeprom_cmds.h" #include "cs_msg.h" #include "cs_msgdefs.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_version.h" #include "cs_utils.h" #include "cs_test_utils.h" @@ -45,20 +44,19 @@ uint8 call_count_CFE_EVS_SendEvent; void CS_DisableEepromCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of EEPROM is Disabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_DisableEepromCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSState == CS_STATE_DISABLED, - "CS_AppData.HkPacket.Payload.EepromCSState == CS_STATE_DISABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSState == CS_ChecksumState_DISABLED, + "CS_AppData.HkPacket.Payload.EepromCSState == CS_ChecksumState_DISABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_EEPROM_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -77,9 +75,9 @@ void CS_DisableEepromCmd_Test(void) void CS_DisableEepromCmd_Test_OneShot(void) { - CS_NoArgsCmd_t CmdPacket; + CS_DisableEepromCmd_t CmdPacket; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + memset(&CmdPacket, 0, sizeof(CmdPacket)); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ @@ -96,20 +94,19 @@ void CS_DisableEepromCmd_Test_OneShot(void) void CS_EnableEepromCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of EEPROM is Enabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_EnableEepromCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.EepromCSState == CS_STATE_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.EepromCSState == CS_ChecksumState_ENABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ENABLE_EEPROM_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -128,9 +125,9 @@ void CS_EnableEepromCmd_Test(void) void CS_EnableEepromCmd_Test_OneShot(void) { - CS_NoArgsCmd_t CmdPacket; + CS_EnableEepromCmd_t CmdPacket; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + memset(&CmdPacket, 0, sizeof(CmdPacket)); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ @@ -147,19 +144,19 @@ void CS_EnableEepromCmd_Test_OneShot(void) void CS_ReportBaselineEntryIDEepromCmd_Test_Computed(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t * ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Report baseline of EEPROM Entry %%d is 0x%%08X"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State = 99; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].ComputedYet = true; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].ComparisonValue = 1; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; + ResEepromTblPtr[CmdPacket.Payload.EntryID].ComputedYet = true; + ResEepromTblPtr[CmdPacket.Payload.EntryID].ComparisonValue = 1; /* Execute the function being tested */ CS_ReportBaselineEntryIDEepromCmd(&CmdPacket); @@ -182,20 +179,20 @@ void CS_ReportBaselineEntryIDEepromCmd_Test_Computed(void) void CS_ReportBaselineEntryIDEepromCmd_Test_NotYetComputed(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t * ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Report baseline of EEPROM Entry %%d has not been computed yet"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State = 99; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].ComputedYet = false; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].ComparisonValue = 1; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; + ResEepromTblPtr[CmdPacket.Payload.EntryID].ComputedYet = false; + ResEepromTblPtr[CmdPacket.Payload.EntryID].ComparisonValue = 1; /* Execute the function being tested */ CS_ReportBaselineEntryIDEepromCmd(&CmdPacket); @@ -218,16 +215,16 @@ void CS_ReportBaselineEntryIDEepromCmd_Test_NotYetComputed(void) void CS_ReportBaselineEntryIDEepromCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "EEPROM report baseline failed, Entry ID invalid: %%d, State: %%d Max ID: %%d"); CmdPacket.Payload.EntryID = CS_MAX_NUM_EEPROM_TABLE_ENTRIES; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + UT_ResetState(UT_KEY(CS_GetResEntryAddr)); /* Remove handler so this will return NULL */ /* Execute the function being tested */ CS_ReportBaselineEntryIDEepromCmd(&CmdPacket); @@ -250,18 +247,18 @@ void CS_ReportBaselineEntryIDEepromCmd_Test_InvalidEntryErrorEntryIDTooHigh(void void CS_ReportBaselineEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t * ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "EEPROM report baseline failed, Entry ID invalid: %%d, State: %%d Max ID: %%d"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_STATE_EMPTY; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_EMPTY; /* Execute the function being tested */ CS_ReportBaselineEntryIDEepromCmd(&CmdPacket); @@ -284,30 +281,34 @@ void CS_ReportBaselineEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty(void) void CS_RecomputeBaselineEepromCmd_Test_Nominal(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute baseline of EEPROM Entry ID %%d started"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State = 99; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; /* Execute the function being tested */ CS_RecomputeBaselineEepromCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == true, "CS_AppData.HkPacket.Payload.RecomputeInProgress == true"); - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); - - UtAssert_True(CS_AppData.ChildTaskTable == CS_EEPROM_TABLE, "CS_AppData.ChildTaskTable == CS_EEPROM_TABLE"); - UtAssert_True(CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID, "CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID"); - UtAssert_True(CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID], - "CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID]"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == true, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == true"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, + "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); + + UtAssert_True(CS_AppData.ChildTaskTable == CS_ChecksumType_EEPROM_TABLE, + "CS_AppData.ChildTaskTable == CS_ChecksumType_EEPROM_TABLE"); + UtAssert_True(CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID, + "CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID"); + UtAssert_True(CS_AppData.RecomputeEepromMemoryEntryPtr == &ResEepromTblPtr[CmdPacket.Payload.EntryID], + "CS_AppData.RecomputeEepromMemoryEntryPtr == &ResEepromTblPtr[CmdPacket.Payload.EntryID]"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_EEPROM_STARTED_DBG_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_DEBUG); @@ -326,32 +327,35 @@ void CS_RecomputeBaselineEepromCmd_Test_Nominal(void) void CS_RecomputeBaselineEepromCmd_Test_CreateChildTaskError(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute baseline of EEPROM Entry ID %%d failed, CFE_ES_CreateChildTask returned: 0x%%08X"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State = 99; + ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; /* Set to generate error message CS_RECOMPUTE_EEPROM_CREATE_CHDTASK_ERR_EID */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CreateChildTask), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineEepromCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, + "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); - UtAssert_True(CS_AppData.ChildTaskTable == CS_EEPROM_TABLE, "CS_AppData.ChildTaskTable == CS_EEPROM_TABLE"); - UtAssert_True(CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID, "CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID"); - UtAssert_True(CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID], - "CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID]"); + UtAssert_True(CS_AppData.ChildTaskTable == CS_ChecksumType_EEPROM_TABLE, + "CS_AppData.ChildTaskTable == CS_ChecksumType_EEPROM_TABLE"); + UtAssert_True(CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID, + "CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID"); + UtAssert_True(CS_AppData.RecomputeEepromMemoryEntryPtr == &ResEepromTblPtr[CmdPacket.Payload.EntryID], + "CS_AppData.RecomputeEepromMemoryEntryPtr == &ResEepromTblPtr[CmdPacket.Payload.EntryID]"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_EEPROM_CREATE_CHDTASK_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); @@ -361,7 +365,8 @@ void CS_RecomputeBaselineEepromCmd_Test_CreateChildTaskError(void) UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); UtAssert_True(CS_AppData.HkPacket.Payload.CmdErrCounter == 1, "CS_AppData.HkPacket.Payload.CmdErrCounter == 1"); - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -371,16 +376,16 @@ void CS_RecomputeBaselineEepromCmd_Test_CreateChildTaskError(void) void CS_RecomputeBaselineEepromCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "EEPROM recompute baseline of entry failed, Entry ID invalid: %%d, State: %%d, Max ID: %%d"); CmdPacket.Payload.EntryID = CS_MAX_NUM_EEPROM_TABLE_ENTRIES; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + UT_ResetState(UT_KEY(CS_GetResEntryAddr)); /* Remove handler so this will return NULL */ /* Execute the function being tested */ CS_RecomputeBaselineEepromCmd(&CmdPacket); @@ -403,18 +408,18 @@ void CS_RecomputeBaselineEepromCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) void CS_RecomputeBaselineEepromCmd_Test_InvalidEntryErrorStateEmpty(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "EEPROM recompute baseline of entry failed, Entry ID invalid: %%d, State: %%d, Max ID: %%d"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_STATE_EMPTY; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_EMPTY; /* Execute the function being tested */ CS_RecomputeBaselineEepromCmd(&CmdPacket); @@ -437,10 +442,11 @@ void CS_RecomputeBaselineEepromCmd_Test_InvalidEntryErrorStateEmpty(void) void CS_RecomputeBaselineEepromCmd_Test_RecomputeInProgress(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute baseline of EEPROM Entry ID %%d failed: child task in use"); @@ -448,8 +454,6 @@ void CS_RecomputeBaselineEepromCmd_Test_RecomputeInProgress(void) CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineEepromCmd(&CmdPacket); @@ -471,10 +475,11 @@ void CS_RecomputeBaselineEepromCmd_Test_RecomputeInProgress(void) void CS_RecomputeBaselineEepromCmd_Test_OneShot(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute baseline of EEPROM Entry ID %%d failed: child task in use"); @@ -483,8 +488,6 @@ void CS_RecomputeBaselineEepromCmd_Test_OneShot(void) CS_AppData.HkPacket.Payload.RecomputeInProgress = false; CS_AppData.HkPacket.Payload.OneShotInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineEepromCmd(&CmdPacket); @@ -506,25 +509,28 @@ void CS_RecomputeBaselineEepromCmd_Test_OneShot(void) void CS_EnableEntryIDEepromCmd_Test_Nominal(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_EepromMemory_Table_Entry_t *DefEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].DefAddr; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of EEPROM Entry ID %%d is Enabled"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State = 99; - CS_AppData.DefEepromTblPtr[CmdPacket.Payload.EntryID].State = 99; + ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_DISABLED; + DefEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_DISABLED; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_Test_Setup_SetDefEntryState(DefEepromTblPtr[CmdPacket.Payload.EntryID].State); /* Execute the function being tested */ CS_EnableEntryIDEepromCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_ENABLED, - "CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_ENABLED"); + UtAssert_True(ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_ENABLED, + "ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_ENABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ENABLE_EEPROM_ENTRY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -532,9 +538,7 @@ void CS_EnableEntryIDEepromCmd_Test_Nominal(void) strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(CS_AppData.DefEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_ENABLED, - "CS_AppData.DefEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_ENABLED"); + CS_Test_Check_SetDefEntryState(&DefEepromTblPtr[CmdPacket.Payload.EntryID], CS_ChecksumState_ENABLED); UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 1, "CS_AppData.HkPacket.Payload.CmdCounter == 1"); @@ -546,10 +550,13 @@ void CS_EnableEntryIDEepromCmd_Test_Nominal(void) void CS_EnableEntryIDEepromCmd_Test_DefEepromTblPtrStateEmpty(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_EepromMemory_Table_Entry_t *DefEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].DefAddr; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of EEPROM Entry ID %%d is Enabled"); @@ -558,17 +565,19 @@ void CS_EnableEntryIDEepromCmd_Test_DefEepromTblPtrStateEmpty(void) CmdPacket.Payload.EntryID = 1; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State = 99; - CS_AppData.DefEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_STATE_EMPTY; + ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; + DefEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_EMPTY; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_Test_Setup_SetDefEntryState(DefEepromTblPtr[CmdPacket.Payload.EntryID].State); /* Execute the function being tested */ CS_EnableEntryIDEepromCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_ENABLED, - "CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_ENABLED"); + UtAssert_True(ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_ENABLED, + "ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_ENABLED"); + + CS_Test_Check_SetDefEntryState(&DefEepromTblPtr[CmdPacket.Payload.EntryID], CS_ChecksumState_ENABLED); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ENABLE_EEPROM_ENTRY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -596,16 +605,16 @@ void CS_EnableEntryIDEepromCmd_Test_DefEepromTblPtrStateEmpty(void) void CS_EnableEntryIDEepromCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Enable EEPROM entry failed, invalid Entry ID: %%d, State: %%d, Max ID: %%d"); CmdPacket.Payload.EntryID = CS_MAX_NUM_EEPROM_TABLE_ENTRIES; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + UT_ResetState(UT_KEY(CS_GetResEntryAddr)); /* Remove handler so this will return NULL */ /* Execute the function being tested */ CS_EnableEntryIDEepromCmd(&CmdPacket); @@ -628,18 +637,18 @@ void CS_EnableEntryIDEepromCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) void CS_EnableEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Enable EEPROM entry failed, invalid Entry ID: %%d, State: %%d, Max ID: %%d"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_STATE_EMPTY; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_EMPTY; /* Execute the function being tested */ CS_EnableEntryIDEepromCmd(&CmdPacket); @@ -662,9 +671,9 @@ void CS_EnableEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty(void) void CS_EnableEntryIDEepromCmd_Test_OneShot(void) { - CS_EntryCmd_t CmdPacket; + CS_EnableEntryIDEepromCmd_t CmdPacket; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + memset(&CmdPacket, 0, sizeof(CmdPacket)); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ @@ -681,30 +690,34 @@ void CS_EnableEntryIDEepromCmd_Test_OneShot(void) void CS_DisableEntryIDEepromCmd_Test_Nominal(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_EepromMemory_Table_Entry_t *DefEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].DefAddr; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of EEPROM Entry ID %%d is Disabled"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State = 99; - CS_AppData.DefEepromTblPtr[CmdPacket.Payload.EntryID].State = 99; + ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; + DefEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_Test_Setup_SetDefEntryState(DefEepromTblPtr[CmdPacket.Payload.EntryID].State); /* Execute the function being tested */ CS_DisableEntryIDEepromCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_DISABLED, - "CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_DISABLED"); - UtAssert_True(CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0, - "CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0, - "CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0"); + UtAssert_True(ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_DISABLED, + "ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_DISABLED"); + + UtAssert_True(ResEepromTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0, + "ResEepromTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0"); + UtAssert_True(ResEepromTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0, + "ResEepromTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_EEPROM_ENTRY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -713,8 +726,7 @@ void CS_DisableEntryIDEepromCmd_Test_Nominal(void) UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - UtAssert_True(CS_AppData.DefEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_DISABLED, - "CS_AppData.DefEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_DISABLED"); + CS_Test_Check_SetDefEntryState(&DefEepromTblPtr[CmdPacket.Payload.EntryID], CS_ChecksumState_DISABLED); UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 1, "CS_AppData.HkPacket.Payload.CmdCounter == 1"); @@ -726,10 +738,13 @@ void CS_DisableEntryIDEepromCmd_Test_Nominal(void) void CS_DisableEntryIDEepromCmd_Test_DefEepromTblPtrStateEmpty(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_EepromMemory_Table_Entry_t *DefEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].DefAddr; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of EEPROM Entry ID %%d is Disabled"); @@ -738,21 +753,23 @@ void CS_DisableEntryIDEepromCmd_Test_DefEepromTblPtrStateEmpty(void) CmdPacket.Payload.EntryID = 1; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State = 99; - CS_AppData.DefEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_STATE_EMPTY; + ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; + DefEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_EMPTY; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_Test_Setup_SetDefEntryState(DefEepromTblPtr[CmdPacket.Payload.EntryID].State); /* Execute the function being tested */ CS_DisableEntryIDEepromCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_DISABLED, - "CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_DISABLED"); - UtAssert_True(CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0, - "CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0, - "CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0"); + UtAssert_True(ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_DISABLED, + "ResEepromTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_DISABLED"); + CS_Test_Check_SetDefEntryState(&DefEepromTblPtr[CmdPacket.Payload.EntryID], CS_ChecksumState_DISABLED); + + UtAssert_True(ResEepromTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0, + "ResEepromTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0"); + UtAssert_True(ResEepromTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0, + "ResEepromTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_EEPROM_ENTRY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -780,17 +797,16 @@ void CS_DisableEntryIDEepromCmd_Test_DefEepromTblPtrStateEmpty(void) void CS_DisableEntryIDEepromCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Disable EEPROM entry failed, invalid Entry ID: %%d, State: %%d, Max ID: %%d"); CmdPacket.Payload.EntryID = CS_MAX_NUM_EEPROM_TABLE_ENTRIES; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_DisableEntryIDEepromCmd(&CmdPacket); @@ -812,18 +828,18 @@ void CS_DisableEntryIDEepromCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) void CS_DisableEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Disable EEPROM entry failed, invalid Entry ID: %%d, State: %%d, Max ID: %%d"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_STATE_EMPTY; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResEepromTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_EMPTY; /* Execute the function being tested */ CS_DisableEntryIDEepromCmd(&CmdPacket); @@ -846,9 +862,9 @@ void CS_DisableEntryIDEepromCmd_Test_InvalidEntryErrorStateEmpty(void) void CS_DisableEntryIDEepromCmd_Test_OneShot(void) { - CS_EntryCmd_t CmdPacket; + CS_DisableEntryIDEepromCmd_t CmdPacket; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + memset(&CmdPacket, 0, sizeof(CmdPacket)); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ @@ -865,20 +881,20 @@ void CS_DisableEntryIDEepromCmd_Test_OneShot(void) void CS_GetEntryIDEepromCmd_Test_Nominal(void) { - CS_GetEntryIDCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_GetEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "EEPROM Found Address 0x%%08X in Entry ID %%d"); int16 EntryID = 1; - CS_AppData.ResEepromTblPtr[EntryID].StartAddress = 1; - CmdPacket.Payload.Address = 1; - CS_AppData.ResEepromTblPtr[EntryID].NumBytesToChecksum = 0; - CS_AppData.ResEepromTblPtr[EntryID].State = 99; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResEepromTblPtr[EntryID].StartAddress = 1; + CmdPacket.Payload.Address = 1; + ResEepromTblPtr[EntryID].NumBytesToChecksum = 10; + ResEepromTblPtr[EntryID].State = CS_ChecksumState_ENABLED; /* Execute the function being tested */ CS_GetEntryIDEepromCmd(&CmdPacket); @@ -901,15 +917,18 @@ void CS_GetEntryIDEepromCmd_Test_Nominal(void) void CS_GetEntryIDEepromCmd_Test_AddressNotFound(void) { - CS_GetEntryIDCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_GetEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Address 0x%%08X was not found in EEPROM table"); - CmdPacket.Payload.Address = 0xFFFFFFFF; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CmdPacket.Payload.Address = 0xFFFFFFFF; + ResEepromTblPtr[0].State = CS_ChecksumState_ENABLED; + ResEepromTblPtr[0].StartAddress = 1; + ResEepromTblPtr[0].NumBytesToChecksum = 10; /* Execute the function being tested */ CS_GetEntryIDEepromCmd(&CmdPacket); @@ -932,20 +951,20 @@ void CS_GetEntryIDEepromCmd_Test_AddressNotFound(void) void CS_GetEntryIDEepromCmd_Test_AddressPtr(void) { - CS_GetEntryIDCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_GetEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Address 0x%%08X was not found in EEPROM table"); int16 EntryID = 1; - CS_AppData.ResEepromTblPtr[EntryID].StartAddress = 2; - CmdPacket.Payload.Address = 1; - CS_AppData.ResEepromTblPtr[EntryID].NumBytesToChecksum = 0; - CS_AppData.ResEepromTblPtr[EntryID].State = 99; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResEepromTblPtr[EntryID].StartAddress = 2; + CmdPacket.Payload.Address = 1; + ResEepromTblPtr[EntryID].NumBytesToChecksum = 10; + ResEepromTblPtr[EntryID].State = CS_ChecksumState_ENABLED; /* Execute the function being tested */ CS_GetEntryIDEepromCmd(&CmdPacket); @@ -968,20 +987,20 @@ void CS_GetEntryIDEepromCmd_Test_AddressPtr(void) void CS_GetEntryIDEepromCmd_Test_State(void) { - CS_GetEntryIDCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_GetEntryIDEepromCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Address 0x%%08X was not found in EEPROM table"); int16 EntryID = 1; - CS_AppData.ResEepromTblPtr[EntryID].StartAddress = 1; - CmdPacket.Payload.Address = 1; - CS_AppData.ResEepromTblPtr[EntryID].NumBytesToChecksum = 0; - CS_AppData.ResEepromTblPtr[EntryID].State = CS_STATE_EMPTY; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResEepromTblPtr[EntryID].StartAddress = 1; + CmdPacket.Payload.Address = 1; + ResEepromTblPtr[EntryID].NumBytesToChecksum = 10; + ResEepromTblPtr[EntryID].State = CS_ChecksumState_EMPTY; /* Execute the function being tested */ CS_GetEntryIDEepromCmd(&CmdPacket); diff --git a/unit-test/cs_init_tests.c b/unit-test/cs_init_tests.c index c393c2a..cda06a3 100644 --- a/unit-test/cs_init_tests.c +++ b/unit-test/cs_init_tests.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -24,7 +23,7 @@ #include "cs_init.h" #include "cs_msg.h" #include "cs_msgdefs.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_version.h" #include "cs_utils.h" #include "cs_test_utils.h" @@ -185,6 +184,11 @@ void CS_Init_Test_TableInitNominal(void) { CFE_Status_t Result; + CS_AppData.HkPacket.Payload.EepromCSState = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.MemoryCSState = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.TablesCSState = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.AppCSState = CS_ChecksumState_ENABLED; + /* Execute the function being tested */ Result = CS_InitAllTables(); @@ -196,6 +200,11 @@ void CS_Init_Test_TableInitNominal(void) UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", call_count_CFE_EVS_SendEvent); + + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.EepromCSState, CS_ChecksumState_ENABLED); + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.MemoryCSState, CS_ChecksumState_ENABLED); + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.TablesCSState, CS_ChecksumState_ENABLED); + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.AppCSState, CS_ChecksumState_ENABLED); } void CS_Init_Test_TableInitErrorEEPROM(void) @@ -204,12 +213,13 @@ void CS_Init_Test_TableInitErrorEEPROM(void) int32 strCmpResult; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "Table initialization failed for EEPROM: 0x%%08X"); + snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Table initialization failed for %%s: 0x%%08X"); /* Set to generate error message CS_INIT_EEPROM_ERR_EID */ - UT_SetDeferredRetcode(UT_KEY(CS_TableInit), 1, -1); + UT_SetDeferredRetcode(UT_KEY(CS_TableInit), 1 + CS_ChecksumType_EEPROM_TABLE, -1); + + CS_AppData.HkPacket.Payload.EepromCSState = CS_ChecksumState_ENABLED; /* Execute the function being tested */ Result = CS_InitAllTables(); @@ -226,9 +236,10 @@ void CS_Init_Test_TableInitErrorEEPROM(void) call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + /* Generates 1 event message we don't care about in this test */ UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", call_count_CFE_EVS_SendEvent); - /* Generates 1 event message we don't care about in this test */ + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.EepromCSState, CS_ChecksumState_DISABLED); } void CS_Init_Test_TableInitErrorMemory(void) @@ -237,8 +248,10 @@ void CS_Init_Test_TableInitErrorMemory(void) int32 strCmpResult; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "Table initialization failed for Memory: 0x%%08X"); + snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Table initialization failed for %%s: 0x%%08X"); + + CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].GlobalState = NULL; + CS_AppData.HkPacket.Payload.MemoryCSState = CS_ChecksumState_ENABLED; /* Set to prevent unintended error messages */ @@ -246,8 +259,7 @@ void CS_Init_Test_TableInitErrorMemory(void) * Combining a SetReturnCode and a SetFunctionHook in order to return CFE_SUCCESS all runs except the one specified */ - UT_SetDeferredRetcode(UT_KEY(CS_TableInit), 1, CFE_SUCCESS); - UT_SetDeferredRetcode(UT_KEY(CS_TableInit), 1, -1); + UT_SetDeferredRetcode(UT_KEY(CS_TableInit), 1 + CS_ChecksumType_MEMORY_TABLE, -1); /* Execute the function being tested */ Result = CS_InitAllTables(); @@ -267,6 +279,7 @@ void CS_Init_Test_TableInitErrorMemory(void) UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", call_count_CFE_EVS_SendEvent); /* Generates 1 event message we don't care about in this test */ + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.MemoryCSState, CS_ChecksumState_DISABLED); } void CS_Init_Test_TableInitErrorApps(void) @@ -275,16 +288,16 @@ void CS_Init_Test_TableInitErrorApps(void) int32 strCmpResult; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Table initialization failed for Apps: 0x%%08X"); + snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Table initialization failed for %%s: 0x%%08X"); + CS_AppData.HkPacket.Payload.AppCSState = CS_ChecksumState_ENABLED; /* Set to prevent unintended error messages */ /* Set to generate error message CS_INIT_APP_ERR_EID. * Combining a SetReturnCode and a SetFunctionHook in order to return CFE_SUCCESS all runs except the one specified */ - UT_SetDeferredRetcode(UT_KEY(CS_TableInit), 2, CFE_SUCCESS); - UT_SetDeferredRetcode(UT_KEY(CS_TableInit), 1, -1); + UT_SetDeferredRetcode(UT_KEY(CS_TableInit), 1 + CS_ChecksumType_APP_TABLE, -1); /* Execute the function being tested */ Result = CS_InitAllTables(); @@ -304,6 +317,7 @@ void CS_Init_Test_TableInitErrorApps(void) UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", call_count_CFE_EVS_SendEvent); /* Generates 1 event message we don't care about in this test */ + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.AppCSState, CS_ChecksumState_DISABLED); } void CS_Init_Test_TableInitErrorTables(void) @@ -312,17 +326,16 @@ void CS_Init_Test_TableInitErrorTables(void) int32 strCmpResult; char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "Table initialization failed for Tables: 0x%%08X"); + snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Table initialization failed for %%s: 0x%%08X"); + CS_AppData.HkPacket.Payload.TablesCSState = CS_ChecksumState_DISABLED; /* Set to prevent unintended error messages */ /* Set to generate error message CS_INIT_TABLES_ERR_EID. * Combining a SetReturnCode and a SetFunctionHook in order to return CFE_SUCCESS all runs except the one specified */ - UT_SetDeferredRetcode(UT_KEY(CS_TableInit), 3, CFE_SUCCESS); - UT_SetDeferredRetcode(UT_KEY(CS_TableInit), 1, -1); + UT_SetDeferredRetcode(UT_KEY(CS_TableInit), 1 + CS_ChecksumType_TABLES_TABLE, -1); /* Execute the function being tested */ Result = CS_InitAllTables(); @@ -342,6 +355,17 @@ void CS_Init_Test_TableInitErrorTables(void) UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", call_count_CFE_EVS_SendEvent); /* Generates 1 event message we don't care about in this test */ + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.TablesCSState, CS_ChecksumState_DISABLED); +} + +void CS_Init_Test_TableInitErrorOther(void) +{ + UT_SetDeferredRetcode(UT_KEY(CS_TableInit), 1, -1); + + /* Execute the function being tested */ + UtAssert_INT32_EQ(CS_InitAllTables(), -1); + + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } void CS_Init_Test_CFETextSegmentInfoError(void) @@ -421,6 +445,7 @@ void UtTest_Setup(void) UtTest_Add(CS_Init_Test_TableInitErrorMemory, CS_Test_Setup, CS_Test_TearDown, "CS_Init_Test_TableInitErrorMemory"); UtTest_Add(CS_Init_Test_TableInitErrorApps, CS_Test_Setup, CS_Test_TearDown, "CS_Init_Test_TableInitErrorApps"); UtTest_Add(CS_Init_Test_TableInitErrorTables, CS_Test_Setup, CS_Test_TearDown, "CS_Init_Test_TableInitErrorTables"); + UtTest_Add(CS_Init_Test_TableInitErrorOther, CS_Test_Setup, CS_Test_TearDown, "CS_Init_Test_TableInitErrorOther"); UtTest_Add(CS_Init_Test_CFETextSegmentInfoError, CS_Test_Setup, CS_Test_TearDown, "CS_Init_Test_CFETextSegmentInfoError"); UtTest_Add(CS_Init_Test_KernelTextSegmentInfoError, CS_Test_Setup, CS_Test_TearDown, diff --git a/unit-test/cs_memory_cmds_tests.c b/unit-test/cs_memory_cmds_tests.c index e348296..72554d5 100644 --- a/unit-test/cs_memory_cmds_tests.c +++ b/unit-test/cs_memory_cmds_tests.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -24,7 +23,7 @@ #include "cs_memory_cmds.h" #include "cs_msg.h" #include "cs_msgdefs.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_version.h" #include "cs_utils.h" #include "cs_test_utils.h" @@ -45,20 +44,19 @@ uint8 call_count_CFE_EVS_SendEvent; void CS_DisableMemoryCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of Memory is Disabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_DisableMemoryCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == CS_STATE_DISABLED, - "CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_DISABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == CS_ChecksumState_DISABLED, + "CS_AppData.HkPacket.Payload.MemoryCSState = CS_ChecksumState_DISABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_MEMORY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -77,9 +75,9 @@ void CS_DisableMemoryCmd_Test(void) void CS_DisableMemoryCmd_Test_OneShot(void) { - CS_NoArgsCmd_t CmdPacket; + CS_DisableMemoryCmd_t CmdPacket; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + memset(&CmdPacket, 0, sizeof(CmdPacket)); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ @@ -96,20 +94,19 @@ void CS_DisableMemoryCmd_Test_OneShot(void) void CS_EnableMemoryCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of Memory is Enabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_EnableMemoryCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.MemoryCSState = CS_ChecksumState_ENABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ENABLE_MEMORY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -128,9 +125,9 @@ void CS_EnableMemoryCmd_Test(void) void CS_EnableMemoryCmd_Test_OneShot(void) { - CS_NoArgsCmd_t CmdPacket; + CS_EnableMemoryCmd_t CmdPacket; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + memset(&CmdPacket, 0, sizeof(CmdPacket)); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ @@ -147,19 +144,19 @@ void CS_EnableMemoryCmd_Test_OneShot(void) void CS_ReportBaselineEntryIDMemoryCmd_Test_Computed(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t * ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Report baseline of Memory Entry %%d is 0x%%08X"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = 99; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].ComputedYet = true; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].ComparisonValue = 1; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; + ResMemoryTblPtr[CmdPacket.Payload.EntryID].ComputedYet = true; + ResMemoryTblPtr[CmdPacket.Payload.EntryID].ComparisonValue = 1; /* Execute the function being tested */ CS_ReportBaselineEntryIDMemoryCmd(&CmdPacket); @@ -182,20 +179,20 @@ void CS_ReportBaselineEntryIDMemoryCmd_Test_Computed(void) void CS_ReportBaselineEntryIDMemoryCmd_Test_NotYetComputed(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t * ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Report baseline of Memory Entry %%d has not been computed yet"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = 99; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].ComputedYet = false; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].ComparisonValue = 1; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; + ResMemoryTblPtr[CmdPacket.Payload.EntryID].ComputedYet = false; + ResMemoryTblPtr[CmdPacket.Payload.EntryID].ComparisonValue = 1; /* Execute the function being tested */ CS_ReportBaselineEntryIDMemoryCmd(&CmdPacket); @@ -218,17 +215,16 @@ void CS_ReportBaselineEntryIDMemoryCmd_Test_NotYetComputed(void) void CS_ReportBaselineEntryIDMemoryCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Memory report baseline failed, Entry ID invalid: %%d, State: %%d Max ID: %%d"); CmdPacket.Payload.EntryID = CS_MAX_NUM_MEMORY_TABLE_ENTRIES; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_ReportBaselineEntryIDMemoryCmd(&CmdPacket); @@ -250,18 +246,18 @@ void CS_ReportBaselineEntryIDMemoryCmd_Test_InvalidEntryErrorEntryIDTooHigh(void void CS_ReportBaselineEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t * ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Memory report baseline failed, Entry ID invalid: %%d, State: %%d Max ID: %%d"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_STATE_EMPTY; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_EMPTY; /* Execute the function being tested */ CS_ReportBaselineEntryIDMemoryCmd(&CmdPacket); @@ -284,30 +280,34 @@ void CS_ReportBaselineEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty(void) void CS_RecomputeBaselineMemoryCmd_Test_Nominal(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute baseline of Memory Entry ID %%d started"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = 99; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; /* Execute the function being tested */ CS_RecomputeBaselineMemoryCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == true, "CS_AppData.HkPacket.Payload.RecomputeInProgress == true"); - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); - - UtAssert_True(CS_AppData.ChildTaskTable == CS_MEMORY_TABLE, "CS_AppData.ChildTaskTable == CS_MEMORY_TABLE"); - UtAssert_True(CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID, "CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID"); - UtAssert_True(CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID], - "CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID]"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == true, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == true"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, + "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); + + UtAssert_True(CS_AppData.ChildTaskTable == CS_ChecksumType_MEMORY_TABLE, + "CS_AppData.ChildTaskTable == CS_ChecksumType_MEMORY_TABLE"); + UtAssert_True(CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID, + "CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID"); + UtAssert_True(CS_AppData.RecomputeEepromMemoryEntryPtr == &ResMemoryTblPtr[CmdPacket.Payload.EntryID], + "CS_AppData.RecomputeEepromMemoryEntryPtr == &ResMemoryTblPtr[CmdPacket.Payload.EntryID]"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_MEMORY_STARTED_DBG_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_DEBUG); @@ -326,32 +326,35 @@ void CS_RecomputeBaselineMemoryCmd_Test_Nominal(void) void CS_RecomputeBaselineMemoryCmd_Test_CreateChildTaskError(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute baseline of Memory Entry ID %%d failed, ES_CreateChildTask returned: 0x%%08X"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = 99; + ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; /* Set to generate error message CS_RECOMPUTE_MEMORY_CREATE_CHDTASK_ERR_EID */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CreateChildTask), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineMemoryCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, + "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); - UtAssert_True(CS_AppData.ChildTaskTable == CS_MEMORY_TABLE, "CS_AppData.ChildTaskTable == CS_MEMORY_TABLE"); - UtAssert_True(CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID, "CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID"); - UtAssert_True(CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID], - "CS_AppData.RecomputeEepromMemoryEntryPtr == &CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID]"); + UtAssert_True(CS_AppData.ChildTaskTable == CS_ChecksumType_MEMORY_TABLE, + "CS_AppData.ChildTaskTable == CS_ChecksumType_MEMORY_TABLE"); + UtAssert_True(CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID, + "CS_AppData.ChildTaskEntryID == CmdPacket.Payload.EntryID"); + UtAssert_True(CS_AppData.RecomputeEepromMemoryEntryPtr == &ResMemoryTblPtr[CmdPacket.Payload.EntryID], + "CS_AppData.RecomputeEepromMemoryEntryPtr == &ResMemoryTblPtr[CmdPacket.Payload.EntryID]"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_MEMORY_CREATE_CHDTASK_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); @@ -361,7 +364,8 @@ void CS_RecomputeBaselineMemoryCmd_Test_CreateChildTaskError(void) UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); UtAssert_True(CS_AppData.HkPacket.Payload.CmdErrCounter == 1, "CS_AppData.HkPacket.Payload.CmdErrCounter == 1"); - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -371,17 +375,16 @@ void CS_RecomputeBaselineMemoryCmd_Test_CreateChildTaskError(void) void CS_RecomputeBaselineMemoryCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Memory recompute baseline of entry failed, Entry ID invalid: %%d, State: %%d, Max ID: %%d"); CmdPacket.Payload.EntryID = CS_MAX_NUM_MEMORY_TABLE_ENTRIES; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineMemoryCmd(&CmdPacket); @@ -403,18 +406,18 @@ void CS_RecomputeBaselineMemoryCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) void CS_RecomputeBaselineMemoryCmd_Test_InvalidEntryErrorStateEmpty(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Memory recompute baseline of entry failed, Entry ID invalid: %%d, State: %%d, Max ID: %%d"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_STATE_EMPTY; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_EMPTY; /* Execute the function being tested */ CS_RecomputeBaselineMemoryCmd(&CmdPacket); @@ -437,10 +440,11 @@ void CS_RecomputeBaselineMemoryCmd_Test_InvalidEntryErrorStateEmpty(void) void CS_RecomputeBaselineMemoryCmd_Test_RecomputeInProgress(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute baseline of Memory Entry ID %%d failed: child task in use"); @@ -448,8 +452,6 @@ void CS_RecomputeBaselineMemoryCmd_Test_RecomputeInProgress(void) CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineMemoryCmd(&CmdPacket); @@ -471,10 +473,11 @@ void CS_RecomputeBaselineMemoryCmd_Test_RecomputeInProgress(void) void CS_RecomputeBaselineMemoryCmd_Test_OneShot(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute baseline of Memory Entry ID %%d failed: child task in use"); @@ -483,8 +486,6 @@ void CS_RecomputeBaselineMemoryCmd_Test_OneShot(void) CS_AppData.HkPacket.Payload.RecomputeInProgress = false; CS_AppData.HkPacket.Payload.OneShotInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_RecomputeBaselineMemoryCmd(&CmdPacket); @@ -506,25 +507,28 @@ void CS_RecomputeBaselineMemoryCmd_Test_OneShot(void) void CS_EnableEntryIDMemoryCmd_Test_Nominal(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_EepromMemory_Table_Entry_t *DefMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].DefAddr; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of Memory Entry ID %%d is Enabled"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = 99; - CS_AppData.DefMemoryTblPtr[CmdPacket.Payload.EntryID].State = 99; + ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_DISABLED; + DefMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_DISABLED; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_Test_Setup_SetDefEntryState(DefMemoryTblPtr[CmdPacket.Payload.EntryID].State); /* Execute the function being tested */ CS_EnableEntryIDMemoryCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_ENABLED, - "CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_ENABLED"); + UtAssert_True(ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_ENABLED, + "ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_ENABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ENABLE_MEMORY_ENTRY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -533,8 +537,7 @@ void CS_EnableEntryIDMemoryCmd_Test_Nominal(void) UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - UtAssert_True(CS_AppData.DefMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_ENABLED, - "CS_AppData.DefMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_ENABLED"); + CS_Test_Check_SetDefEntryState(&DefMemoryTblPtr[CmdPacket.Payload.EntryID], CS_ChecksumState_ENABLED); UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 1, "CS_AppData.HkPacket.Payload.CmdCounter == 1"); @@ -546,10 +549,13 @@ void CS_EnableEntryIDMemoryCmd_Test_Nominal(void) void CS_EnableEntryIDMemoryCmd_Test_DefMemoryTblPtrStateEmpty(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_EepromMemory_Table_Entry_t *DefMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].DefAddr; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of Memory Entry ID %%d is Enabled"); @@ -558,17 +564,19 @@ void CS_EnableEntryIDMemoryCmd_Test_DefMemoryTblPtrStateEmpty(void) CmdPacket.Payload.EntryID = 1; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = 99; - CS_AppData.DefMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_STATE_EMPTY; + ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; + DefMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_EMPTY; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_Test_Setup_SetDefEntryState(DefMemoryTblPtr[CmdPacket.Payload.EntryID].State); /* Execute the function being tested */ CS_EnableEntryIDMemoryCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_ENABLED, - "CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_ENABLED"); + UtAssert_True(ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_ENABLED, + "ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_ENABLED"); + + CS_Test_Check_SetDefEntryState(&DefMemoryTblPtr[CmdPacket.Payload.EntryID], CS_ChecksumState_ENABLED); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ENABLE_MEMORY_ENTRY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -596,17 +604,16 @@ void CS_EnableEntryIDMemoryCmd_Test_DefMemoryTblPtrStateEmpty(void) void CS_EnableEntryIDMemoryCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Enable Memory entry failed, invalid Entry ID: %%d, State: %%d, Max ID: %%d"); CmdPacket.Payload.EntryID = CS_MAX_NUM_MEMORY_TABLE_ENTRIES; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_EnableEntryIDMemoryCmd(&CmdPacket); @@ -628,18 +635,18 @@ void CS_EnableEntryIDMemoryCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) void CS_EnableEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Enable Memory entry failed, invalid Entry ID: %%d, State: %%d, Max ID: %%d"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_STATE_EMPTY; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_EMPTY; /* Execute the function being tested */ CS_EnableEntryIDMemoryCmd(&CmdPacket); @@ -662,9 +669,9 @@ void CS_EnableEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty(void) void CS_EnableEntryIDMemoryCmd_Test_OneShot(void) { - CS_EntryCmd_t CmdPacket; + CS_EnableEntryIDMemoryCmd_t CmdPacket; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + memset(&CmdPacket, 0, sizeof(CmdPacket)); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ @@ -681,30 +688,33 @@ void CS_EnableEntryIDMemoryCmd_Test_OneShot(void) void CS_DisableEntryIDMemoryCmd_Test_Nominal(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_EepromMemory_Table_Entry_t *DefMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].DefAddr; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of Memory Entry ID %%d is Disabled"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = 99; - CS_AppData.DefMemoryTblPtr[CmdPacket.Payload.EntryID].State = 99; + ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; + DefMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_Test_Setup_SetDefEntryState(DefMemoryTblPtr[CmdPacket.Payload.EntryID].State); /* Execute the function being tested */ CS_DisableEntryIDMemoryCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_DISABLED, - "CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_DISABLED"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0, - "CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0, - "CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0"); + UtAssert_True(ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_DISABLED, + "ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_DISABLED"); + UtAssert_True(ResMemoryTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0, + "ResMemoryTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0"); + UtAssert_True(ResMemoryTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0, + "ResMemoryTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_MEMORY_ENTRY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -713,8 +723,7 @@ void CS_DisableEntryIDMemoryCmd_Test_Nominal(void) UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - UtAssert_True(CS_AppData.DefMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_DISABLED, - "CS_AppData.DefMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_DISABLED"); + CS_Test_Check_SetDefEntryState(&DefMemoryTblPtr[CmdPacket.Payload.EntryID], CS_ChecksumState_DISABLED); UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 1, "CS_AppData.HkPacket.Payload.CmdCounter == 1"); @@ -726,10 +735,13 @@ void CS_DisableEntryIDMemoryCmd_Test_Nominal(void) void CS_DisableEntryIDMemoryCmd_Test_DefMemoryTblPtrStateEmpty(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_EepromMemory_Table_Entry_t *DefMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].DefAddr; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of Memory Entry ID %%d is Disabled"); @@ -738,21 +750,21 @@ void CS_DisableEntryIDMemoryCmd_Test_DefMemoryTblPtrStateEmpty(void) CmdPacket.Payload.EntryID = 1; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = 99; - CS_AppData.DefMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_STATE_EMPTY; + ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_ENABLED; + DefMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_EMPTY; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CS_Test_Setup_SetDefEntryState(DefMemoryTblPtr[CmdPacket.Payload.EntryID].State); /* Execute the function being tested */ CS_DisableEntryIDMemoryCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_DISABLED, - "CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_STATE_DISABLED"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0, - "CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0, - "CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0"); + UtAssert_True(ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_DISABLED, + "ResMemoryTblPtr[CmdPacket.Payload.EntryID].State == CS_ChecksumState_DISABLED"); + UtAssert_True(ResMemoryTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0, + "ResMemoryTblPtr[CmdPacket.Payload.EntryID].TempChecksumValue == 0"); + UtAssert_True(ResMemoryTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0, + "ResMemoryTblPtr[CmdPacket.Payload.EntryID].ByteOffset == 0"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_MEMORY_ENTRY_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -780,17 +792,16 @@ void CS_DisableEntryIDMemoryCmd_Test_DefMemoryTblPtrStateEmpty(void) void CS_DisableEntryIDMemoryCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Disable Memory entry failed, invalid Entry ID: %%d, State: %%d, Max ID: %%d"); CmdPacket.Payload.EntryID = CS_MAX_NUM_MEMORY_TABLE_ENTRIES; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); - /* Execute the function being tested */ CS_DisableEntryIDMemoryCmd(&CmdPacket); @@ -812,18 +823,18 @@ void CS_DisableEntryIDMemoryCmd_Test_InvalidEntryErrorEntryIDTooHigh(void) void CS_DisableEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty(void) { - CS_EntryCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Disable Memory entry failed, invalid Entry ID: %%d, State: %%d, Max ID: %%d"); CmdPacket.Payload.EntryID = 1; - CS_AppData.ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_STATE_EMPTY; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResMemoryTblPtr[CmdPacket.Payload.EntryID].State = CS_ChecksumState_EMPTY; /* Execute the function being tested */ CS_DisableEntryIDMemoryCmd(&CmdPacket); @@ -846,9 +857,9 @@ void CS_DisableEntryIDMemoryCmd_Test_InvalidEntryErrorStateEmpty(void) void CS_DisableEntryIDMemoryCmd_Test_OneShot(void) { - CS_EntryCmd_t CmdPacket; + CS_DisableEntryIDMemoryCmd_t CmdPacket; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + memset(&CmdPacket, 0, sizeof(CmdPacket)); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ @@ -865,20 +876,19 @@ void CS_DisableEntryIDMemoryCmd_Test_OneShot(void) void CS_GetEntryIDMemoryCmd_Test_Nominal(void) { - CS_GetEntryIDCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_GetEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Memory Found Address 0x%%08X in Entry ID %%d"); int16 EntryID = 1; - CS_AppData.ResMemoryTblPtr[EntryID].StartAddress = 1; - CmdPacket.Payload.Address = 1; - CS_AppData.ResMemoryTblPtr[EntryID].NumBytesToChecksum = 0; - CS_AppData.ResMemoryTblPtr[EntryID].State = 99; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResMemoryTblPtr[EntryID].StartAddress = 1; + CmdPacket.Payload.Address = 1; + ResMemoryTblPtr[EntryID].NumBytesToChecksum = 10; + ResMemoryTblPtr[EntryID].State = CS_ChecksumState_ENABLED; /* Execute the function being tested */ CS_GetEntryIDMemoryCmd(&CmdPacket); @@ -901,15 +911,18 @@ void CS_GetEntryIDMemoryCmd_Test_Nominal(void) void CS_GetEntryIDMemoryCmd_Test_AddressNotFound(void) { - CS_GetEntryIDCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_GetEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Address 0x%%08X was not found in Memory table"); - CmdPacket.Payload.Address = 0xFFFFFFFF; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + CmdPacket.Payload.Address = 0xFFFFFFFF; + ResMemoryTblPtr[0].State = CS_ChecksumState_ENABLED; + ResMemoryTblPtr[0].StartAddress = 1; + ResMemoryTblPtr[0].NumBytesToChecksum = 10; /* Execute the function being tested */ CS_GetEntryIDMemoryCmd(&CmdPacket); @@ -932,20 +945,20 @@ void CS_GetEntryIDMemoryCmd_Test_AddressNotFound(void) void CS_GetEntryIDMemoryCmd_Test_AddressPtr(void) { - CS_GetEntryIDCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_GetEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Address 0x%%08X was not found in Memory table"); int16 EntryID = 1; - CS_AppData.ResMemoryTblPtr[EntryID].StartAddress = 2; - CmdPacket.Payload.Address = 1; - CS_AppData.ResMemoryTblPtr[EntryID].NumBytesToChecksum = 0; - CS_AppData.ResMemoryTblPtr[EntryID].State = 99; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResMemoryTblPtr[EntryID].StartAddress = 12; + CmdPacket.Payload.Address = 1; + ResMemoryTblPtr[EntryID].NumBytesToChecksum = 10; + ResMemoryTblPtr[EntryID].State = CS_ChecksumState_ENABLED; /* Execute the function being tested */ CS_GetEntryIDMemoryCmd(&CmdPacket); @@ -968,20 +981,20 @@ void CS_GetEntryIDMemoryCmd_Test_AddressPtr(void) void CS_GetEntryIDMemoryCmd_Test_State(void) { - CS_GetEntryIDCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_GetEntryIDMemoryCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE].ResAddr; + memset(&CmdPacket, 0, sizeof(CmdPacket)); snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Address 0x%%08X was not found in Memory table"); int16 EntryID = 1; - CS_AppData.ResMemoryTblPtr[EntryID].StartAddress = 1; - CmdPacket.Payload.Address = 1; - CS_AppData.ResMemoryTblPtr[EntryID].NumBytesToChecksum = 0; - CS_AppData.ResMemoryTblPtr[EntryID].State = CS_STATE_EMPTY; - - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); + ResMemoryTblPtr[EntryID].StartAddress = 1; + CmdPacket.Payload.Address = 1; + ResMemoryTblPtr[EntryID].NumBytesToChecksum = 10; + ResMemoryTblPtr[EntryID].State = CS_ChecksumState_EMPTY; /* Execute the function being tested */ CS_GetEntryIDMemoryCmd(&CmdPacket); diff --git a/unit-test/cs_table_cmds_tests.c b/unit-test/cs_table_cmds_tests.c index eb11657..835ff14 100644 --- a/unit-test/cs_table_cmds_tests.c +++ b/unit-test/cs_table_cmds_tests.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -24,7 +23,7 @@ #include "cs_table_cmds.h" #include "cs_msg.h" #include "cs_msgdefs.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_version.h" #include "cs_utils.h" #include "cs_test_utils.h" @@ -78,21 +77,20 @@ void CS_APP_CMDS_TEST_CS_GetTableDefTblEntryByNameHandler1(void *UserObj, UT_Ent void CS_DisableTablesCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableTablesCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of Tables is Disabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); /* Execute the function being tested */ CS_DisableTablesCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == CS_STATE_DISABLED, - "CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_DISABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == CS_ChecksumState_DISABLED, + "CS_AppData.HkPacket.Payload.TablesCSState = CS_ChecksumState_DISABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_TABLES_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -111,9 +109,8 @@ void CS_DisableTablesCmd_Test(void) void CS_DisableTablesCmd_Test_OneShot(void) { - CS_NoArgsCmd_t CmdPacket; + CS_DisableTablesCmd_t CmdPacket; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ @@ -130,21 +127,20 @@ void CS_DisableTablesCmd_Test_OneShot(void) void CS_EnableTablesCmd_Test(void) { - CS_NoArgsCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableTablesCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of Tables is Enabled"); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); /* Execute the function being tested */ CS_EnableTablesCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == CS_STATE_ENABLED, - "CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_ENABLED"); + UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == CS_ChecksumState_ENABLED, + "CS_AppData.HkPacket.Payload.TablesCSState = CS_ChecksumState_ENABLED"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_ENABLE_TABLES_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -163,9 +159,8 @@ void CS_EnableTablesCmd_Test(void) void CS_EnableTablesCmd_Test_OneShot(void) { - CS_NoArgsCmd_t CmdPacket; + CS_EnableTablesCmd_t CmdPacket; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ @@ -180,33 +175,33 @@ void CS_EnableTablesCmd_Test_OneShot(void) call_count_CFE_EVS_SendEvent); } -void CS_ReportBaselineTablesCmd_Test_Computed(void) +void CS_ReportBaselineTableCmd_Test_Computed(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_Tables_Table_Entry_t *ResTablesTblPtr = CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].ResAddr; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Report baseline of table %%s is 0x%%08X"); - CS_AppData.ResTablesTblPtr[0].ComputedYet = true; - CS_AppData.ResTablesTblPtr[0].ComparisonValue = 1; + ResTablesTblPtr[0].ComputedYet = true; + ResTablesTblPtr[0].ComparisonValue = 1; - strncpy(CS_AppData.ResTablesTblPtr[0].Name, "name", 10); + strncpy(ResTablesTblPtr[0].Name, "name", 10); strncpy(CmdPacket.Payload.Name, "name", 10); - CS_AppData.ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ + ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetHandlerFunction(UT_KEY(CS_GetTableResTblEntryByName), CS_APP_CMDS_TEST_CS_GetTableResTblEntryByNameHandler1, NULL); UT_SetDeferredRetcode(UT_KEY(CS_GetTableResTblEntryByName), 1, true); /* Execute the function being tested */ - CS_ReportBaselineTablesCmd(&CmdPacket); + CS_ReportBaselineTableCmd(&CmdPacket); /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_BASELINE_TABLES_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_BASELINE_TABLE_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); @@ -221,33 +216,33 @@ void CS_ReportBaselineTablesCmd_Test_Computed(void) call_count_CFE_EVS_SendEvent); } -void CS_ReportBaselineTablesCmd_Test_NotYetComputed(void) +void CS_ReportBaselineTableCmd_Test_NotYetComputed(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_Tables_Table_Entry_t *ResTablesTblPtr = CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].ResAddr; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Report baseline of table %%s has not been computed yet"); - CS_AppData.ResTablesTblPtr[0].ComputedYet = false; + ResTablesTblPtr[0].ComputedYet = false; - strncpy(CS_AppData.ResTablesTblPtr[0].Name, "name", 10); + strncpy(ResTablesTblPtr[0].Name, "name", 10); strncpy(CmdPacket.Payload.Name, "name", 10); - CS_AppData.ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ + ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetHandlerFunction(UT_KEY(CS_GetTableResTblEntryByName), CS_APP_CMDS_TEST_CS_GetTableResTblEntryByNameHandler2, NULL); UT_SetDeferredRetcode(UT_KEY(CS_GetTableResTblEntryByName), 1, true); /* Execute the function being tested */ - CS_ReportBaselineTablesCmd(&CmdPacket); + CS_ReportBaselineTableCmd(&CmdPacket); /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_NO_BASELINE_TABLES_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_NO_BASELINE_TABLE_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); @@ -262,23 +257,23 @@ void CS_ReportBaselineTablesCmd_Test_NotYetComputed(void) call_count_CFE_EVS_SendEvent); } -void CS_ReportBaselineTablesCmd_Test_TableNotFound(void) +void CS_ReportBaselineTableCmd_Test_TableNotFound(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_ReportBaselineTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_Tables_Table_Entry_t *ResTablesTblPtr = CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].ResAddr; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Tables report baseline failed, table %%s not found"); - strncpy(CS_AppData.ResTablesTblPtr[0].Name, "name1", 10); + strncpy(ResTablesTblPtr[0].Name, "name1", 10); strncpy(CmdPacket.Payload.Name, "name2", 10); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_GetTableResTblEntryByName), 1, false); /* Execute the function being tested */ - CS_ReportBaselineTablesCmd(&CmdPacket); + CS_ReportBaselineTableCmd(&CmdPacket); /* Verify results */ @@ -297,33 +292,36 @@ void CS_ReportBaselineTablesCmd_Test_TableNotFound(void) call_count_CFE_EVS_SendEvent); } -void CS_RecomputeBaselineTablesCmd_Test_Nominal(void) +void CS_RecomputeBaselineTableCmd_Test_Nominal(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_Tables_Table_Entry_t * ResTablesTblPtr = CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].ResAddr; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute baseline of table %%s started"); - strncpy(CS_AppData.ResTablesTblPtr[0].Name, "name", 10); + strncpy(ResTablesTblPtr[0].Name, "name", 10); strncpy(CmdPacket.Payload.Name, "name", 10); - CS_AppData.ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ + ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); UT_SetHandlerFunction(UT_KEY(CS_GetTableResTblEntryByName), CS_APP_CMDS_TEST_CS_GetTableResTblEntryByNameHandler1, NULL); UT_SetDeferredRetcode(UT_KEY(CS_GetTableResTblEntryByName), 1, true); /* Execute the function being tested */ - CS_RecomputeBaselineTablesCmd(&CmdPacket); + CS_RecomputeBaselineTableCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == true, "CS_AppData.HkPacket.Payload.RecomputeInProgress == true"); - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == true, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == true"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, + "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); - UtAssert_True(CS_AppData.ChildTaskTable == CS_TABLES_TABLE, "CS_AppData.ChildTaskTable == CS_TABLES_TABLE"); + UtAssert_True(CS_AppData.ChildTaskTable == CS_ChecksumType_TABLES_TABLE, + "CS_AppData.ChildTaskTable == CS_ChecksumType_TABLES_TABLE"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_TABLES_STARTED_DBG_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_DEBUG); @@ -340,36 +338,38 @@ void CS_RecomputeBaselineTablesCmd_Test_Nominal(void) call_count_CFE_EVS_SendEvent); } -void CS_RecomputeBaselineTablesCmd_Test_CreateChildTaskError(void) +void CS_RecomputeBaselineTableCmd_Test_CreateChildTaskError(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_Tables_Table_Entry_t * ResTablesTblPtr = CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].ResAddr; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Recompute baseline of table %%s failed, CFE_ES_CreateChildTask returned: 0x%%08X"); - strncpy(CS_AppData.ResTablesTblPtr[0].Name, "name", 10); + strncpy(ResTablesTblPtr[0].Name, "name", 10); strncpy(CmdPacket.Payload.Name, "name", 10); - CS_AppData.ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ + ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ /* Set to generate error message CS_RECOMPUTE_TABLES_CREATE_CHDTASK_ERR_EID */ UT_SetDeferredRetcode(UT_KEY(CFE_ES_CreateChildTask), 1, -1); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); UT_SetHandlerFunction(UT_KEY(CS_GetTableResTblEntryByName), CS_APP_CMDS_TEST_CS_GetTableResTblEntryByNameHandler1, NULL); UT_SetDeferredRetcode(UT_KEY(CS_GetTableResTblEntryByName), 1, true); /* Execute the function being tested */ - CS_RecomputeBaselineTablesCmd(&CmdPacket); + CS_RecomputeBaselineTableCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.OneShotInProgress == false, + "CS_AppData.HkPacket.Payload.OneShotInProgress == false"); - UtAssert_True(CS_AppData.ChildTaskTable == CS_TABLES_TABLE, "CS_AppData.ChildTaskTable == CS_TABLES_TABLE"); + UtAssert_True(CS_AppData.ChildTaskTable == CS_ChecksumType_TABLES_TABLE, + "CS_AppData.ChildTaskTable == CS_ChecksumType_TABLES_TABLE"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_TABLES_CREATE_CHDTASK_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); @@ -380,7 +380,8 @@ void CS_RecomputeBaselineTablesCmd_Test_CreateChildTaskError(void) UtAssert_True(CS_AppData.HkPacket.Payload.CmdErrCounter == 1, "CS_AppData.HkPacket.Payload.CmdErrCounter == 1"); - UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); + UtAssert_True(CS_AppData.HkPacket.Payload.RecomputeInProgress == false, + "CS_AppData.HkPacket.Payload.RecomputeInProgress == false"); call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); @@ -388,22 +389,21 @@ void CS_RecomputeBaselineTablesCmd_Test_CreateChildTaskError(void) call_count_CFE_EVS_SendEvent); } -void CS_RecomputeBaselineTablesCmd_Test_TableNotFound(void) +void CS_RecomputeBaselineTableCmd_Test_TableNotFound(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Tables recompute baseline failed, table %%s not found"); strncpy(CmdPacket.Payload.Name, "name", 10); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); /* Execute the function being tested */ - CS_RecomputeBaselineTablesCmd(&CmdPacket); + CS_RecomputeBaselineTableCmd(&CmdPacket); /* Verify results */ @@ -422,11 +422,11 @@ void CS_RecomputeBaselineTablesCmd_Test_TableNotFound(void) call_count_CFE_EVS_SendEvent); } -void CS_RecomputeBaselineTablesCmd_Test_RecomputeInProgress(void) +void CS_RecomputeBaselineTableCmd_Test_RecomputeInProgress(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Tables recompute baseline for table %%s failed: child task in use"); @@ -435,11 +435,10 @@ void CS_RecomputeBaselineTablesCmd_Test_RecomputeInProgress(void) CS_AppData.HkPacket.Payload.RecomputeInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); /* Execute the function being tested */ - CS_RecomputeBaselineTablesCmd(&CmdPacket); + CS_RecomputeBaselineTableCmd(&CmdPacket); /* Verify results */ @@ -458,11 +457,11 @@ void CS_RecomputeBaselineTablesCmd_Test_RecomputeInProgress(void) call_count_CFE_EVS_SendEvent); } -void CS_RecomputeBaselineTablesCmd_Test_OneShot(void) +void CS_RecomputeBaselineTableCmd_Test_OneShot(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_RecomputeBaselineTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Tables recompute baseline for table %%s failed: child task in use"); @@ -472,11 +471,10 @@ void CS_RecomputeBaselineTablesCmd_Test_OneShot(void) CS_AppData.HkPacket.Payload.RecomputeInProgress = false; CS_AppData.HkPacket.Payload.OneShotInProgress = true; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); /* Execute the function being tested */ - CS_RecomputeBaselineTablesCmd(&CmdPacket); + CS_RecomputeBaselineTableCmd(&CmdPacket); /* Verify results */ UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_RECOMPUTE_TABLES_CHDTASK_ERR_EID); @@ -494,24 +492,25 @@ void CS_RecomputeBaselineTablesCmd_Test_OneShot(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableNameTablesCmd_Test_Nominal(void) +void CS_DisableNameTableCmd_Test_Nominal(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableNameTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_Tables_Table_Entry_t *DefTablesTblPtr = CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].DefAddr; + CS_Res_Tables_Table_Entry_t *ResTablesTblPtr = CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].ResAddr; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of table %%s is Disabled"); - strncpy(CS_AppData.ResTablesTblPtr[0].Name, "name", 10); + strncpy(ResTablesTblPtr[0].Name, "name", 10); strncpy(CmdPacket.Payload.Name, "name", 10); - CS_AppData.ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ + ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "name", 10); + strncpy(DefTablesTblPtr[0].Name, "name", 10); - CS_AppData.DefTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableDefTblEntryByName return correct results */ + DefTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableDefTblEntryByName return correct results */ - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); UT_SetHandlerFunction(UT_KEY(CS_GetTableResTblEntryByName), CS_APP_CMDS_TEST_CS_GetTableResTblEntryByNameHandler1, NULL); @@ -521,12 +520,11 @@ void CS_DisableNameTablesCmd_Test_Nominal(void) UT_SetDeferredRetcode(UT_KEY(CS_GetTableDefTblEntryByName), 1, true); /* Execute the function being tested */ - CS_DisableNameTablesCmd(&CmdPacket); + CS_DisableNameTableCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ByteOffset == 0, "CS_AppData.ResTablesTblPtr[0].ByteOffset == 0"); + UtAssert_True(ResTablesTblPtr[0].TempChecksumValue == 0, "ResTablesTblPtr[0].TempChecksumValue == 0"); + UtAssert_True(ResTablesTblPtr[0].ByteOffset == 0, "ResTablesTblPtr[0].ByteOffset == 0"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_TABLES_NAME_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -543,23 +541,23 @@ void CS_DisableNameTablesCmd_Test_Nominal(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableNameTablesCmd_Test_TableDefNotFound(void) +void CS_DisableNameTableCmd_Test_TableDefNotFound(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableNameTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_Tables_Table_Entry_t *ResTablesTblPtr = CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].ResAddr; snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of table %%s is Disabled"); snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "CS unable to update tables definition table for entry %%s"); - strncpy(CS_AppData.ResTablesTblPtr[0].Name, "name", 10); + strncpy(ResTablesTblPtr[0].Name, "name", 10); strncpy(CmdPacket.Payload.Name, "name", 10); - CS_AppData.ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ + ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); UT_SetHandlerFunction(UT_KEY(CS_GetTableResTblEntryByName), CS_APP_CMDS_TEST_CS_GetTableResTblEntryByNameHandler1, NULL); @@ -567,12 +565,11 @@ void CS_DisableNameTablesCmd_Test_TableDefNotFound(void) UT_SetDeferredRetcode(UT_KEY(CS_GetTableDefTblEntryByName), 1, false); /* Execute the function being tested */ - CS_DisableNameTablesCmd(&CmdPacket); + CS_DisableNameTableCmd(&CmdPacket); /* Verify results */ - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ByteOffset == 0, "CS_AppData.ResTablesTblPtr[0].ByteOffset == 0"); + UtAssert_True(ResTablesTblPtr[0].TempChecksumValue == 0, "ResTablesTblPtr[0].TempChecksumValue == 0"); + UtAssert_True(ResTablesTblPtr[0].ByteOffset == 0, "ResTablesTblPtr[0].ByteOffset == 0"); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_DISABLE_TABLES_NAME_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); @@ -598,23 +595,22 @@ void CS_DisableNameTablesCmd_Test_TableDefNotFound(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableNameTablesCmd_Test_TableNotFound(void) +void CS_DisableNameTableCmd_Test_TableNotFound(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_DisableNameTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Tables disable table command failed, table %%s not found"); strncpy(CmdPacket.Payload.Name, "name", 10); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); UT_SetDeferredRetcode(UT_KEY(CS_GetTableResTblEntryByName), 1, false); /* Execute the function being tested */ - CS_DisableNameTablesCmd(&CmdPacket); + CS_DisableNameTableCmd(&CmdPacket); /* Verify results */ @@ -633,15 +629,14 @@ void CS_DisableNameTablesCmd_Test_TableNotFound(void) call_count_CFE_EVS_SendEvent); } -void CS_DisableNameTablesCmd_Test_OneShot(void) +void CS_DisableNameTableCmd_Test_OneShot(void) { - CS_TableNameCmd_t CmdPacket; + CS_DisableNameTableCmd_t CmdPacket; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ - CS_DisableNameTablesCmd(&CmdPacket); + CS_DisableNameTableCmd(&CmdPacket); /* Verify results */ UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 0, "CS_AppData.HkPacket.Payload.CmdCounter == 0"); @@ -652,24 +647,25 @@ void CS_DisableNameTablesCmd_Test_OneShot(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableNameTablesCmd_Test_Nominal(void) +void CS_EnableNameTableCmd_Test_Nominal(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableNameTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Def_Tables_Table_Entry_t *DefTablesTblPtr = CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].DefAddr; + CS_Res_Tables_Table_Entry_t *ResTablesTblPtr = CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].ResAddr; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of table %%s is Enabled"); - strncpy(CS_AppData.ResTablesTblPtr[0].Name, "name", 10); + strncpy(ResTablesTblPtr[0].Name, "name", 10); strncpy(CmdPacket.Payload.Name, "name", 10); - CS_AppData.ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ + ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "name", 10); + strncpy(DefTablesTblPtr[0].Name, "name", 10); - CS_AppData.DefTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableDefTblEntryByName return correct results */ + DefTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableDefTblEntryByName return correct results */ - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); UT_SetHandlerFunction(UT_KEY(CS_GetTableResTblEntryByName), CS_APP_CMDS_TEST_CS_GetTableResTblEntryByNameHandler1, NULL); @@ -679,7 +675,7 @@ void CS_EnableNameTablesCmd_Test_Nominal(void) UT_SetDeferredRetcode(UT_KEY(CS_GetTableDefTblEntryByName), 1, true); /* Execute the function being tested */ - CS_EnableNameTablesCmd(&CmdPacket); + CS_EnableNameTableCmd(&CmdPacket); /* Verify results */ @@ -698,23 +694,23 @@ void CS_EnableNameTablesCmd_Test_Nominal(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableNameTablesCmd_Test_TableDefNotFound(void) +void CS_EnableNameTableCmd_Test_TableDefNotFound(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableNameTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_Res_Tables_Table_Entry_t *ResTablesTblPtr = CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE].ResAddr; snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Checksumming of table %%s is Enabled"); snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "CS unable to update tables definition table for entry %%s"); - strncpy(CS_AppData.ResTablesTblPtr[0].Name, "name", 10); + strncpy(ResTablesTblPtr[0].Name, "name", 10); strncpy(CmdPacket.Payload.Name, "name", 10); - CS_AppData.ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ + ResTablesTblPtr[0].State = 99; /* Needed to make CS_GetTableResTblEntryByName return correct results */ - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); UT_SetHandlerFunction(UT_KEY(CS_GetTableResTblEntryByName), CS_APP_CMDS_TEST_CS_GetTableResTblEntryByNameHandler1, NULL); @@ -722,7 +718,7 @@ void CS_EnableNameTablesCmd_Test_TableDefNotFound(void) UT_SetDeferredRetcode(UT_KEY(CS_GetTableDefTblEntryByName), 1, false); /* Execute the function being tested */ - CS_EnableNameTablesCmd(&CmdPacket); + CS_EnableNameTableCmd(&CmdPacket); /* Verify results */ @@ -750,23 +746,22 @@ void CS_EnableNameTablesCmd_Test_TableDefNotFound(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableNameTablesCmd_Test_TableNotFound(void) +void CS_EnableNameTableCmd_Test_TableNotFound(void) { - CS_TableNameCmd_t CmdPacket; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + CS_EnableNameTableCmd_t CmdPacket; + int32 strCmpResult; + char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "Tables enable table command failed, table %%s not found"); strncpy(CmdPacket.Payload.Name, "name", 10); - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, false); UT_SetDeferredRetcode(UT_KEY(CS_GetTableResTblEntryByName), 1, false); /* Execute the function being tested */ - CS_EnableNameTablesCmd(&CmdPacket); + CS_EnableNameTableCmd(&CmdPacket); /* Verify results */ @@ -785,15 +780,14 @@ void CS_EnableNameTablesCmd_Test_TableNotFound(void) call_count_CFE_EVS_SendEvent); } -void CS_EnableNameTablesCmd_Test_OneShot(void) +void CS_EnableNameTableCmd_Test_OneShot(void) { - CS_TableNameCmd_t CmdPacket; + CS_EnableNameTableCmd_t CmdPacket; - UT_SetDeferredRetcode(UT_KEY(CS_VerifyCmdLength), 1, true); UT_SetDeferredRetcode(UT_KEY(CS_CheckRecomputeOneshot), 1, true); /* Execute the function being tested */ - CS_EnableNameTablesCmd(&CmdPacket); + CS_EnableNameTableCmd(&CmdPacket); /* Verify results */ UtAssert_True(CS_AppData.HkPacket.Payload.CmdCounter == 0, "CS_AppData.HkPacket.Payload.CmdCounter == 0"); @@ -812,39 +806,39 @@ void UtTest_Setup(void) UtTest_Add(CS_EnableTablesCmd_Test, CS_Test_Setup, CS_Test_TearDown, "CS_EnableTablesCmd_Test"); UtTest_Add(CS_EnableTablesCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, "CS_EnableTablesCmd_Test_OneShot"); - UtTest_Add(CS_ReportBaselineTablesCmd_Test_Computed, CS_Test_Setup, CS_Test_TearDown, - "CS_ReportBaselineTablesCmd_Test_Computed"); - UtTest_Add(CS_ReportBaselineTablesCmd_Test_NotYetComputed, CS_Test_Setup, CS_Test_TearDown, - "CS_ReportBaselineTablesCmd_Test_NotYetComputed"); - UtTest_Add(CS_ReportBaselineTablesCmd_Test_TableNotFound, CS_Test_Setup, CS_Test_TearDown, - "CS_ReportBaselineTablesCmd_Test_TableNotFound"); - - UtTest_Add(CS_RecomputeBaselineTablesCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, - "CS_RecomputeBaselineTablesCmd_Test_Nominal"); - UtTest_Add(CS_RecomputeBaselineTablesCmd_Test_CreateChildTaskError, CS_Test_Setup, CS_Test_TearDown, - "CS_RecomputeBaselineTablesCmd_Test_CreateChildTaskError"); - UtTest_Add(CS_RecomputeBaselineTablesCmd_Test_TableNotFound, CS_Test_Setup, CS_Test_TearDown, - "CS_RecomputeBaselineTablesCmd_Test_TableNotFound"); - UtTest_Add(CS_RecomputeBaselineTablesCmd_Test_RecomputeInProgress, CS_Test_Setup, CS_Test_TearDown, - "CS_RecomputeBaselineTablesCmd_Test_RecomputeInProgress"); - UtTest_Add(CS_RecomputeBaselineTablesCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, - "CS_RecomputeBaselineTablesCmd_Test_OneShot"); - - UtTest_Add(CS_DisableNameTablesCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableNameTablesCmd_Test_Nominal"); - UtTest_Add(CS_DisableNameTablesCmd_Test_TableDefNotFound, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableNameTablesCmd_Test_TableDefNotFound"); - UtTest_Add(CS_DisableNameTablesCmd_Test_TableNotFound, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableNameTablesCmd_Test_TableNotFound"); - UtTest_Add(CS_DisableNameTablesCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, - "CS_DisableNameTablesCmd_Test_OneShot"); - - UtTest_Add(CS_EnableNameTablesCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableNameTablesCmd_Test_Nominal"); - UtTest_Add(CS_EnableNameTablesCmd_Test_TableDefNotFound, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableNameTablesCmd_Test_TableDefNotFound"); - UtTest_Add(CS_EnableNameTablesCmd_Test_TableNotFound, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableNameTablesCmd_Test_TableNotFound"); - UtTest_Add(CS_EnableNameTablesCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, - "CS_EnableNameTablesCmd_Test_OneShot"); + UtTest_Add(CS_ReportBaselineTableCmd_Test_Computed, CS_Test_Setup, CS_Test_TearDown, + "CS_ReportBaselineTableCmd_Test_Computed"); + UtTest_Add(CS_ReportBaselineTableCmd_Test_NotYetComputed, CS_Test_Setup, CS_Test_TearDown, + "CS_ReportBaselineTableCmd_Test_NotYetComputed"); + UtTest_Add(CS_ReportBaselineTableCmd_Test_TableNotFound, CS_Test_Setup, CS_Test_TearDown, + "CS_ReportBaselineTableCmd_Test_TableNotFound"); + + UtTest_Add(CS_RecomputeBaselineTableCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, + "CS_RecomputeBaselineTableCmd_Test_Nominal"); + UtTest_Add(CS_RecomputeBaselineTableCmd_Test_CreateChildTaskError, CS_Test_Setup, CS_Test_TearDown, + "CS_RecomputeBaselineTableCmd_Test_CreateChildTaskError"); + UtTest_Add(CS_RecomputeBaselineTableCmd_Test_TableNotFound, CS_Test_Setup, CS_Test_TearDown, + "CS_RecomputeBaselineTableCmd_Test_TableNotFound"); + UtTest_Add(CS_RecomputeBaselineTableCmd_Test_RecomputeInProgress, CS_Test_Setup, CS_Test_TearDown, + "CS_RecomputeBaselineTableCmd_Test_RecomputeInProgress"); + UtTest_Add(CS_RecomputeBaselineTableCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, + "CS_RecomputeBaselineTableCmd_Test_OneShot"); + + UtTest_Add(CS_DisableNameTableCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, + "CS_DisableNameTableCmd_Test_Nominal"); + UtTest_Add(CS_DisableNameTableCmd_Test_TableDefNotFound, CS_Test_Setup, CS_Test_TearDown, + "CS_DisableNameTableCmd_Test_TableDefNotFound"); + UtTest_Add(CS_DisableNameTableCmd_Test_TableNotFound, CS_Test_Setup, CS_Test_TearDown, + "CS_DisableNameTableCmd_Test_TableNotFound"); + UtTest_Add(CS_DisableNameTableCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, + "CS_DisableNameTableCmd_Test_OneShot"); + + UtTest_Add(CS_EnableNameTableCmd_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, + "CS_EnableNameTableCmd_Test_Nominal"); + UtTest_Add(CS_EnableNameTableCmd_Test_TableDefNotFound, CS_Test_Setup, CS_Test_TearDown, + "CS_EnableNameTableCmd_Test_TableDefNotFound"); + UtTest_Add(CS_EnableNameTableCmd_Test_TableNotFound, CS_Test_Setup, CS_Test_TearDown, + "CS_EnableNameTableCmd_Test_TableNotFound"); + UtTest_Add(CS_EnableNameTableCmd_Test_OneShot, CS_Test_Setup, CS_Test_TearDown, + "CS_EnableNameTableCmd_Test_OneShot"); } diff --git a/unit-test/cs_table_processing_tests.c b/unit-test/cs_table_processing_tests.c index 3d1a3fa..dd95f92 100644 --- a/unit-test/cs_table_processing_tests.c +++ b/unit-test/cs_table_processing_tests.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -23,7 +22,7 @@ #include "cs_msg.h" #include "cs_msgdefs.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_version.h" #include "cs_utils.h" #include "cs_test_utils.h" @@ -35,6 +34,8 @@ #include "utassert.h" #include "utstubs.h" +#define CS_UT_TABLE_HANDLE(x) CFE_TBL_HandleFromID(CFE_TBL_HANDLEID_C(CFE_ResourceId_FromInteger(x))) + /* cs_table_processing_tests globals */ uint8 call_count_CFE_EVS_SendEvent; @@ -62,3255 +63,603 @@ CFE_Status_t CS_TABLE_PROCESSING_TEST_CFE_TBL_LoadHook(void *UserObj, int32 Stub return CFE_SUCCESS; } -void CS_ValidateEepromChecksumDefinitionTable_Test_Nominal(void) +void Test_CS_ValidateEepromChecksumDefinitionTable(void) { - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS EEPROM Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefEepromTblPtr[0].State = CS_STATE_ENABLED; /* All other states are empty by default, and so this test - also covers CS_STATE_EMPTY branch */ - - /* Execute the function being tested */ - Result = CS_ValidateEepromChecksumDefinitionTable(CS_AppData.DefEepromTblPtr); + /* Test case for: + * CFE_Status_t CS_ValidateEepromChecksumDefinitionTable(void *TblPtr); + */ - /* Verify results */ + /* Nominal, enabled + disabled, rest empty */ + CS_AppData.DefaultEepromDefTable[0].State = CS_ChecksumState_ENABLED; + CS_AppData.DefaultEepromDefTable[1].State = CS_ChecksumState_DISABLED; + UtAssert_INT32_EQ(CS_ValidateEepromChecksumDefinitionTable(CS_AppData.DefaultEepromDefTable), CFE_SUCCESS); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_EEPROM_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateEepromChecksumDefinitionTable_Test_IllegalChecksumRangeStateEnabled(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "EEPROM Table Validate: Illegal checksum range found in Entry ID %%d, CFE_PSP_MemValidateRange returned: " - "0x%%08X"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS EEPROM Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefEepromTblPtr[0].State = CS_STATE_ENABLED; - - /* Set to generate error message CS_VAL_EEPROM_RANGE_ERR_EID */ - UT_SetDeferredRetcode(UT_KEY(CFE_PSP_MemValidateRange), 1, -1); - - /* Execute the function being tested */ - Result = CS_ValidateEepromChecksumDefinitionTable(CS_AppData.DefEepromTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_EEPROM_RANGE_ERR_EID); + /* Error in state */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultEepromDefTable[0].State = CS_ChecksumState_UNDEFINED; + CS_AppData.DefaultEepromDefTable[1].State = CS_ChecksumState_UNDEFINED; + UtAssert_INT32_EQ(CS_ValidateEepromChecksumDefinitionTable(CS_AppData.DefaultEepromDefTable), CS_TABLE_ERROR); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_EEPROM_STATE_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_EEPROM_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateEepromChecksumDefinitionTable_Test_IllegalChecksumRangeStateDisabled(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "EEPROM Table Validate: Illegal checksum range found in Entry ID %%d, CFE_PSP_MemValidateRange returned: " - "0x%%08X"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS EEPROM Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefEepromTblPtr[0].State = CS_STATE_DISABLED; - - /* Set to generate error message CS_VAL_EEPROM_RANGE_ERR_EID */ - UT_SetDeferredRetcode(UT_KEY(CFE_PSP_MemValidateRange), 1, -1); - - /* Execute the function being tested */ - Result = CS_ValidateEepromChecksumDefinitionTable(CS_AppData.DefEepromTblPtr); - - /* Verify results */ - + /* Error in range */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultEepromDefTable[0].State = CS_ChecksumState_ENABLED; + CS_AppData.DefaultEepromDefTable[1].State = CS_ChecksumState_DISABLED; + UT_SetDefaultReturnValue(UT_KEY(CFE_PSP_MemValidateRange), -1); + UtAssert_INT32_EQ(CS_ValidateEepromChecksumDefinitionTable(CS_AppData.DefaultEepromDefTable), CS_TABLE_ERROR); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_EEPROM_RANGE_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_EEPROM_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); } -void CS_ValidateEepromChecksumDefinitionTable_Test_IllegalStateField(void) +void Test_CS_ValidateMemoryChecksumDefinitionTable(void) { - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "EEPROM Table Validate: Illegal State Field (0x%%04X) found in Entry ID %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS EEPROM Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefEepromTblPtr[0].State = 0xFFFF; + /* Test case for: + * CFE_Status_t CS_ValidateMemoryChecksumDefinitionTable(void *TblPtr); + */ - /* Execute the function being tested */ - Result = CS_ValidateEepromChecksumDefinitionTable(CS_AppData.DefEepromTblPtr); - - /* Verify results */ + /* Nominal, enabled + disabled, rest empty */ + CS_AppData.DefaultMemoryDefTable[0].State = CS_ChecksumState_ENABLED; + CS_AppData.DefaultMemoryDefTable[1].State = CS_ChecksumState_DISABLED; + UtAssert_INT32_EQ(CS_ValidateMemoryChecksumDefinitionTable(CS_AppData.DefaultMemoryDefTable), CFE_SUCCESS); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_MEMORY_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_EEPROM_STATE_ERR_EID); + /* Error in state */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultMemoryDefTable[0].State = CS_ChecksumState_UNDEFINED; + CS_AppData.DefaultMemoryDefTable[1].State = CS_ChecksumState_UNDEFINED; + UtAssert_INT32_EQ(CS_ValidateMemoryChecksumDefinitionTable(CS_AppData.DefaultMemoryDefTable), CS_TABLE_ERROR); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_MEMORY_STATE_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_EEPROM_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateEepromChecksumDefinitionTable_Test_TableErrorResult(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "EEPROM Table Validate: Illegal checksum range found in Entry ID %%d, CFE_PSP_MemValidateRange returned: " - "0x%%08X"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS EEPROM Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefEepromTblPtr[0].State = CS_STATE_DISABLED; - CS_AppData.DefEepromTblPtr[1].State = CS_STATE_DISABLED; - - /* Set to generate error message CS_VAL_EEPROM_RANGE_ERR_EID */ + /* Error in range */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultMemoryDefTable[0].State = CS_ChecksumState_ENABLED; + CS_AppData.DefaultMemoryDefTable[1].State = CS_ChecksumState_DISABLED; UT_SetDefaultReturnValue(UT_KEY(CFE_PSP_MemValidateRange), -1); - - /* Execute the function being tested */ - Result = CS_ValidateEepromChecksumDefinitionTable(CS_AppData.DefEepromTblPtr); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_EEPROM_RANGE_ERR_EID); + UtAssert_INT32_EQ(CS_ValidateMemoryChecksumDefinitionTable(CS_AppData.DefaultMemoryDefTable), CS_TABLE_ERROR); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_MEMORY_RANGE_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_EEPROM_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); } -void CS_ValidateEepromChecksumDefinitionTable_Test_UndefTableErrorResult(void) +void Test_CS_ValidateTablesChecksumDefinitionTable(void) { - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "EEPROM Table Validate: Illegal checksum range found in Entry ID %%d, CFE_PSP_MemValidateRange returned: " - "0x%%08X"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS EEPROM Table verification results: good = %%d, bad = %%d, unused = %%d"); + /* Test case for: + * CFE_Status_t CS_ValidateTablesChecksumDefinitionTable(void *TblPtr); + */ - CS_AppData.DefEepromTblPtr[0].State = CS_STATE_DISABLED; - CS_AppData.DefEepromTblPtr[1].State = CS_STATE_UNDEFINED; - - /* Set to generate error message CS_VAL_EEPROM_RANGE_ERR_EID */ - UT_SetDefaultReturnValue(UT_KEY(CFE_PSP_MemValidateRange), -1); - - /* Execute the function being tested */ - Result = CS_ValidateEepromChecksumDefinitionTable(CS_AppData.DefEepromTblPtr); + /* Nominal, enabled + disabled, rest empty */ + CS_AppData.DefaultTablesDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultTablesDefTable[0].Name, "UT0"); + CS_AppData.DefaultTablesDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultTablesDefTable[1].Name, "UT1"); + UtAssert_INT32_EQ(CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefaultTablesDefTable), CFE_SUCCESS); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_EEPROM_RANGE_ERR_EID); + /* Error in state */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultTablesDefTable[0].State = CS_ChecksumState_UNDEFINED; + CS_AppData.DefaultTablesDefTable[1].State = CS_ChecksumState_UNDEFINED; + UtAssert_INT32_EQ(CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefaultTablesDefTable), CS_TABLE_ERROR); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_STATE_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_EEPROM_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); + /* Error in name (zero) */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultTablesDefTable[0].State = CS_ChecksumState_ENABLED; + CS_AppData.DefaultTablesDefTable[0].Name[0] = 0; + CS_AppData.DefaultTablesDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultTablesDefTable[1].Name, "UT1"); + UtAssert_INT32_EQ(CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefaultTablesDefTable), CS_TABLE_ERROR); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_DEF_TBL_ZERO_NAME_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + /* Error in name (long) */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultTablesDefTable[0].State = CS_ChecksumState_ENABLED; + memset(CS_AppData.DefaultTablesDefTable[0].Name, 'x', sizeof(CS_AppData.DefaultTablesDefTable[0].Name)); + CS_AppData.DefaultTablesDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultTablesDefTable[1].Name, "UT1"); + UtAssert_INT32_EQ(CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefaultTablesDefTable), CS_TABLE_ERROR); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_DEF_TBL_LONG_NAME_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); + /* Error in name (duplicate) */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultTablesDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultTablesDefTable[0].Name, "UT1"); + CS_AppData.DefaultTablesDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultTablesDefTable[1].Name, "UT1"); + UtAssert_INT32_EQ(CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefaultTablesDefTable), CS_TABLE_ERROR); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_DEF_TBL_DUPL_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); } -void CS_ValidateMemoryChecksumDefinitionTable_Test_Nominal(void) +void Test_CS_ValidateAppChecksumDefinitionTable(void) { - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Memory Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefMemoryTblPtr[0].State = CS_STATE_ENABLED; /* All other states are empty by default, and so this test - also covers CS_STATE_EMPTY branch */ + /* Test case for: + * CFE_Status_t CS_ValidateAppChecksumDefinitionTable(void *TblPtr); + */ - /* Execute the function being tested */ - Result = CS_ValidateMemoryChecksumDefinitionTable(CS_AppData.DefMemoryTblPtr); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_MEMORY_INF_EID); + /* Nominal, enabled + disabled, rest empty */ + CS_AppData.DefaultAppDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultAppDefTable[0].Name, "UT0"); + CS_AppData.DefaultAppDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultAppDefTable[1].Name, "UT1"); + UtAssert_INT32_EQ(CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefaultAppDefTable), CFE_SUCCESS); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_INF_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); + /* Error in state */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultAppDefTable[0].State = CS_ChecksumState_UNDEFINED; + CS_AppData.DefaultAppDefTable[1].State = CS_ChecksumState_UNDEFINED; + UtAssert_INT32_EQ(CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefaultAppDefTable), CS_TABLE_ERROR); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_STATE_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + /* Error in name (zero) */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultAppDefTable[0].State = CS_ChecksumState_ENABLED; + CS_AppData.DefaultAppDefTable[0].Name[0] = 0; + CS_AppData.DefaultAppDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultAppDefTable[1].Name, "UT1"); + UtAssert_INT32_EQ(CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefaultAppDefTable), CS_TABLE_ERROR); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_DEF_TBL_ZERO_NAME_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + /* Error in name (long) */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultAppDefTable[0].State = CS_ChecksumState_ENABLED; + memset(CS_AppData.DefaultAppDefTable[0].Name, 'x', sizeof(CS_AppData.DefaultAppDefTable[0].Name)); + CS_AppData.DefaultAppDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultAppDefTable[1].Name, "UT1"); + UtAssert_INT32_EQ(CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefaultAppDefTable), CS_TABLE_ERROR); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_DEF_TBL_LONG_NAME_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); + /* Error in name (duplicate) */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultAppDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultAppDefTable[0].Name, "UT1"); + CS_AppData.DefaultAppDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultAppDefTable[1].Name, "UT1"); + UtAssert_INT32_EQ(CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefaultAppDefTable), CS_TABLE_ERROR); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_DEF_TBL_DUPL_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); } -void CS_ValidateMemoryChecksumDefinitionTable_Test_IllegalChecksumRangeStateEnabled(void) +void Test_CS_ProcessNewEepromMemoryDefinitionTable(void) { - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "Memory Table Validate: Illegal checksum range found in Entry ID %%d, CFE_PSP_MemValidateRange returned: " - "0x%%08X"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Memory Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefMemoryTblPtr[0].State = CS_STATE_ENABLED; - - /* Set to generate error message CS_VAL_MEMORY_RANGE_ERR_EID */ - UT_SetDeferredRetcode(UT_KEY(CFE_PSP_MemValidateRange), 1, -1); - - /* Execute the function being tested */ - Result = CS_ValidateMemoryChecksumDefinitionTable(CS_AppData.DefMemoryTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_MEMORY_RANGE_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); + /* Test case for: + * void CS_ProcessNewEepromMemoryDefinitionTable(CS_TableWrapper_t *tw); + */ + CS_TableWrapper_t *tw; - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_MEMORY_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); + /* path where all entries are empty */ + tw = &CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE]; + UtAssert_VOIDCALL(CS_ProcessNewEepromMemoryDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_EEPROM_MEMORY_NO_ENTRIES_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); + /* path where some entries not empty */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultEepromDefTable[0].State = CS_ChecksumState_ENABLED; + CS_AppData.DefaultEepromDefTable[1].State = CS_ChecksumState_DISABLED; + UtAssert_VOIDCALL(CS_ProcessNewEepromMemoryDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); + /* Where ResultsEntry is null */ + CS_Test_ResetEventCheck(); + UT_SetDeferredRetcode(UT_KEY(CS_GetResEntryAddr), 1, 0); + CS_AppData.DefaultEepromDefTable[0].State = CS_ChecksumState_ENABLED; + CS_AppData.DefaultEepromDefTable[1].State = CS_ChecksumState_DISABLED; + UtAssert_VOIDCALL(CS_ProcessNewEepromMemoryDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_EEPROM_MEMORY_NO_ENTRIES_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); + /* Where DefEntry is null */ + CS_Test_ResetEventCheck(); + UT_SetDeferredRetcode(UT_KEY(CS_GetDefEntryAddr), 1, 0); + CS_AppData.DefaultEepromDefTable[0].State = CS_ChecksumState_ENABLED; + CS_AppData.DefaultEepromDefTable[1].State = CS_ChecksumState_DISABLED; + UtAssert_VOIDCALL(CS_ProcessNewEepromMemoryDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_EEPROM_MEMORY_NO_ENTRIES_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + CS_Test_ResetEventCheck(); + CS_AppData.DefaultEepromDefTable[0].State = CS_ChecksumState_ENABLED; + CS_AppData.DefaultEepromDefTable[1].State = CS_ChecksumState_DISABLED; + UtAssert_VOIDCALL(CS_ProcessNewEepromMemoryDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); + /* exercise path where there is no global state */ + tw->GlobalState = NULL; + CS_Test_ResetEventCheck(); + UtAssert_VOIDCALL(CS_ProcessNewEepromMemoryDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } -void CS_ValidateMemoryChecksumDefinitionTable_Test_IllegalChecksumRangeStateDisabled(void) +void Test_CS_ProcessNewTablesDefinitionTable(void) { - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "Memory Table Validate: Illegal checksum range found in Entry ID %%d, CFE_PSP_MemValidateRange returned: " - "0x%%08X"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Memory Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefMemoryTblPtr[0].State = CS_STATE_DISABLED; - - /* Set to generate error message CS_VAL_MEMORY_RANGE_ERR_EID */ - UT_SetDeferredRetcode(UT_KEY(CFE_PSP_MemValidateRange), 1, -1); - - /* Execute the function being tested */ - Result = CS_ValidateMemoryChecksumDefinitionTable(CS_AppData.DefMemoryTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_MEMORY_RANGE_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); + /* Test case for: + * void CS_ProcessNewTablesDefinitionTable(CS_TableWrapper_t *tw); + */ - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); + CS_TableWrapper_t * tw; + CS_Res_Tables_Table_Entry_t *ResultsEntry; - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); + /* path where all entries are empty */ + tw = &CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE]; + UtAssert_VOIDCALL(CS_ProcessNewTablesDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_TABLES_NO_ENTRIES_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_MEMORY_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); + /* path where some entries not empty, table names only */ + ResultsEntry = tw->ResAddr; + CS_Test_ResetEventCheck(); + CS_AppData.DefaultTablesDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultTablesDefTable[0].Name, "UT0"); + CS_AppData.DefaultTablesDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultTablesDefTable[1].Name, "UT1"); + UtAssert_VOIDCALL(CS_ProcessNewTablesDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); + UtAssert_BOOL_FALSE(ResultsEntry->IsCSOwner); + + /* Where ResultsEntry is null */ + CS_Test_ResetEventCheck(); + UT_SetDeferredRetcode(UT_KEY(CS_GetResEntryAddr), 1, 0); + CS_AppData.DefaultTablesDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultTablesDefTable[0].Name, "UT0"); + CS_AppData.DefaultTablesDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultTablesDefTable[1].Name, "UT1"); + UtAssert_VOIDCALL(CS_ProcessNewTablesDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_TABLES_NO_ENTRIES_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); + /* Where DefEntry is null */ + CS_Test_ResetEventCheck(); + UT_SetDeferredRetcode(UT_KEY(CS_GetDefEntryAddr), 1, 0); + CS_AppData.DefaultTablesDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultTablesDefTable[0].Name, "UT0"); + CS_AppData.DefaultTablesDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultTablesDefTable[1].Name, "UT1"); + UtAssert_VOIDCALL(CS_ProcessNewTablesDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_TABLES_NO_ENTRIES_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); + /* path where some entries not empty, qualified table names */ + ResultsEntry = tw->ResAddr; + CS_Test_ResetEventCheck(); + CS_AppData.DefaultTablesDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultTablesDefTable[0].Name, "UT.UT0"); + CS_AppData.DefaultTablesDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultTablesDefTable[1].Name, "XY.UT1"); + UtAssert_VOIDCALL(CS_ProcessNewTablesDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); + UtAssert_BOOL_FALSE(ResultsEntry->IsCSOwner); + + /* path where some entries not empty, invalid table names */ + ResultsEntry = tw->ResAddr; + CS_Test_ResetEventCheck(); + CS_AppData.DefaultTablesDefTable[0].State = CS_ChecksumState_ENABLED; + memset(CS_AppData.DefaultTablesDefTable[0].Name, 'x', sizeof(CS_AppData.DefaultTablesDefTable[0].Name)); + CS_AppData.DefaultTablesDefTable[0].Name[sizeof(CS_AppData.DefaultTablesDefTable[0].Name) - 1] = '.'; + CS_AppData.DefaultTablesDefTable[1].State = CS_ChecksumState_DISABLED; + memset(CS_AppData.DefaultTablesDefTable[1].Name, 'y', sizeof(CS_AppData.DefaultTablesDefTable[1].Name)); + CS_AppData.DefaultTablesDefTable[1].Name[0] = '.'; + UtAssert_VOIDCALL(CS_ProcessNewTablesDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); + UtAssert_BOOL_FALSE(ResultsEntry->IsCSOwner); + + /* path where matches a CS Def table */ + UT_SetDeferredRetcode(UT_KEY(CS_CheckDefTableNameMatch), 1, true); + CS_AppData.DefaultTablesDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultTablesDefTable[0].Name, "UT.UT0"); + CS_AppData.DefaultTablesDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultTablesDefTable[1].Name, "XY.UT1"); + UtAssert_VOIDCALL(CS_ProcessNewTablesDefinitionTable(tw)); + UtAssert_BOOL_TRUE(ResultsEntry->IsCSOwner); + + /* path where matches a CS Res table */ + UT_SetDeferredRetcode(UT_KEY(CS_CheckResTableNameMatch), 1, true); + CS_AppData.DefaultTablesDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultTablesDefTable[0].Name, "UT.UT0"); + CS_AppData.DefaultTablesDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultTablesDefTable[1].Name, "XY.UT1"); + UtAssert_VOIDCALL(CS_ProcessNewTablesDefinitionTable(tw)); + UtAssert_BOOL_TRUE(ResultsEntry->IsCSOwner); +} + +void Test_CS_ProcessNewAppDefinitionTable(void) +{ + /* Test case for: + * void CS_ProcessNewAppDefinitionTable(CS_TableWrapper_t *tw); + */ + CS_TableWrapper_t *tw; + + /* path where all entries are empty */ + tw = &CS_AppData.Tbl[CS_ChecksumType_APP_TABLE]; + UtAssert_VOIDCALL(CS_ProcessNewAppDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_APP_NO_ENTRIES_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); + /* path where some entries not empty */ + CS_Test_ResetEventCheck(); + CS_AppData.DefaultAppDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultAppDefTable[0].Name, "UT0"); + CS_AppData.DefaultAppDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultAppDefTable[1].Name, "UT1"); + UtAssert_VOIDCALL(CS_ProcessNewAppDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + /* Where ResultsEntry is null */ + CS_Test_ResetEventCheck(); + UT_SetDeferredRetcode(UT_KEY(CS_GetResEntryAddr), 1, 0); + CS_AppData.DefaultAppDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultAppDefTable[0].Name, "UT0"); + CS_AppData.DefaultAppDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultAppDefTable[1].Name, "UT1"); + UtAssert_VOIDCALL(CS_ProcessNewAppDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_APP_NO_ENTRIES_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); + /* Where DefEntry is null */ + CS_Test_ResetEventCheck(); + UT_SetDeferredRetcode(UT_KEY(CS_GetDefEntryAddr), 1, 0); + CS_AppData.DefaultAppDefTable[0].State = CS_ChecksumState_ENABLED; + strcpy(CS_AppData.DefaultAppDefTable[0].Name, "UT0"); + CS_AppData.DefaultAppDefTable[1].State = CS_ChecksumState_DISABLED; + strcpy(CS_AppData.DefaultAppDefTable[1].Name, "UT1"); + UtAssert_VOIDCALL(CS_ProcessNewAppDefinitionTable(tw)); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_APP_NO_ENTRIES_INF_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); } -void CS_ValidateMemoryChecksumDefinitionTable_Test_IllegalStateField(void) +void Test_CS_TableInit(void) { - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "Memory Table Validate: Illegal State Field (0x%%04X) found in Entry ID %%d"); + /* Test case for: + * CFE_Status_t CS_TableInit(CS_TableWrapper_t *tw, const char *DefinitionTableFileName, CFE_TBL_CallbackFuncPtr_t + * CallBackFunction); + */ + CS_TableWrapper_t *tw = &CS_AppData.Tbl[CS_ChecksumType_APP_TABLE]; - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Memory Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefMemoryTblPtr[0].State = 0xFFFF; - - /* Execute the function being tested */ - Result = CS_ValidateMemoryChecksumDefinitionTable(CS_AppData.DefMemoryTblPtr); + /* nominal */ + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->ResAddr, sizeof(tw->ResAddr), false); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->DefAddr, sizeof(tw->DefAddr), false); + UtAssert_INT32_EQ(CS_TableInit(tw, "UT", NULL), CFE_SUCCESS); + UtAssert_STUB_COUNT(CFE_TBL_Register, 2); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); - /* Verify results */ + /* No filename */ + CS_Test_ResetEventCheck(); + UT_ResetState(UT_KEY(CFE_TBL_Register)); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->ResAddr, sizeof(tw->ResAddr), false); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->DefAddr, sizeof(tw->DefAddr), false); + UtAssert_INT32_EQ(CS_TableInit(tw, NULL, NULL), CFE_SUCCESS); + UtAssert_STUB_COUNT(CFE_TBL_Register, 0); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_MEMORY_STATE_ERR_EID); + /* failure to register result table */ + CS_Test_ResetEventCheck(); + UT_ResetState(UT_KEY(CFE_TBL_Register)); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Register), 1, -123); + UtAssert_INT32_EQ(CS_TableInit(tw, "UT", NULL), -123); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_MEMORY_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); + /* failure to register definition table */ + CS_Test_ResetEventCheck(); + UT_ResetState(UT_KEY(CFE_TBL_Register)); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->ResAddr, sizeof(tw->ResAddr), false); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Register), 2, -123); + UtAssert_INT32_EQ(CS_TableInit(tw, "UT", NULL), -123); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); + /* failure to get address result table */ + CS_Test_ResetEventCheck(); + UT_ResetState(UT_KEY(CFE_TBL_Register)); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 1, -123); + UtAssert_INT32_EQ(CS_TableInit(tw, "UT", NULL), -123); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); + /* failure to register definition table */ + CS_Test_ResetEventCheck(); + UT_ResetState(UT_KEY(CFE_TBL_Register)); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->ResAddr, sizeof(tw->ResAddr), false); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, -123); + UtAssert_INT32_EQ(CS_TableInit(tw, "UT", NULL), -123); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + /* failure to load definition table from file, but memory succeeds */ + CS_Test_ResetEventCheck(); + *tw->GlobalState = CS_ChecksumState_ENABLED; + UT_ResetState(UT_KEY(CFE_TBL_Register)); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->ResAddr, sizeof(tw->ResAddr), false); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->DefAddr, sizeof(tw->DefAddr), false); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Load), 1, -456); + UtAssert_INT32_EQ(CS_TableInit(tw, "UT", NULL), CFE_SUCCESS); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); + UtAssert_UINT8_EQ(*tw->GlobalState, CS_ChecksumState_DISABLED); + + /* same but when there is no global staste */ + CS_Test_ResetEventCheck(); + tw->GlobalState = NULL; + UT_ResetState(UT_KEY(CFE_TBL_Register)); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->ResAddr, sizeof(tw->ResAddr), false); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->DefAddr, sizeof(tw->DefAddr), false); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Load), 1, -456); + UtAssert_INT32_EQ(CS_TableInit(tw, "UT", NULL), CFE_SUCCESS); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); + /* failure to load definition table from anything */ + CS_Test_ResetEventCheck(); + UT_ResetState(UT_KEY(CFE_TBL_Register)); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->ResAddr, sizeof(tw->ResAddr), false); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->DefAddr, sizeof(tw->DefAddr), false); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Load), 1, -456); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Load), 1, -456); + UtAssert_INT32_EQ(CS_TableInit(tw, "UT", NULL), -456); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); } -void CS_ValidateMemoryChecksumDefinitionTable_Test_TableErrorResult(void) +void Test_CS_HandleTableUpdate(void) { - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; + /* Test case for: + * CFE_Status_t CS_HandleTableUpdate(CS_TableWrapper_t *tw); + */ + CS_Res_Tables_Table_Entry_t *ResultsEntry; + CS_TableWrapper_t * tw; - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "Memory Table Validate: Illegal checksum range found in Entry ID %%d, CFE_PSP_MemValidateRange returned: " - "0x%%08X"); + tw = &CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE]; - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Memory Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefMemoryTblPtr[0].State = CS_STATE_DISABLED; - CS_AppData.DefMemoryTblPtr[1].State = CS_STATE_DISABLED; - - /* Set to generate error message CS_VAL_MEMORY_RANGE_ERR_EID */ - UT_SetDefaultReturnValue(UT_KEY(CFE_PSP_MemValidateRange), -1); - - /* Execute the function being tested */ - Result = CS_ValidateMemoryChecksumDefinitionTable(CS_AppData.DefMemoryTblPtr); + /* nominal */ + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->ResAddr, sizeof(tw->ResAddr), false); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->DefAddr, sizeof(tw->DefAddr), false); + UtAssert_INT32_EQ(CS_HandleTableUpdate(tw), CFE_SUCCESS); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_MEMORY_RANGE_ERR_EID); + /* failure to get result address */ + CS_Test_ResetEventCheck(); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 1, -123); + UtAssert_INT32_EQ(CS_HandleTableUpdate(tw), -123); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_UPDATE_ERR_EID); UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_MEMORY_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); + /* failure to get definition address */ + CS_Test_ResetEventCheck(); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->ResAddr, sizeof(tw->ResAddr), false); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, -123); + UtAssert_INT32_EQ(CS_HandleTableUpdate(tw), -123); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_UPDATE_ERR_EID); + UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); + /* CFE_TBL_INFO_UPDATED on definition address, not the tables table */ + tw = &CS_AppData.Tbl[CS_ChecksumType_APP_TABLE]; + CS_Test_ResetEventCheck(); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->ResAddr, sizeof(tw->ResAddr), false); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->DefAddr, sizeof(tw->DefAddr), false); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); + UtAssert_INT32_EQ(CS_HandleTableUpdate(tw), CFE_SUCCESS); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + /* CFE_TBL_INFO_UPDATED on definition address, on the tables table, owned by CS */ + tw = &CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE]; + ResultsEntry = tw->ResAddr; + CS_Test_ResetEventCheck(); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->ResAddr, sizeof(tw->ResAddr), false); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->DefAddr, sizeof(tw->DefAddr), false); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); + ResultsEntry->TblHandleID = CFE_TBL_HANDLEID_C(CFE_ResourceId_FromInteger(15)); + ResultsEntry->IsCSOwner = true; + UtAssert_INT32_EQ(CS_HandleTableUpdate(tw), CFE_SUCCESS); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); + UtAssert_STUB_COUNT(CFE_TBL_Unregister, 0); - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); + /* CFE_TBL_INFO_UPDATED on definition address, on the tables table, not owned by CS */ + CS_Test_ResetEventCheck(); + UT_ResetState(UT_KEY(CFE_TBL_GetAddress)); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->ResAddr, sizeof(tw->ResAddr), false); + UT_SetDataBuffer(UT_KEY(CFE_TBL_GetAddress), &tw->DefAddr, sizeof(tw->DefAddr), false); + UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); + ResultsEntry->TblHandleID = CFE_TBL_HANDLEID_C(CFE_ResourceId_FromInteger(15)); + ResultsEntry->IsCSOwner = false; + UtAssert_INT32_EQ(CS_HandleTableUpdate(tw), CFE_SUCCESS); + UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); + UtAssert_STUB_COUNT(CFE_TBL_Unregister, 1); } -void CS_ValidateMemoryChecksumDefinitionTable_Test_UndefTableErrorResult(void) +static void CS_UT_UpdateHandler(CS_TableWrapper_t *tw) { - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "Memory Table Validate: Illegal checksum range found in Entry ID %%d, CFE_PSP_MemValidateRange returned: " - "0x%%08X"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Memory Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefMemoryTblPtr[0].State = CS_STATE_DISABLED; - CS_AppData.DefMemoryTblPtr[1].State = CS_STATE_UNDEFINED; - - /* Set to generate error message CS_VAL_MEMORY_RANGE_ERR_EID */ - UT_SetDefaultReturnValue(UT_KEY(CFE_PSP_MemValidateRange), -1); - - /* Execute the function being tested */ - Result = CS_ValidateMemoryChecksumDefinitionTable(CS_AppData.DefMemoryTblPtr); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_MEMORY_RANGE_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_MEMORY_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); + UT_DEFAULT_IMPL(CS_UT_UpdateHandler); } -void CS_ValidateTablesChecksumDefinitionTable_Test_Nominal(void) +void Test_CS_CallTableUpdateHandler(void) { - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefTablesTblPtr[0].State = CS_STATE_ENABLED; /* All other states are empty by default, and so this test - also covers CS_STATE_EMPTY branch */ - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefTablesTblPtr); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); + CS_TableWrapper_t *tw; - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); + tw = &CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE]; - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateTablesChecksumDefinitionTable_Test_DuplicateNameStateEmpty(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table Validate: Duplicate Name (%%s) found at entries %%d and %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table verification results: good = %%d, bad = %%d, unused = %%d"); - - /* All states are empty by default */ - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "name", 10); - strncpy(CS_AppData.DefTablesTblPtr[1].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefTablesTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_DEF_TBL_DUPL_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_TABLES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateTablesChecksumDefinitionTable_Test_DuplicateNameStateEnabled(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table Validate: Duplicate Name (%%s) found at entries %%d and %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefTablesTblPtr[0].State = CS_STATE_ENABLED; /* All other states are empty by default, and so this test - also covers CS_STATE_EMPTY branch */ - CS_AppData.DefTablesTblPtr[1].State = CS_STATE_ENABLED; /* All other states are empty by default, and so this test - also covers CS_STATE_EMPTY branch */ - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "name", 10); - strncpy(CS_AppData.DefTablesTblPtr[1].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefTablesTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_DEF_TBL_DUPL_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_TABLES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateTablesChecksumDefinitionTable_Test_DuplicateNameStateDisabled(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table Validate: Duplicate Name (%%s) found at entries %%d and %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefTablesTblPtr[0].State = CS_STATE_DISABLED; /* All other states are empty by default, and so this test - also covers CS_STATE_EMPTY branch */ - CS_AppData.DefTablesTblPtr[1].State = CS_STATE_DISABLED; /* All other states are empty by default, and so this test - also covers CS_STATE_EMPTY branch */ - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "name", 10); - strncpy(CS_AppData.DefTablesTblPtr[1].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefTablesTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_DEF_TBL_DUPL_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_TABLES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateTablesChecksumDefinitionTable_Test_IllegalStateField(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table Validate: Illegal State Field (0x%%04X) found with name %%s"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefTablesTblPtr[0].State = 0xFFFF; - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefTablesTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_STATE_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_TABLES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateTablesChecksumDefinitionTable_Test_IllegalStateEmptyName(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table Validate: Illegal State (0x%%04X) with empty name at entry %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefTablesTblPtr[0].State = CS_STATE_ENABLED; - - /* Execute the function being tested */ - Result = CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefTablesTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_DEF_TBL_ZERO_NAME_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_TABLES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateTablesChecksumDefinitionTable_Test_TableErrorResult(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table Validate: Duplicate Name (%%s) found at entries %%d and %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table verification results: good = %%d, bad = %%d, unused = %%d"); - - /* All states are empty by default */ - CS_AppData.DefTablesTblPtr[0].State = CS_STATE_DISABLED; - CS_AppData.DefTablesTblPtr[1].State = CS_STATE_DISABLED; - CS_AppData.DefTablesTblPtr[2].State = CS_STATE_DISABLED; - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "name", 10); - strncpy(CS_AppData.DefTablesTblPtr[1].Name, "name", 10); - strncpy(CS_AppData.DefTablesTblPtr[2].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefTablesTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_DEF_TBL_DUPL_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_TABLES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateTablesChecksumDefinitionTable_Test_UndefTableErrorResult(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table Validate: Duplicate Name (%%s) found at entries %%d and %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefTablesTblPtr[0].State = CS_STATE_DISABLED; - CS_AppData.DefTablesTblPtr[1].State = CS_STATE_DISABLED; - CS_AppData.DefTablesTblPtr[2].State = CS_STATE_UNDEFINED; - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "name", 10); - strncpy(CS_AppData.DefTablesTblPtr[1].Name, "name", 10); - strncpy(CS_AppData.DefTablesTblPtr[2].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefTablesTblPtr); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_DEF_TBL_DUPL_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_TABLES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateTablesChecksumDefinitionTable_Test_CsTableError(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table Validate: Duplicate Name (%%s) found at entries %%d and %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Tables Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefTablesTblPtr[0].State = CS_STATE_DISABLED; - CS_AppData.DefTablesTblPtr[1].State = CS_STATE_DISABLED; - CS_AppData.DefTablesTblPtr[2].State = CS_STATE_UNDEFINED; - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "name", 10); - strncpy(CS_AppData.DefTablesTblPtr[1].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateTablesChecksumDefinitionTable(CS_AppData.DefTablesTblPtr); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_TABLES_DEF_TBL_DUPL_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_TABLES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateAppChecksumDefinitionTable_Test_Nominal(void) -{ - CS_AppData.DefAppTblPtr[0].State = CS_STATE_ENABLED; - strncpy(CS_AppData.DefAppTblPtr[0].Name, "app1", sizeof(CS_AppData.DefAppTblPtr[0].Name)); - CS_AppData.DefAppTblPtr[1].State = CS_STATE_ENABLED; - strncpy(CS_AppData.DefAppTblPtr[1].Name, "app2", sizeof(CS_AppData.DefAppTblPtr[1].Name)); - - /* Execute the function being tested */ - UtAssert_INT32_EQ(CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefAppTblPtr), CFE_SUCCESS); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); -} - -void CS_ValidateAppChecksumDefinitionTable_Test_DuplicateNameStateEmpty(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table Validate: Duplicate Name (%%s) found at entries %%d and %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table verification results: good = %%d, bad = %%d, unused = %%d"); - - /* All states are empty by default */ - - strncpy(CS_AppData.DefAppTblPtr[0].Name, "name", 10); - strncpy(CS_AppData.DefAppTblPtr[1].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefAppTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_DEF_TBL_DUPL_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_APP_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateAppChecksumDefinitionTable_Test_DuplicateNameStateEnabled(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table Validate: Duplicate Name (%%s) found at entries %%d and %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefAppTblPtr[0].State = CS_STATE_ENABLED; /* All other states are empty by default, and so this test also - covers CS_STATE_EMPTY branch */ - CS_AppData.DefAppTblPtr[1].State = CS_STATE_ENABLED; /* All other states are empty by default, and so this test also - covers CS_STATE_EMPTY branch */ - - strncpy(CS_AppData.DefAppTblPtr[0].Name, "name", 10); - strncpy(CS_AppData.DefAppTblPtr[1].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefAppTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_DEF_TBL_DUPL_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_APP_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateAppChecksumDefinitionTable_Test_DuplicateNameStateDisabled(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table Validate: Duplicate Name (%%s) found at entries %%d and %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefAppTblPtr[0].State = CS_STATE_DISABLED; /* All other states are empty by default, and so this test - also covers CS_STATE_EMPTY branch */ - CS_AppData.DefAppTblPtr[1].State = CS_STATE_DISABLED; /* All other states are empty by default, and so this test - also covers CS_STATE_EMPTY branch */ - - strncpy(CS_AppData.DefAppTblPtr[0].Name, "name", 10); - strncpy(CS_AppData.DefAppTblPtr[1].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefAppTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_DEF_TBL_DUPL_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_APP_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateAppChecksumDefinitionTable_Test_IllegalStateField(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table Validate: Illegal State Field (0x%%04X) found with name %%s"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefAppTblPtr[0].State = 0xFFFF; - - strncpy(CS_AppData.DefAppTblPtr[0].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefAppTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_STATE_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_APP_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateAppChecksumDefinitionTable_Test_IllegalStateEmptyName(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table Validate: Illegal State (0x%%04X) with empty name at entry %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefAppTblPtr[0].State = CS_STATE_ENABLED; - - /* Execute the function being tested */ - Result = CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefAppTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_DEF_TBL_ZERO_NAME_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_APP_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateAppChecksumDefinitionTable_Test_LongName(void) -{ - memset(CS_AppData.DefAppTblPtr[0].Name, 'x', sizeof(CS_AppData.DefAppTblPtr[0].Name)); - memset(CS_AppData.DefAppTblPtr[1].Name, 'y', sizeof(CS_AppData.DefAppTblPtr[1].Name)); - - UtAssert_INT32_EQ(CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefAppTblPtr), CS_TABLE_ERROR); - - /* Verify results */ - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_DEF_TBL_LONG_NAME_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_APP_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); -} - -void CS_ValidateAppChecksumDefinitionTable_Test_TableErrorResult(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table Validate: Duplicate Name (%%s) found at entries %%d and %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table verification results: good = %%d, bad = %%d, unused = %%d"); - - /* All states are empty by default */ - CS_AppData.DefAppTblPtr[0].State = CS_STATE_DISABLED; - CS_AppData.DefAppTblPtr[1].State = CS_STATE_DISABLED; - CS_AppData.DefAppTblPtr[2].State = CS_STATE_DISABLED; - - strncpy(CS_AppData.DefAppTblPtr[0].Name, "name", 10); - strncpy(CS_AppData.DefAppTblPtr[1].Name, "name", 10); - strncpy(CS_AppData.DefAppTblPtr[2].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefAppTblPtr); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_DEF_TBL_DUPL_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_APP_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateAppChecksumDefinitionTable_Test_UndefTableErrorResult(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table Validate: Duplicate Name (%%s) found at entries %%d and %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefAppTblPtr[0].State = CS_STATE_DISABLED; - CS_AppData.DefAppTblPtr[1].State = CS_STATE_DISABLED; - CS_AppData.DefAppTblPtr[2].State = CS_STATE_UNDEFINED; - - strncpy(CS_AppData.DefAppTblPtr[0].Name, "name", 10); - strncpy(CS_AppData.DefAppTblPtr[1].Name, "name", 10); - strncpy(CS_AppData.DefAppTblPtr[2].Name, "name", 10); - - /* Execute the function being tested */ - Result = CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefAppTblPtr); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_DEF_TBL_DUPL_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_APP_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ValidateAppChecksumDefinitionTable_Test_EmptyNameTableResult(void) -{ - CFE_Status_t Result; - int32 strCmpResult; - char ExpectedEventString[2][CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString[0], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table Validate: Illegal State (0x%%04X) with empty name at entry %%d"); - - snprintf(ExpectedEventString[1], CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS Apps Table verification results: good = %%d, bad = %%d, unused = %%d"); - - CS_AppData.DefAppTblPtr[0].State = CS_STATE_ENABLED; - CS_AppData.DefAppTblPtr[1].State = CS_STATE_ENABLED; - CS_AppData.DefAppTblPtr[2].State = CS_STATE_ENABLED; - - /* Execute the function being tested */ - Result = CS_ValidateAppChecksumDefinitionTable(CS_AppData.DefAppTblPtr); - - /* Verify results */ - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_VAL_APP_DEF_TBL_ZERO_NAME_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = - strncmp(ExpectedEventString[0], context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventID, CS_VAL_APP_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[1].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = - strncmp(ExpectedEventString[1], context_CFE_EVS_SendEvent[1].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[1].Spec); - - UtAssert_True(Result == CS_TABLE_ERROR, "Result == CS_TABLE_ERROR"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 2, "CFE_EVS_SendEvent was called %u time(s), expected 2", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewEepromMemoryDefinitionTable_Test_EEPROMTableNominal(void) -{ - /* Handles both cases of "DefEntry -> State" */ - - uint16 NumEntries = 1; - uint16 Table = CS_EEPROM_TABLE; - - CS_AppData.HkPacket.Payload.EepromCSState = 99; - CS_AppData.DefEepromTblPtr[0].State = 1; - CS_AppData.DefEepromTblPtr[0].NumBytesToChecksum = 2; - CS_AppData.DefEepromTblPtr[0].StartAddress = 3; - - /* Execute the function being tested */ - CS_ProcessNewEepromMemoryDefinitionTable(CS_AppData.DefEepromTblPtr, CS_AppData.ResEepromTblPtr, NumEntries, Table); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.EepromCSState == 99, "CS_AppData.HkPacket.Payload.EepromCSState == 99"); - - UtAssert_True(CS_AppData.ResEepromTblPtr[0].State == 1, "CS_AppData.ResEepromTblPtr[0].State == 1"); - UtAssert_True(CS_AppData.ResEepromTblPtr[0].ComputedYet == false, - "CS_AppData.ResEepromTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResEepromTblPtr[0].NumBytesToChecksum == 2, - "CS_AppData.ResEepromTblPtr[0].NumBytesToChecksum == 2"); - UtAssert_True(CS_AppData.ResEepromTblPtr[0].ComparisonValue == 0, - "CS_AppData.ResEepromTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResEepromTblPtr[0].ByteOffset == 0, "CS_AppData.ResEepromTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResEepromTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResEepromTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResEepromTblPtr[0].StartAddress == 3, "CS_AppData.ResEepromTblPtr[0].StartAddress == 3"); - - UtAssert_True(CS_AppData.ResEepromTblPtr[1].State == CS_STATE_EMPTY, - "CS_AppData.ResEepromTblPtr[1].State == CS_STATE_EMPTY"); - UtAssert_True(CS_AppData.ResEepromTblPtr[1].ComputedYet == false, - "CS_AppData.ResEepromTblPtr[1].ComputedYet == false"); - UtAssert_True(CS_AppData.ResEepromTblPtr[1].NumBytesToChecksum == 0, - "CS_AppData.ResEepromTblPtr[1].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResEepromTblPtr[1].ComparisonValue == 0, - "CS_AppData.ResEepromTblPtr[1].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResEepromTblPtr[1].ByteOffset == 0, "CS_AppData.ResEepromTblPtr[1].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResEepromTblPtr[1].TempChecksumValue == 0, - "CS_AppData.ResEepromTblPtr[1].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResEepromTblPtr[1].StartAddress == 0, "CS_AppData.ResEepromTblPtr[1].StartAddress == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewEepromMemoryDefinitionTable_Test_MemoryTableNominal(void) -{ - /* Handles both cases of "DefEntry -> State" */ - - uint16 NumEntries = 1; - uint16 Table = CS_MEMORY_TABLE; - - CS_AppData.HkPacket.Payload.MemoryCSState = 99; - CS_AppData.DefMemoryTblPtr[0].State = 1; - CS_AppData.DefMemoryTblPtr[0].NumBytesToChecksum = 2; - CS_AppData.DefMemoryTblPtr[0].StartAddress = 3; - - /* Execute the function being tested */ - CS_ProcessNewEepromMemoryDefinitionTable(CS_AppData.DefMemoryTblPtr, CS_AppData.ResMemoryTblPtr, NumEntries, Table); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == 99, "CS_AppData.HkPacket.Payload.MemoryCSState == 99"); - - UtAssert_True(CS_AppData.ResMemoryTblPtr[0].State == 1, "CS_AppData.ResMemoryTblPtr[0].State == 1"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[0].ComputedYet == false, - "CS_AppData.ResMemoryTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[0].NumBytesToChecksum == 2, - "CS_AppData.ResMemoryTblPtr[0].NumBytesToChecksum == 2"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[0].ComparisonValue == 0, - "CS_AppData.ResMemoryTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[0].ByteOffset == 0, "CS_AppData.ResMemoryTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResMemoryTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[0].StartAddress == 3, "CS_AppData.ResMemoryTblPtr[0].StartAddress == 3"); - - UtAssert_True(CS_AppData.ResMemoryTblPtr[1].State == CS_STATE_EMPTY, - "CS_AppData.ResMemoryTblPtr[1].State == CS_STATE_EMPTY"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[1].ComputedYet == false, - "CS_AppData.ResMemoryTblPtr[1].ComputedYet == false"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[1].NumBytesToChecksum == 0, - "CS_AppData.ResMemoryTblPtr[1].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[1].ComparisonValue == 0, - "CS_AppData.ResMemoryTblPtr[1].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[1].ByteOffset == 0, "CS_AppData.ResMemoryTblPtr[1].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[1].TempChecksumValue == 0, - "CS_AppData.ResMemoryTblPtr[1].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResMemoryTblPtr[1].StartAddress == 0, "CS_AppData.ResMemoryTblPtr[1].StartAddress == 0"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewEepromMemoryDefinitionTable_Test_EEPROMTableNoValidEntries(void) -{ - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "CS %%s Table: No valid entries in the table"); - - /* Handles both cases of "DefEntry -> State" */ - - uint16 NumEntries = 1; - uint16 Table = CS_EEPROM_TABLE; - - CS_AppData.HkPacket.Payload.MemoryCSState = 99; - - /* Execute the function being tested */ - CS_ProcessNewEepromMemoryDefinitionTable(CS_AppData.DefMemoryTblPtr, CS_AppData.ResMemoryTblPtr, NumEntries, Table); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == 99, "CS_AppData.HkPacket.Payload.MemoryCSState == 99"); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_EEPROM_MEMORY_NO_ENTRIES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewEepromMemoryDefinitionTable_Test_MemoryTableNoValidEntries(void) -{ - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "CS %%s Table: No valid entries in the table"); - - /* Handles both cases of "DefEntry -> State" */ - - uint16 NumEntries = 1; - uint16 Table = CS_MEMORY_TABLE; - - CS_AppData.HkPacket.Payload.MemoryCSState = 99; - - /* Execute the function being tested */ - CS_ProcessNewEepromMemoryDefinitionTable(CS_AppData.DefMemoryTblPtr, CS_AppData.ResMemoryTblPtr, NumEntries, Table); - - /* Verify results */ - UtAssert_True(CS_AppData.HkPacket.Payload.MemoryCSState == 99, "CS_AppData.HkPacket.Payload.MemoryCSState == 99"); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_EEPROM_MEMORY_NO_ENTRIES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewTablesDefinitionTable_Test_DefEepromTableHandle(void) -{ - CS_AppData.HkPacket.Payload.TablesCSState = 99; - CS_AppData.DefTablesTblPtr[0].State = 88; - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "CS.DefEepromTbl", 20); - - CS_AppData.DefEepromTableHandle = 11; - - /* Sets AppName to "CS" */ - UT_SetHandlerFunction(UT_KEY(CFE_ES_GetAppName), CS_TABLE_PROCESSING_TEST_CFE_ES_GetAppNameHandler1, NULL); - - /* Execute the function being tested */ - CS_ProcessNewTablesDefinitionTable(CS_AppData.DefTablesTblPtr, CS_AppData.ResTablesTblPtr); - - /* Verify results */ - UtAssert_True(CS_AppData.MemResTablesTblPtr == NULL, "CS_AppData.MemResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.AppResTablesTblPtr == NULL, "CS_AppData.AppResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.TblResTablesTblPtr == NULL, "CS_AppData.TblResTablesTblPtr == NULL"); - - UtAssert_True(CS_AppData.EepResTablesTblPtr == CS_AppData.ResTablesTblPtr, - "CS_AppData.EepResTablesTblPtr == CS_AppData.ResTablesTblPtr"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].State == 88, "CS_AppData.ResTablesTblPtr[0].State == 88"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComputedYet == false, - "CS_AppData.ResTablesTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0, - "CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0, - "CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ByteOffset == 0, "CS_AppData.ResTablesTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].StartAddress == 0, "CS_AppData.ResTablesTblPtr[0].StartAddress == 0"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TblHandle == 11, "CS_AppData.ResTablesTblPtr[0].TblHandle == 11"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].IsCSOwner == true, "CS_AppData.ResTablesTblPtr[0].IsCSOwner == true"); - UtAssert_True(strncmp(CS_AppData.ResTablesTblPtr[0].Name, "CS.DefEepromTbl", 20) == 0, - "strncmp(CS_AppData.ResTablesTblPtr[0].Name, 'CS.DefEepromTbl', 20) == 0"); - - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 99, "CS_AppData.HkPacket.Payload.TablesCSState == 99"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewTablesDefinitionTable_Test_DefMemoryTableHandle(void) -{ - CS_AppData.HkPacket.Payload.TablesCSState = 99; - CS_AppData.DefTablesTblPtr[0].State = 88; - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "CS.DefMemoryTbl", 20); - - CS_AppData.DefMemoryTableHandle = 11; - - /* Sets AppName to "CS" */ - UT_SetHandlerFunction(UT_KEY(CFE_ES_GetAppName), CS_TABLE_PROCESSING_TEST_CFE_ES_GetAppNameHandler1, NULL); - - /* Execute the function being tested */ - CS_ProcessNewTablesDefinitionTable(CS_AppData.DefTablesTblPtr, CS_AppData.ResTablesTblPtr); - - /* Verify results */ - UtAssert_True(CS_AppData.EepResTablesTblPtr == NULL, "CS_AppData.EepResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.AppResTablesTblPtr == NULL, "CS_AppData.AppResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.TblResTablesTblPtr == NULL, "CS_AppData.TblResTablesTblPtr == NULL"); - - UtAssert_True(CS_AppData.MemResTablesTblPtr == CS_AppData.ResTablesTblPtr, - "CS_AppData.MemResTablesTblPtr == CS_AppData.ResTablesTblPtr"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].State == 88, "CS_AppData.ResTablesTblPtr[0].State == 88"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComputedYet == false, - "CS_AppData.ResTablesTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0, - "CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0, - "CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ByteOffset == 0, "CS_AppData.ResTablesTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].StartAddress == 0, "CS_AppData.ResTablesTblPtr[0].StartAddress == 0"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TblHandle == 11, "CS_AppData.ResTablesTblPtr[0].TblHandle == 11"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].IsCSOwner == true, "CS_AppData.ResTablesTblPtr[0].IsCSOwner == true"); - UtAssert_True(strncmp(CS_AppData.ResTablesTblPtr[0].Name, "CS.DefMemoryTbl", 20) == 0, - "strncmp(CS_AppData.ResTablesTblPtr[0].Name, 'CS.DefMemoryTbl', 20) == 0"); - - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 99, "CS_AppData.HkPacket.Payload.TablesCSState == 99"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewTablesDefinitionTable_Test_DefTablesTableHandle(void) -{ - CS_AppData.HkPacket.Payload.TablesCSState = 99; - CS_AppData.DefTablesTblPtr[0].State = 88; - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "CS.DefTablesTbl", 20); - - CS_AppData.DefTablesTableHandle = 11; - - /* Sets AppName to "CS" */ - UT_SetHandlerFunction(UT_KEY(CFE_ES_GetAppName), CS_TABLE_PROCESSING_TEST_CFE_ES_GetAppNameHandler1, NULL); - - /* Execute the function being tested */ - CS_ProcessNewTablesDefinitionTable(CS_AppData.DefTablesTblPtr, CS_AppData.ResTablesTblPtr); - - /* Verify results */ - UtAssert_True(CS_AppData.EepResTablesTblPtr == NULL, "CS_AppData.EepResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.AppResTablesTblPtr == NULL, "CS_AppData.AppResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.MemResTablesTblPtr == NULL, "CS_AppData.MemResTablesTblPtr == NULL"); - - UtAssert_True(CS_AppData.TblResTablesTblPtr == CS_AppData.ResTablesTblPtr, - "CS_AppData.TblResTablesTblPtr == CS_AppData.ResTablesTblPtr"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].State == 88, "CS_AppData.ResTablesTblPtr[0].State == 88"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComputedYet == false, - "CS_AppData.ResTablesTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0, - "CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0, - "CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ByteOffset == 0, "CS_AppData.ResTablesTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].StartAddress == 0, "CS_AppData.ResTablesTblPtr[0].StartAddress == 0"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TblHandle == 11, "CS_AppData.ResTablesTblPtr[0].TblHandle == 11"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].IsCSOwner == true, "CS_AppData.ResTablesTblPtr[0].IsCSOwner == true"); - UtAssert_True(strncmp(CS_AppData.ResTablesTblPtr[0].Name, "CS.DefTablesTbl", 20) == 0, - "strncmp(CS_AppData.ResTablesTblPtr[0].Name, 'CS.DefTablesTbl', 20) == 0"); - - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 99, "CS_AppData.HkPacket.Payload.TablesCSState == 99"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewTablesDefinitionTable_Test_DefAppTableHandle(void) -{ - CS_AppData.HkPacket.Payload.TablesCSState = 99; - CS_AppData.DefTablesTblPtr[0].State = 88; - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "CS.DefAppTbl", 20); - - CS_AppData.DefAppTableHandle = 11; - - /* Sets AppName to "CS" */ - UT_SetHandlerFunction(UT_KEY(CFE_ES_GetAppName), CS_TABLE_PROCESSING_TEST_CFE_ES_GetAppNameHandler1, NULL); - - /* Execute the function being tested */ - CS_ProcessNewTablesDefinitionTable(CS_AppData.DefTablesTblPtr, CS_AppData.ResTablesTblPtr); - - /* Verify results */ - UtAssert_True(CS_AppData.EepResTablesTblPtr == NULL, "CS_AppData.EepResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.TblResTablesTblPtr == NULL, "CS_AppData.TblResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.MemResTablesTblPtr == NULL, "CS_AppData.MemResTablesTblPtr == NULL"); - - UtAssert_True(CS_AppData.AppResTablesTblPtr == CS_AppData.ResTablesTblPtr, - "CS_AppData.AppResTablesTblPtr == CS_AppData.ResTablesTblPtr"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].State == 88, "CS_AppData.ResTablesTblPtr[0].State == 88"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComputedYet == false, - "CS_AppData.ResTablesTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0, - "CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0, - "CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ByteOffset == 0, "CS_AppData.ResTablesTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].StartAddress == 0, "CS_AppData.ResTablesTblPtr[0].StartAddress == 0"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TblHandle == 11, "CS_AppData.ResTablesTblPtr[0].TblHandle == 11"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].IsCSOwner == true, "CS_AppData.ResTablesTblPtr[0].IsCSOwner == true"); - UtAssert_True(strncmp(CS_AppData.ResTablesTblPtr[0].Name, "CS.DefAppTbl", 20) == 0, - "strncmp(CS_AppData.ResTablesTblPtr[0].Name, 'CS.DefAppTbl', 20) == 0"); - - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 99, "CS_AppData.HkPacket.Payload.TablesCSState == 99"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewTablesDefinitionTable_Test_ResEepromTableHandle(void) -{ - CS_AppData.HkPacket.Payload.TablesCSState = 99; - CS_AppData.DefTablesTblPtr[0].State = 88; - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "CS.ResEepromTbl", 20); - - CS_AppData.ResEepromTableHandle = 11; - - /* Sets AppName to "CS" */ - UT_SetHandlerFunction(UT_KEY(CFE_ES_GetAppName), CS_TABLE_PROCESSING_TEST_CFE_ES_GetAppNameHandler1, NULL); - - /* Execute the function being tested */ - CS_ProcessNewTablesDefinitionTable(CS_AppData.DefTablesTblPtr, CS_AppData.ResTablesTblPtr); - - /* Verify results */ - UtAssert_True(CS_AppData.EepResTablesTblPtr == NULL, "CS_AppData.EepResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.MemResTablesTblPtr == NULL, "CS_AppData.MemResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.AppResTablesTblPtr == NULL, "CS_AppData.AppResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.TblResTablesTblPtr == NULL, "CS_AppData.TblResTablesTblPtr == NULL"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].State == 88, "CS_AppData.ResTablesTblPtr[0].State == 88"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComputedYet == false, - "CS_AppData.ResTablesTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0, - "CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0, - "CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ByteOffset == 0, "CS_AppData.ResTablesTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].StartAddress == 0, "CS_AppData.ResTablesTblPtr[0].StartAddress == 0"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TblHandle == 11, "CS_AppData.ResTablesTblPtr[0].TblHandle == 11"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].IsCSOwner == true, "CS_AppData.ResTablesTblPtr[0].IsCSOwner == true"); - UtAssert_True(strncmp(CS_AppData.ResTablesTblPtr[0].Name, "CS.ResEepromTbl", 20) == 0, - "strncmp(CS_AppData.ResTablesTblPtr[0].Name, 'CS.ResEepromTbl', 20) == 0"); - - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 99, "CS_AppData.HkPacket.Payload.TablesCSState == 99"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewTablesDefinitionTable_Test_ResMemoryTableHandle(void) -{ - CS_AppData.HkPacket.Payload.TablesCSState = 99; - CS_AppData.DefTablesTblPtr[0].State = 88; - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "CS.ResMemoryTbl", 20); - - CS_AppData.ResMemoryTableHandle = 11; - - /* Sets AppName to "CS" */ - UT_SetHandlerFunction(UT_KEY(CFE_ES_GetAppName), CS_TABLE_PROCESSING_TEST_CFE_ES_GetAppNameHandler1, NULL); - - /* Execute the function being tested */ - CS_ProcessNewTablesDefinitionTable(CS_AppData.DefTablesTblPtr, CS_AppData.ResTablesTblPtr); - - /* Verify results */ - UtAssert_True(CS_AppData.EepResTablesTblPtr == NULL, "CS_AppData.EepResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.MemResTablesTblPtr == NULL, "CS_AppData.MemResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.AppResTablesTblPtr == NULL, "CS_AppData.AppResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.TblResTablesTblPtr == NULL, "CS_AppData.TblResTablesTblPtr == NULL"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].State == 88, "CS_AppData.ResTablesTblPtr[0].State == 88"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComputedYet == false, - "CS_AppData.ResTablesTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0, - "CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0, - "CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ByteOffset == 0, "CS_AppData.ResTablesTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].StartAddress == 0, "CS_AppData.ResTablesTblPtr[0].StartAddress == 0"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TblHandle == 11, "CS_AppData.ResTablesTblPtr[0].TblHandle == 11"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].IsCSOwner == true, "CS_AppData.ResTablesTblPtr[0].IsCSOwner == true"); - UtAssert_True(strncmp(CS_AppData.ResTablesTblPtr[0].Name, "CS.ResMemoryTbl", 20) == 0, - "strncmp(CS_AppData.ResTablesTblPtr[0].Name, 'CS.ResMemoryTbl', 20) == 0"); - - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 99, "CS_AppData.HkPacket.Payload.TablesCSState == 99"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewTablesDefinitionTable_Test_ResTablesTableHandle(void) -{ - CS_AppData.HkPacket.Payload.TablesCSState = 99; - CS_AppData.DefTablesTblPtr[0].State = 88; - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "CS.ResTablesTbl", 20); - - CS_AppData.ResTablesTableHandle = 11; - - /* Sets AppName to "CS" */ - UT_SetHandlerFunction(UT_KEY(CFE_ES_GetAppName), CS_TABLE_PROCESSING_TEST_CFE_ES_GetAppNameHandler1, NULL); - - /* Execute the function being tested */ - CS_ProcessNewTablesDefinitionTable(CS_AppData.DefTablesTblPtr, CS_AppData.ResTablesTblPtr); - - /* Verify results */ - UtAssert_True(CS_AppData.EepResTablesTblPtr == NULL, "CS_AppData.EepResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.MemResTablesTblPtr == NULL, "CS_AppData.MemResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.AppResTablesTblPtr == NULL, "CS_AppData.AppResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.TblResTablesTblPtr == NULL, "CS_AppData.TblResTablesTblPtr == NULL"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].State == 88, "CS_AppData.ResTablesTblPtr[0].State == 88"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComputedYet == false, - "CS_AppData.ResTablesTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0, - "CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0, - "CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ByteOffset == 0, "CS_AppData.ResTablesTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].StartAddress == 0, "CS_AppData.ResTablesTblPtr[0].StartAddress == 0"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TblHandle == 11, "CS_AppData.ResTablesTblPtr[0].TblHandle == 11"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].IsCSOwner == true, "CS_AppData.ResTablesTblPtr[0].IsCSOwner == true"); - UtAssert_True(strncmp(CS_AppData.ResTablesTblPtr[0].Name, "CS.ResTablesTbl", 20) == 0, - "strncmp(CS_AppData.ResTablesTblPtr[0].Name, 'CS.ResTablesTbl', 20) == 0"); - - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 99, "CS_AppData.HkPacket.Payload.TablesCSState == 99"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewTablesDefinitionTable_Test_ResAppTableHandle(void) -{ - CS_AppData.HkPacket.Payload.TablesCSState = 99; - CS_AppData.DefTablesTblPtr[0].State = 88; - - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "CS.ResAppTbl", 20); - - CS_AppData.ResAppTableHandle = 11; - - /* Sets AppName to "CS" */ - UT_SetHandlerFunction(UT_KEY(CFE_ES_GetAppName), CS_TABLE_PROCESSING_TEST_CFE_ES_GetAppNameHandler1, NULL); - - /* Execute the function being tested */ - CS_ProcessNewTablesDefinitionTable(CS_AppData.DefTablesTblPtr, CS_AppData.ResTablesTblPtr); - - /* Verify results */ - UtAssert_True(CS_AppData.EepResTablesTblPtr == NULL, "CS_AppData.EepResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.MemResTablesTblPtr == NULL, "CS_AppData.MemResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.AppResTablesTblPtr == NULL, "CS_AppData.AppResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.TblResTablesTblPtr == NULL, "CS_AppData.TblResTablesTblPtr == NULL"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].State == 88, "CS_AppData.ResTablesTblPtr[0].State == 88"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComputedYet == false, - "CS_AppData.ResTablesTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0, - "CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0, - "CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ByteOffset == 0, "CS_AppData.ResTablesTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].StartAddress == 0, "CS_AppData.ResTablesTblPtr[0].StartAddress == 0"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TblHandle == 11, "CS_AppData.ResTablesTblPtr[0].TblHandle == 11"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].IsCSOwner == true, "CS_AppData.ResTablesTblPtr[0].IsCSOwner == true"); - UtAssert_True(strncmp(CS_AppData.ResTablesTblPtr[0].Name, "CS.ResAppTbl", 20) == 0, - "strncmp(CS_AppData.ResTablesTblPtr[0].Name, 'CS.ResAppTbl', 20) == 0"); - - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 99, "CS_AppData.HkPacket.Payload.TablesCSState == 99"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewTablesDefinitionTable_Test_StateEmptyNoValidEntries(void) -{ - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "CS Tables Table: No valid entries in the table"); - - CS_AppData.HkPacket.Payload.TablesCSState = 99; - CS_AppData.DefTablesTblPtr[0].State = CS_STATE_EMPTY; - - /* Sets AppName to "CS" */ - UT_SetHandlerFunction(UT_KEY(CFE_ES_GetAppName), CS_TABLE_PROCESSING_TEST_CFE_ES_GetAppNameHandler1, NULL); - - /* Execute the function being tested */ - CS_ProcessNewTablesDefinitionTable(CS_AppData.DefTablesTblPtr, CS_AppData.ResTablesTblPtr); - - /* Verify results */ - UtAssert_True(CS_AppData.EepResTablesTblPtr == NULL, "CS_AppData.EepResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.MemResTablesTblPtr == NULL, "CS_AppData.MemResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.AppResTablesTblPtr == NULL, "CS_AppData.AppResTablesTblPtr == NULL"); - UtAssert_True(CS_AppData.TblResTablesTblPtr == NULL, "CS_AppData.TblResTablesTblPtr == NULL"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].State == CS_STATE_EMPTY, - "CS_AppData.ResTablesTblPtr[0].State == CS_STATE_EMPTY"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComputedYet == false, - "CS_AppData.ResTablesTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0, - "CS_AppData.ResTablesTblPtr[0].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0, - "CS_AppData.ResTablesTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].ByteOffset == 0, "CS_AppData.ResTablesTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResTablesTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].StartAddress == 0, "CS_AppData.ResTablesTblPtr[0].StartAddress == 0"); - - UtAssert_True(CS_AppData.ResTablesTblPtr[0].TblHandle == CFE_TBL_BAD_TABLE_HANDLE, - "CS_AppData.ResTablesTblPtr[0].TblHandle == CFE_TBL_BAD_TABLE_HANDLE"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].IsCSOwner == false, "CS_AppData.ResTablesTblPtr[0].IsCSOwner == false"); - UtAssert_True(CS_AppData.ResTablesTblPtr[0].Name[0] == 0, "CS_AppData.ResTablesTblPtr[0].Name[0] == 0"); - - UtAssert_True(CS_AppData.HkPacket.Payload.TablesCSState == 99, "CS_AppData.HkPacket.Payload.TablesCSState == 99"); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_TABLES_NO_ENTRIES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewTablesDefinitionTable_Test_LimitApplicationNameLength(void) -{ - uint16 i; - const char AppNameX[] = "X"; - - CS_AppData.HkPacket.Payload.TablesCSState = 99; - CS_AppData.DefTablesTblPtr[0].State = 88; - - /* String name chosen to be of length OS_MAX_API_NAME in order to satisfy condition "AppNameIndex == - * OS_MAX_API_NAME" */ - /* If intended branch is reached, name length will be truncated to length OS_MAX_API_NAME - 1 */ - for (i = 0; i <= OS_MAX_API_NAME; i++) - { - strncat(CS_AppData.DefTablesTblPtr[0].Name, "x", OS_MAX_API_NAME); - } - - strncat(CS_AppData.DefTablesTblPtr[0].Name, ".DefEepromTbl", OS_MAX_API_NAME); - - CS_AppData.DefEepromTableHandle = 11; - - /* Sets AppName to string of x's of length OS_MAX_API_NAME */ - UT_SetDataBuffer(UT_KEY(CFE_ES_GetAppName), (uint8 *)AppNameX, sizeof(AppNameX), false); - - /* Execute the function being tested */ - CS_ProcessNewTablesDefinitionTable(CS_AppData.DefTablesTblPtr, CS_AppData.ResTablesTblPtr); - - /* Verify results */ - /* Note: This test is a special case where we're only interested in seeing that one branch was taken: "if - * (AppNameIndex == OS_MAX_API_NAME)" */ - /* If branch was taken, line "CS_AppData.EepResTablesTblPtr = ResultsEntry" will not be reached, and so the - * following assert will pass */ - UtAssert_True(CS_AppData.EepResTablesTblPtr != CS_AppData.ResTablesTblPtr, - "CS_AppData.EepResTablesTblPtr != CS_AppData.ResTablesTblPtr"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewTablesDefinitionTable_Test_LimitTableNameLength(void) -{ - uint16 i; - - CS_AppData.HkPacket.Payload.TablesCSState = 99; - CS_AppData.DefTablesTblPtr[0].State = 88; - - strncat(CS_AppData.DefTablesTblPtr[0].Name, "CS.", CFE_TBL_MAX_FULL_NAME_LEN); - - /* String name chosen to be of length CFE_TBL_MAX_FULL_NAME_LEN in order to satisfy condition "TableNameIndex == - * CFE_TBL_MAX_FULL_NAME_LEN" */ - /* If intended branch is reached, name length will be truncated to length CFE_TBL_MAX_FULL_NAME_LEN - 1 */ - for (i = 0; i <= CFE_TBL_MAX_FULL_NAME_LEN; i++) - { - strncat(CS_AppData.DefTablesTblPtr[0].Name, "x", CFE_TBL_MAX_FULL_NAME_LEN); - } - - CS_AppData.DefEepromTableHandle = 11; - - /* Sets AppName to "CS" */ - UT_SetHandlerFunction(UT_KEY(CFE_ES_GetAppName), CS_TABLE_PROCESSING_TEST_CFE_ES_GetAppNameHandler1, NULL); - - /* Execute the function being tested */ - CS_ProcessNewTablesDefinitionTable(CS_AppData.DefTablesTblPtr, CS_AppData.ResTablesTblPtr); - - /* Verify results */ - /* Note: This test is a special case where we're only interested in seeing that one branch was taken: "if - * (TableNameIndex == CFE_TBL_MAX_FULL_NAME_LEN)" */ - /* If branch was taken, line "CS_AppData.EepResTablesTblPtr = ResultsEntry" will not be reached, and so the - * following assert will pass */ - UtAssert_True(CS_AppData.EepResTablesTblPtr != CS_AppData.ResTablesTblPtr, - "CS_AppData.EepResTablesTblPtr != CS_AppData.ResTablesTblPtr"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewTablesDefinitionTable_Test_MaxTableNameLength(void) -{ - uint16 i; - - CS_AppData.HkPacket.Payload.TablesCSState = 99; - CS_AppData.DefTablesTblPtr[0].State = 88; - - strncat(CS_AppData.DefTablesTblPtr[0].Name, "CS", CFE_TBL_MAX_FULL_NAME_LEN); - - /* String name chosen to be of length CFE_TBL_MAX_FULL_NAME_LEN in order to satisfy condition "TableNameIndex == - * CFE_TBL_MAX_FULL_NAME_LEN" */ - /* If intended branch is reached, name length will be truncated to length CFE_TBL_MAX_FULL_NAME_LEN - 1 */ - for (i = 0; i <= CFE_TBL_MAX_FULL_NAME_LEN + 1; i++) - { - strncat(CS_AppData.DefTablesTblPtr[0].Name, "x", CFE_TBL_MAX_FULL_NAME_LEN); - } - - CS_AppData.DefEepromTableHandle = 11; - - /* Sets AppName to "CS" */ - UT_SetHandlerFunction(UT_KEY(CFE_ES_GetAppName), CS_TABLE_PROCESSING_TEST_CFE_ES_GetAppNameHandler1, NULL); - - /* Execute the function being tested */ - CS_ProcessNewTablesDefinitionTable(CS_AppData.DefTablesTblPtr, CS_AppData.ResTablesTblPtr); - - /* Verify results */ - /* Note: This test is a special case where we're only interested in seeing that one branch was taken: "if - * (TableNameIndex == CFE_TBL_MAX_FULL_NAME_LEN)" */ - /* If branch was taken, line "CS_AppData.EepResTablesTblPtr = ResultsEntry" will not be reached, and so the - * following assert will pass */ - UtAssert_True(CS_AppData.EepResTablesTblPtr != CS_AppData.ResTablesTblPtr, - "CS_AppData.EepResTablesTblPtr != CS_AppData.ResTablesTblPtr"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewAppDefinitionTable_Test_Nominal(void) -{ - CS_AppData.HkPacket.Payload.AppCSState = 99; - CS_AppData.DefAppTblPtr[0].State = 88; - - strncpy(CS_AppData.DefAppTblPtr[0].Name, "name", 20); - - /* Execute the function being tested */ - CS_ProcessNewAppDefinitionTable(CS_AppData.DefAppTblPtr, CS_AppData.ResAppTblPtr); - - /* Verify results */ - UtAssert_True(CS_AppData.ResAppTblPtr[0].State == 88, "CS_AppData.ResAppTblPtr[0].State == 88"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].ComputedYet == false, "CS_AppData.ResAppTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].NumBytesToChecksum == 0, - "CS_AppData.ResAppTblPtr[0].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].ComparisonValue == 0, "CS_AppData.ResAppTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].ByteOffset == 0, "CS_AppData.ResAppTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResAppTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].StartAddress == 0, "CS_AppData.ResAppTblPtr[0].StartAddress == 0"); - UtAssert_True(strncmp(CS_AppData.ResAppTblPtr[0].Name, "name", 20) == 0, - "strncmp(CS_AppData.ResAppTblPtr[0].Name, 'name', 20) == 0"); - - UtAssert_True(CS_AppData.HkPacket.Payload.AppCSState == 99, "CS_AppData.HkPacket.Payload.AppCSState == 99"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_ProcessNewAppDefinitionTable_Test_StateEmptyNoValidEntries(void) -{ - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, "CS Apps Table: No valid entries in the table"); - - CS_AppData.HkPacket.Payload.AppCSState = 99; - CS_AppData.DefAppTblPtr[0].State = CS_STATE_EMPTY; - - /* Execute the function being tested */ - CS_ProcessNewAppDefinitionTable(CS_AppData.DefAppTblPtr, CS_AppData.ResAppTblPtr); - - /* Verify results */ - UtAssert_True(CS_AppData.ResAppTblPtr[0].State == CS_STATE_EMPTY, - "CS_AppData.ResAppTblPtr[0].State == CS_STATE_EMPTY"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].ComputedYet == false, "CS_AppData.ResAppTblPtr[0].ComputedYet == false"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].NumBytesToChecksum == 0, - "CS_AppData.ResAppTblPtr[0].NumBytesToChecksum == 0"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].ComparisonValue == 0, "CS_AppData.ResAppTblPtr[0].ComparisonValue == 0"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].ByteOffset == 0, "CS_AppData.ResAppTblPtr[0].ByteOffset == 0"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].TempChecksumValue == 0, - "CS_AppData.ResAppTblPtr[0].TempChecksumValue == 0"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].StartAddress == 0, "CS_AppData.ResAppTblPtr[0].StartAddress == 0"); - UtAssert_True(CS_AppData.ResAppTblPtr[0].Name[0] == 0, "CS_AppData.ResAppTblPtr[0].Name[0] == 0"); - - UtAssert_True(CS_AppData.HkPacket.Payload.AppCSState == 99, "CS_AppData.HkPacket.Payload.AppCSState == 99"); - - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_PROCESS_APP_NO_ENTRIES_INF_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_INFORMATION); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_TableInit_Test_DefaultDefinitionTableLoadErrorEEPROM(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS received error 0x%%08X initializing Definition table for %%s"); - - /* Set to cause load from the default tables */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), -1); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefEepromTblPtr, - (void **)&CS_AppData.ResEepromTblPtr, CS_EEPROM_TABLE, CS_DEF_EEPROM_TABLE_NAME, - CS_RESULTS_EEPROM_TABLE_NAME, CS_MAX_NUM_EEPROM_TABLE_ENTRIES, CS_DEF_EEPROM_TABLE_FILENAME, - &CS_AppData.DefaultEepromDefTable, sizeof(CS_Def_EepromMemory_Table_Entry_t), - sizeof(CS_Res_EepromMemory_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(Result == -1, "Result == -1"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_TableInit_Test_DefinitionTableGetAddressErrorEEPROM(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS received error 0x%%08X initializing Definition table for %%s"); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to fail condition "Result >= CFE_SUCCESS" after 2nd call to GetAddress */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, -1); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefEepromTblPtr, - (void **)&CS_AppData.ResEepromTblPtr, CS_EEPROM_TABLE, CS_DEF_EEPROM_TABLE_NAME, - CS_RESULTS_EEPROM_TABLE_NAME, CS_MAX_NUM_EEPROM_TABLE_ENTRIES, CS_DEF_EEPROM_TABLE_FILENAME, - &CS_AppData.DefaultEepromDefTable, sizeof(CS_Def_EepromMemory_Table_Entry_t), - sizeof(CS_Res_EepromMemory_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(Result == -1, "Result == -1"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_TableInit_Test_DefinitionTableGetAddressErrorMemory(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS received error 0x%%08X initializing Definition table for %%s"); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to fail condition "Result >= CFE_SUCCESS" after 2nd call to GetAddress */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, -1); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefMemoryTblPtr, - (void **)&CS_AppData.ResMemoryTblPtr, CS_MEMORY_TABLE, CS_DEF_MEMORY_TABLE_NAME, - CS_RESULTS_MEMORY_TABLE_NAME, CS_MAX_NUM_MEMORY_TABLE_ENTRIES, CS_DEF_MEMORY_TABLE_FILENAME, - &CS_AppData.DefaultMemoryDefTable, sizeof(CS_Def_EepromMemory_Table_Entry_t), - sizeof(CS_Res_EepromMemory_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(Result == -1, "Result == -1"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_TableInit_Test_DefinitionTableGetAddressErrorTables(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS received error 0x%%08X initializing Definition table for %%s"); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to fail condition "Result >= CFE_SUCCESS" after 2nd call to GetAddress */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, -1); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefTablesTblPtr, - (void **)&CS_AppData.ResTablesTblPtr, CS_TABLES_TABLE, CS_DEF_TABLES_TABLE_NAME, - CS_RESULTS_TABLES_TABLE_NAME, CS_MAX_NUM_TABLES_TABLE_ENTRIES, CS_DEF_TABLES_TABLE_FILENAME, - &CS_AppData.DefaultTablesDefTable, sizeof(CS_Def_Tables_Table_Entry_t), - sizeof(CS_Res_Tables_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(Result == -1, "Result == -1"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_TableInit_Test_DefinitionTableGetAddressErrorApps(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH]; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH, - "CS received error 0x%%08X initializing Definition table for %%s"); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to fail condition "Result >= CFE_SUCCESS" after 2nd call to GetAddress */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, -1); - - /* Execute the function being tested */ - Result = - CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefAppTblPtr, - (void **)&CS_AppData.ResAppTblPtr, CS_APP_TABLE, CS_DEF_APP_TABLE_NAME, CS_RESULTS_APP_TABLE_NAME, - CS_MAX_NUM_APP_TABLE_ENTRIES, CS_DEF_APP_TABLE_FILENAME, &CS_AppData.DefaultAppDefTable, - sizeof(CS_Def_App_Table_Entry_t), sizeof(CS_Res_App_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - strCmpResult = strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(Result == -1, "Result == -1"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); -} - -void CS_TableInit_Test_EepromTableAndNotLoadedFromMemory(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to satisfy condition "Result == CFE_TBL_INFO_UPDATED" */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefEepromTblPtr, - (void **)&CS_AppData.ResEepromTblPtr, CS_EEPROM_TABLE, CS_DEF_EEPROM_TABLE_NAME, - CS_RESULTS_EEPROM_TABLE_NAME, CS_MAX_NUM_EEPROM_TABLE_ENTRIES, CS_DEF_EEPROM_TABLE_FILENAME, - &CS_AppData.DefaultEepromDefTable, sizeof(CS_Def_EepromMemory_Table_Entry_t), - sizeof(CS_Res_EepromMemory_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); - /* Generates 1 error message we don't care about in this test */ -} - -void CS_TableInit_Test_EepromTableAndLoadedFromMemoryAfterResultsTableRegisterError(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - - /* Set to satisfy condition "ResultFromLoad != CFE_SUCCESS" */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Register), 1, -1); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefEepromTblPtr, - (void **)&CS_AppData.ResEepromTblPtr, CS_EEPROM_TABLE, CS_DEF_EEPROM_TABLE_NAME, - CS_RESULTS_EEPROM_TABLE_NAME, CS_MAX_NUM_EEPROM_TABLE_ENTRIES, CS_DEF_EEPROM_TABLE_FILENAME, - &CS_AppData.DefaultEepromDefTable, sizeof(CS_Def_EepromMemory_Table_Entry_t), - sizeof(CS_Res_EepromMemory_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_INT32_EQ(Result, -1); - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); -} - -void CS_TableInit_Test_EepromTableAndLoadedFromMemoryAfterResultsTableGetAddressError(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* On 1st call, return -1 to set LoadedFromMemory. On 2nd call, return CFE_SUCCESS to prevent error */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 1, -1); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefEepromTblPtr, - (void **)&CS_AppData.ResEepromTblPtr, CS_EEPROM_TABLE, CS_DEF_EEPROM_TABLE_NAME, - CS_RESULTS_EEPROM_TABLE_NAME, CS_MAX_NUM_EEPROM_TABLE_ENTRIES, CS_DEF_EEPROM_TABLE_FILENAME, - &CS_AppData.DefaultEepromDefTable, sizeof(CS_Def_EepromMemory_Table_Entry_t), - sizeof(CS_Res_EepromMemory_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_INT32_EQ(Result, -1); - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); -} - -void CS_TableInit_Test_EepromTableAndLoadedFromMemoryAfterDefinitionTableRegisterError(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - - /* Set to satisfy condition "ResultFromLoad != CFE_SUCCESS" on 2nd call to TBL_Register */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Register), 2, -1); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefEepromTblPtr, - (void **)&CS_AppData.ResEepromTblPtr, CS_EEPROM_TABLE, CS_DEF_EEPROM_TABLE_NAME, - CS_RESULTS_EEPROM_TABLE_NAME, CS_MAX_NUM_EEPROM_TABLE_ENTRIES, CS_DEF_EEPROM_TABLE_FILENAME, - &CS_AppData.DefaultEepromDefTable, sizeof(CS_Def_EepromMemory_Table_Entry_t), - sizeof(CS_Res_EepromMemory_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_INT32_EQ(Result, -1); - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_INIT_ERR_EID); -} - -void CS_TableInit_Test_EepromTableAndLoadedFromMemoryAfterDefinitionTableFileLoadError(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - - /* So this can detect the switch to DISABLED */ - CS_AppData.HkPacket.Payload.EepromCSState = CS_STATE_ENABLED; - - /* On 1st call, return -1 to satisfy condition "ResultFromLoad != CFE_SUCCESS". On 2nd call, return CFE_SUCCESS to - * prevent error */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Load), 1, -1); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefEepromTblPtr, - (void **)&CS_AppData.ResEepromTblPtr, CS_EEPROM_TABLE, CS_DEF_EEPROM_TABLE_NAME, - CS_RESULTS_EEPROM_TABLE_NAME, CS_MAX_NUM_EEPROM_TABLE_ENTRIES, CS_DEF_EEPROM_TABLE_FILENAME, - &CS_AppData.DefaultEepromDefTable, sizeof(CS_Def_EepromMemory_Table_Entry_t), - sizeof(CS_Res_EepromMemory_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.EepromCSState, CS_STATE_DISABLED); - UtAssert_INT32_EQ(Result, CFE_SUCCESS); - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - -void CS_TableInit_Test_MemoryTableAndNotLoadedFromMemory(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - - /* So this can detect a switch */ - CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_ENABLED; - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to satisfy condition "Result == CFE_TBL_INFO_UPDATED" */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefMemoryTblPtr, - (void **)&CS_AppData.ResMemoryTblPtr, CS_MEMORY_TABLE, CS_DEF_MEMORY_TABLE_NAME, - CS_RESULTS_MEMORY_TABLE_NAME, CS_MAX_NUM_MEMORY_TABLE_ENTRIES, CS_DEF_MEMORY_TABLE_FILENAME, - &CS_AppData.DefaultMemoryDefTable, sizeof(CS_Def_EepromMemory_Table_Entry_t), - sizeof(CS_Res_EepromMemory_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.MemoryCSState, CS_STATE_ENABLED); - UtAssert_INT32_EQ(Result, CFE_SUCCESS); - - /* Note this may generate an event in the new table processing, checked in other test */ -} - -void CS_TableInit_Test_MemoryTableAndLoadedFromMemory(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - - /* So this can detect a switch */ - CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_ENABLED; - - /* First call fails so it proceeds to load from memory */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Load), 1, -1); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefMemoryTblPtr, - (void **)&CS_AppData.ResMemoryTblPtr, CS_MEMORY_TABLE, CS_DEF_MEMORY_TABLE_NAME, - CS_RESULTS_MEMORY_TABLE_NAME, CS_MAX_NUM_MEMORY_TABLE_ENTRIES, CS_DEF_MEMORY_TABLE_FILENAME, - &CS_AppData.DefaultMemoryDefTable, sizeof(CS_Def_EepromMemory_Table_Entry_t), - sizeof(CS_Res_EepromMemory_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.MemoryCSState, CS_STATE_DISABLED); - UtAssert_INT32_EQ(Result, CFE_SUCCESS); - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - -void CS_TableInit_Test_AppTableAndNotLoadedFromMemory(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - - /* So this can detect a switch */ - CS_AppData.HkPacket.Payload.AppCSState = CS_STATE_ENABLED; - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to satisfy condition "Result == CFE_TBL_INFO_UPDATED" */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); - - /* Execute the function being tested */ - Result = - CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefAppTblPtr, - (void **)&CS_AppData.ResAppTblPtr, CS_APP_TABLE, CS_DEF_APP_TABLE_NAME, CS_RESULTS_APP_TABLE_NAME, - CS_MAX_NUM_APP_TABLE_ENTRIES, CS_DEF_APP_TABLE_FILENAME, &CS_AppData.DefaultAppDefTable, - sizeof(CS_Def_App_Table_Entry_t), sizeof(CS_Res_App_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.AppCSState, CS_STATE_ENABLED); - UtAssert_INT32_EQ(Result, CFE_SUCCESS); - /* Note this may generate an event in the new table processing, checked in other test */ -} - -void CS_TableInit_Test_AppTableAndLoadedFromMemory(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - - /* So this can detect a switch */ - CS_AppData.HkPacket.Payload.AppCSState = CS_STATE_ENABLED; - - /* Set to satisfy condition "ResultFromLoad != CFE_SUCCESS" */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Load), 1, -1); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); - - /* Execute the function being tested */ - Result = - CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefAppTblPtr, - (void **)&CS_AppData.ResAppTblPtr, CS_APP_TABLE, CS_DEF_APP_TABLE_NAME, CS_RESULTS_APP_TABLE_NAME, - CS_MAX_NUM_APP_TABLE_ENTRIES, CS_DEF_APP_TABLE_FILENAME, &CS_AppData.DefaultAppDefTable, - sizeof(CS_Def_App_Table_Entry_t), sizeof(CS_Res_App_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.AppCSState, CS_STATE_DISABLED); - UtAssert_INT32_EQ(Result, CFE_SUCCESS); - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - -void CS_TableInit_Test_TablesTableAndNotLoadedFromMemory(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - - /* So this can detect a switch */ - CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_ENABLED; - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to satisfy condition "Result == CFE_TBL_INFO_UPDATED" */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefTablesTblPtr, - (void **)&CS_AppData.ResTablesTblPtr, CS_TABLES_TABLE, CS_DEF_TABLES_TABLE_NAME, - CS_RESULTS_TABLES_TABLE_NAME, CS_MAX_NUM_TABLES_TABLE_ENTRIES, CS_DEF_TABLES_TABLE_FILENAME, - &CS_AppData.DefaultTablesDefTable, sizeof(CS_Def_Tables_Table_Entry_t), - sizeof(CS_Res_Tables_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.TablesCSState, CS_STATE_ENABLED); - UtAssert_INT32_EQ(Result, CFE_SUCCESS); - /* Note this may generate an event in the new table processing, checked in other test */ -} - -void CS_TableInit_Test_TablesTableAndLoadedFromMemory(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - - /* So this can detect a switch */ - CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_ENABLED; - - /* Set to satisfy condition "ResultFromLoad != CFE_SUCCESS" */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Load), 1, -1); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); - - /* Execute the function being tested */ - Result = CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefTablesTblPtr, - (void **)&CS_AppData.ResTablesTblPtr, CS_TABLES_TABLE, CS_DEF_TABLES_TABLE_NAME, - CS_RESULTS_TABLES_TABLE_NAME, CS_MAX_NUM_TABLES_TABLE_ENTRIES, CS_DEF_TABLES_TABLE_FILENAME, - &CS_AppData.DefaultTablesDefTable, sizeof(CS_Def_Tables_Table_Entry_t), - sizeof(CS_Res_Tables_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.TablesCSState, CS_STATE_DISABLED); - UtAssert_INT32_EQ(Result, CFE_SUCCESS); - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - -void CS_TableInit_Test_DefaultAndLoadedFromMemory(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - - /* Note this is not really a valid case; this only covers a possible path - * where the table ID value is not one of the expected values. It exists - * to satisfy branch coverage */ - - /* Set to satisfy condition "ResultFromLoad != CFE_SUCCESS" */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_Load), 1, -1); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Load), CFE_SUCCESS); - - /* Set to prevent unintended errors */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_SUCCESS); - - /* Execute the function being tested */ - Result = - CS_TableInit(&DefinitionTableHandle, &ResultsTableHandle, (void **)&CS_AppData.DefTablesTblPtr, - (void **)&CS_AppData.ResTablesTblPtr, 99, CS_DEF_TABLES_TABLE_NAME, CS_RESULTS_TABLES_TABLE_NAME, - CS_MAX_NUM_TABLES_TABLE_ENTRIES, CS_DEF_TABLES_TABLE_FILENAME, &CS_AppData.DefaultTablesDefTable, - sizeof(CS_Def_Tables_Table_Entry_t), sizeof(CS_Res_Tables_Table_Entry_t), NULL); - - /* Verify results */ - UtAssert_INT32_EQ(Result, CFE_SUCCESS); - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} - -void CS_HandleTableUpdate_Test_ProcessNewTablesDefinitionTable(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - uint16 Table = CS_TABLES_TABLE; - - void *DefTblPtr = CS_AppData.DefTablesTblPtr; - void *ResultTblPtr = CS_AppData.ResTablesTblPtr; - - /* On 1st call, return CFE_SUCCESS to prevent error. On 2nd call, return UT_CFE_TBL_GETADDRESS_INDEX to satisfy - * condition "Result == CFE_TBL_INFO_UPDATED". */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); - - CS_AppData.ResTablesTblPtr[0].TblHandle = 99; - CS_AppData.ResTablesTblPtr[0].IsCSOwner = false; - - /* Execute the function being tested */ - Result = CS_HandleTableUpdate(&DefTblPtr, &ResultTblPtr, DefinitionTableHandle, ResultsTableHandle, Table, - CS_MAX_NUM_TABLES_TABLE_ENTRIES); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); - /* Generates 1 event message we don't care about in this test */ -} - -void CS_HandleTableUpdate_Test_ProcessNewAppDefinitionTable(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - uint16 Table = CS_APP_TABLE; - uint16 NumEntries = 0; - - void *DefTblPtr = CS_AppData.DefAppTblPtr; - void *ResultTblPtr = CS_AppData.ResAppTblPtr; - - /* On 1st call, return CFE_SUCCESS to prevent error. On 2nd call, return UT_CFE_TBL_GETADDRESS_INDEX to satisfy - * condition "Result == CFE_TBL_INFO_UPDATED". */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); - - /* Execute the function being tested */ - Result = - CS_HandleTableUpdate(&DefTblPtr, &ResultTblPtr, DefinitionTableHandle, ResultsTableHandle, Table, NumEntries); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); - /* Generates 1 error message we don't care about in this test */ -} - -void CS_HandleTableUpdate_Test_ProcessNewEepromMemoryDefinitionTable(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - uint16 Table = CS_EEPROM_TABLE; - uint16 NumEntries = CS_MAX_NUM_EEPROM_TABLE_ENTRIES; - - void *DefTblPtr = CS_AppData.DefEepromTblPtr; - void *ResultTblPtr = CS_AppData.ResEepromTblPtr; - - /* On 1st call, return CFE_SUCCESS to prevent error. On 2nd call, return UT_CFE_TBL_GETADDRESS_INDEX to satisfy - * condition "Result == CFE_TBL_INFO_UPDATED". */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); - - /* Execute the function being tested */ - Result = - CS_HandleTableUpdate(&DefTblPtr, &ResultTblPtr, DefinitionTableHandle, ResultsTableHandle, Table, NumEntries); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); - /* Generates 1 error message we don't care about in this test */ -} - -void CS_HandleTableUpdate_Test_ResultsTableGetAddressErrorEEPROM(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - uint16 Table = CS_EEPROM_TABLE; - uint16 NumEntries = 0; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH * 2]; - - void *DefTblPtr = CS_AppData.DefEepromTblPtr; - void *ResultTblPtr = CS_AppData.ResEepromTblPtr; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH * 2, - "CS had problems updating table. Res Release: 0x%%08X Def Release:0x%%08X Res Manage:0x%%08X Def Manage: " - "0x%%08X Get:0x%%08X for table %%s"); - - /* Set to generate error message CS_TBL_UPDATE_ERR_EID */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 1, -1); - - /* Execute the function being tested */ - Result = - CS_HandleTableUpdate(&DefTblPtr, &ResultTblPtr, DefinitionTableHandle, ResultsTableHandle, Table, NumEntries); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_UPDATE_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - /* Ignore last char in case it was truncated */ - strCmpResult = - strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH - 1); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(Result == -1, "Result == -1"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); - /* Generates 1 error message we don't care about in this test */ -} - -void CS_HandleTableUpdate_Test_DefinitionTableGetAddressErrorEEPROM(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - uint16 Table = CS_EEPROM_TABLE; - uint16 NumEntries = 0; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH * 2]; - - void *DefTblPtr = NULL; - void *ResultTblPtr = NULL; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH * 2, - "CS had problems updating table. Res Release: 0x%%08X Def Release:0x%%08X Res Manage:0x%%08X Def Manage: " - "0x%%08X Get:0x%%08X for table %%s"); - - /* Set to generate error message CS_TBL_UPDATE_ERR_EID. Also prevent issues by returning CFE_SUCCESS on all calls - * except the 2nd. */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, -1); - - /* Execute the function being tested */ - Result = - CS_HandleTableUpdate(&DefTblPtr, &ResultTblPtr, DefinitionTableHandle, ResultsTableHandle, Table, NumEntries); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_UPDATE_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - /* Ignore last char in case it was truncated */ - strCmpResult = - strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH - 1); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(Result == -1, "Result == -1"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); - /* Generates 1 error message we don't care about in this test */ -} - -void CS_HandleTableUpdate_Test_DefinitionTableGetAddressErrorMemory(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - uint16 Table = CS_MEMORY_TABLE; - uint16 NumEntries = 0; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH * 2]; - - void *DefTblPtr = CS_AppData.DefMemoryTblPtr; - void *ResultTblPtr = CS_AppData.ResMemoryTblPtr; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH * 2, - "CS had problems updating table. Res Release: 0x%%08X Def Release:0x%%08X Res Manage:0x%%08X Def Manage: " - "0x%%08X Get:0x%%08X for table %%s"); - - /* Set to generate error message CS_TBL_UPDATE_ERR_EID. Also prevent issues by returning CFE_SUCCESS on all calls - * except the 2nd. */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, -1); - - /* Execute the function being tested */ - Result = - CS_HandleTableUpdate(&DefTblPtr, &ResultTblPtr, DefinitionTableHandle, ResultsTableHandle, Table, NumEntries); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_UPDATE_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - /* Ignore last char in case it was truncated */ - strCmpResult = - strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH - 1); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(Result == -1, "Result == -1"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); - /* Generates 1 error message we don't care about in this test */ -} - -void CS_HandleTableUpdate_Test_DefinitionTableGetAddressErrorTables(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - uint16 Table = CS_TABLES_TABLE; - uint16 NumEntries = 0; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH * 2]; - - void *DefTblPtr = CS_AppData.DefTablesTblPtr; - void *ResultTblPtr = CS_AppData.ResTablesTblPtr; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH * 2, - "CS had problems updating table. Res Release: 0x%%08X Def Release:0x%%08X Res Manage:0x%%08X Def Manage: " - "0x%%08X Get:0x%%08X for table %%s"); - - /* Set to generate error message CS_TBL_UPDATE_ERR_EID. Also prevent issues by returning CFE_SUCCESS on all calls - * except the 2nd. */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, -1); - - /* Execute the function being tested */ - Result = - CS_HandleTableUpdate(&DefTblPtr, &ResultTblPtr, DefinitionTableHandle, ResultsTableHandle, Table, NumEntries); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_UPDATE_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - /* Ignore last char in case it was truncated */ - strCmpResult = - strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH - 1); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(Result == -1, "Result == -1"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); - /* Generates 1 error message we don't care about in this test */ -} - -void CS_HandleTableUpdate_Test_DefinitionTableGetAddressErrorApps(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - uint16 Table = CS_APP_TABLE; - uint16 NumEntries = 0; - int32 strCmpResult; - char ExpectedEventString[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH * 2]; - - void *DefTblPtr = CS_AppData.DefAppTblPtr; - void *ResultTblPtr = CS_AppData.ResAppTblPtr; - - snprintf(ExpectedEventString, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH * 2, - "CS had problems updating table. Res Release: 0x%%08X Def Release:0x%%08X Res Manage:0x%%08X Def Manage: " - "0x%%08X Get:0x%%08X for table %%s"); - - /* Set to generate error message CS_TBL_UPDATE_ERR_EID. Also prevent issues by returning CFE_SUCCESS on all calls - * except the 2nd. */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, -1); - - /* Execute the function being tested */ - Result = - CS_HandleTableUpdate(&DefTblPtr, &ResultTblPtr, DefinitionTableHandle, ResultsTableHandle, Table, NumEntries); - - /* Verify results */ - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_TBL_UPDATE_ERR_EID); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventType, CFE_EVS_EventType_ERROR); - - /* Ignore last char in case it was truncated */ - strCmpResult = - strncmp(ExpectedEventString, context_CFE_EVS_SendEvent[0].Spec, CFE_MISSION_EVS_MAX_MESSAGE_LENGTH - 1); - - UtAssert_True(strCmpResult == 0, "Event string matched expected result, '%s'", context_CFE_EVS_SendEvent[0].Spec); - - UtAssert_True(Result == -1, "Result == -1"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); - /* Generates 1 error message we don't care about in this test */ -} - -void CS_HandleTableUpdate_Test_BadTableHandle(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - uint16 Table = CS_TABLES_TABLE; - - void *DefTblPtr = CS_AppData.DefTablesTblPtr; - void *ResultTblPtr = CS_AppData.ResTablesTblPtr; - - /* On 1st call, return CFE_SUCCESS to prevent error. On 2nd call, return UT_CFE_TBL_GETADDRESS_INDEX to satisfy - * condition "Result == CFE_TBL_INFO_UPDATED". */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); - - CS_AppData.ResTablesTblPtr[0].TblHandle = CFE_TBL_BAD_TABLE_HANDLE; - CS_AppData.ResTablesTblPtr[0].IsCSOwner = true; - - /* Execute the function being tested */ - Result = CS_HandleTableUpdate(&DefTblPtr, &ResultTblPtr, DefinitionTableHandle, ResultsTableHandle, Table, - CS_MAX_NUM_TABLES_TABLE_ENTRIES); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); - /* Generates 1 event message we don't care about in this test */ -} - -void CS_HandleTableUpdate_Test_CsOwner(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - uint16 Table = CS_TABLES_TABLE; - - void *DefTblPtr = CS_AppData.DefTablesTblPtr; - void *ResultTblPtr = CS_AppData.ResTablesTblPtr; - - /* On 1st call, return CFE_SUCCESS to prevent error. On 2nd call, return UT_CFE_TBL_GETADDRESS_INDEX to satisfy - * condition "Result == CFE_TBL_INFO_UPDATED". */ - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); - - CS_AppData.ResTablesTblPtr[0].TblHandle = 99; - CS_AppData.ResTablesTblPtr[0].IsCSOwner = true; - - /* Execute the function being tested */ - Result = CS_HandleTableUpdate(&DefTblPtr, &ResultTblPtr, DefinitionTableHandle, ResultsTableHandle, Table, - CS_MAX_NUM_TABLES_TABLE_ENTRIES); - - /* Verify results */ - UtAssert_True(Result == CFE_SUCCESS, "Result == CFE_SUCCESS"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 1, "CFE_EVS_SendEvent was called %u time(s), expected 1", - call_count_CFE_EVS_SendEvent); - /* Generates 1 event message we don't care about in this test */ -} - -void CS_HandleTableUpdate_Test_GetAddressError(void) -{ - CFE_Status_t Result; - CFE_TBL_Handle_t DefinitionTableHandle = 0; - CFE_TBL_Handle_t ResultsTableHandle = 0; - uint16 Table = CS_TABLES_TABLE; - - void *DefTblPtr = CS_AppData.DefTablesTblPtr; - void *ResultTblPtr = CS_AppData.ResTablesTblPtr; - - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 1, 1); - - CS_AppData.ResTablesTblPtr[0].TblHandle = 99; - CS_AppData.ResTablesTblPtr[0].IsCSOwner = true; - - /* Execute the function being tested */ - Result = CS_HandleTableUpdate(&DefTblPtr, &ResultTblPtr, DefinitionTableHandle, ResultsTableHandle, Table, - CS_MAX_NUM_TABLES_TABLE_ENTRIES); - - /* Verify results */ - UtAssert_True(Result == 1, "Result == 1"); - - call_count_CFE_EVS_SendEvent = UT_GetStubCount(UT_KEY(CFE_EVS_SendEvent)); - - UtAssert_True(call_count_CFE_EVS_SendEvent == 0, "CFE_EVS_SendEvent was called %u time(s), expected 0", - call_count_CFE_EVS_SendEvent); -} - -void CS_HandleTableUpdate_Test_InvalidTable(void) -{ - CFE_TBL_Handle_t DefinitionTableHandle = CFE_TBL_BAD_TABLE_HANDLE; - CFE_TBL_Handle_t ResultsTableHandle = CFE_TBL_BAD_TABLE_HANDLE; - uint16 Table = CS_NUM_TABLES + 1; - uint32 Temp1; - uint32 Temp2; - - void *DefTblPtr = &Temp1; - void *ResultTblPtr = &Temp2; - - UT_SetDeferredRetcode(UT_KEY(CFE_TBL_GetAddress), 2, CFE_TBL_INFO_UPDATED); + /* nominal */ + tw->UpdateHandler = CS_UT_UpdateHandler; + UtAssert_VOIDCALL(CS_CallTableUpdateHandler(tw)); + UtAssert_STUB_COUNT(CS_UT_UpdateHandler, 1); - /* Execute the function being tested */ - UtAssert_INT32_EQ( - CS_HandleTableUpdate(&DefTblPtr, &ResultTblPtr, DefinitionTableHandle, ResultsTableHandle, Table, 1), - CFE_SUCCESS); + /* unset */ + tw->UpdateHandler = NULL; + UtAssert_VOIDCALL(CS_CallTableUpdateHandler(tw)); + UtAssert_STUB_COUNT(CS_UT_UpdateHandler, 1); } void UtTest_Setup(void) { - UtTest_Add(CS_ValidateEepromChecksumDefinitionTable_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateEepromChecksumDefinitionTable_Test_Nominal"); - UtTest_Add(CS_ValidateEepromChecksumDefinitionTable_Test_IllegalChecksumRangeStateEnabled, CS_Test_Setup, - CS_Test_TearDown, "CS_ValidateEepromChecksumDefinitionTable_Test_IllegalChecksumRangeStateEnabled"); - UtTest_Add(CS_ValidateEepromChecksumDefinitionTable_Test_IllegalChecksumRangeStateDisabled, CS_Test_Setup, - CS_Test_TearDown, "CS_ValidateEepromChecksumDefinitionTable_Test_IllegalChecksumRangeStateDisabled"); - UtTest_Add(CS_ValidateEepromChecksumDefinitionTable_Test_IllegalStateField, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateEepromChecksumDefinitionTable_Test_IllegalStateField"); - UtTest_Add(CS_ValidateEepromChecksumDefinitionTable_Test_TableErrorResult, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateEepromChecksumDefinitionTable_Test_TableErrorResult"); - UtTest_Add(CS_ValidateEepromChecksumDefinitionTable_Test_UndefTableErrorResult, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateEepromChecksumDefinitionTable_Test_UndefTableErrorResult"); - - UtTest_Add(CS_ValidateMemoryChecksumDefinitionTable_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateMemoryChecksumDefinitionTable_Test_Nominal"); - UtTest_Add(CS_ValidateMemoryChecksumDefinitionTable_Test_IllegalChecksumRangeStateEnabled, CS_Test_Setup, - CS_Test_TearDown, "CS_ValidateMemoryChecksumDefinitionTable_Test_IllegalChecksumRangeStateEnabled"); - UtTest_Add(CS_ValidateMemoryChecksumDefinitionTable_Test_IllegalChecksumRangeStateDisabled, CS_Test_Setup, - CS_Test_TearDown, "CS_ValidateMemoryChecksumDefinitionTable_Test_IllegalChecksumRangeStateDisabled"); - UtTest_Add(CS_ValidateMemoryChecksumDefinitionTable_Test_IllegalStateField, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateMemoryChecksumDefinitionTable_Test_IllegalStateField"); - UtTest_Add(CS_ValidateMemoryChecksumDefinitionTable_Test_TableErrorResult, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateMemoryChecksumDefinitionTable_Test_TableErrorResult"); - UtTest_Add(CS_ValidateMemoryChecksumDefinitionTable_Test_UndefTableErrorResult, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateMemoryChecksumDefinitionTable_Test_UndefTableErrorResult"); - - UtTest_Add(CS_ValidateTablesChecksumDefinitionTable_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateTablesChecksumDefinitionTable_Test_Nominal"); - UtTest_Add(CS_ValidateTablesChecksumDefinitionTable_Test_DuplicateNameStateEmpty, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateTablesChecksumDefinitionTable_Test_DuplicateNameStateEmpty"); - UtTest_Add(CS_ValidateTablesChecksumDefinitionTable_Test_DuplicateNameStateEnabled, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateTablesChecksumDefinitionTable_Test_DuplicateNameStateEnabled"); - UtTest_Add(CS_ValidateTablesChecksumDefinitionTable_Test_DuplicateNameStateDisabled, CS_Test_Setup, - CS_Test_TearDown, "CS_ValidateTablesChecksumDefinitionTable_Test_DuplicateNameStateDisabled"); - UtTest_Add(CS_ValidateTablesChecksumDefinitionTable_Test_IllegalStateField, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateTablesChecksumDefinitionTable_Test_IllegalStateField"); - UtTest_Add(CS_ValidateTablesChecksumDefinitionTable_Test_IllegalStateEmptyName, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateTablesChecksumDefinitionTable_Test_IllegalStateEmptyName"); - UtTest_Add(CS_ValidateTablesChecksumDefinitionTable_Test_TableErrorResult, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateTablesChecksumDefinitionTable_Test_TableErrorResult"); - UtTest_Add(CS_ValidateTablesChecksumDefinitionTable_Test_UndefTableErrorResult, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateTablesChecksumDefinitionTable_Test_UndefTableErrorResult"); - UtTest_Add(CS_ValidateTablesChecksumDefinitionTable_Test_CsTableError, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateTablesChecksumDefinitionTable_Test_CsTableError"); - - UtTest_Add(CS_ValidateAppChecksumDefinitionTable_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateAppChecksumDefinitionTable_Test_Nominal"); - UtTest_Add(CS_ValidateAppChecksumDefinitionTable_Test_DuplicateNameStateEmpty, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateAppChecksumDefinitionTable_Test_DuplicateNameStateEmpty"); - UtTest_Add(CS_ValidateAppChecksumDefinitionTable_Test_DuplicateNameStateEnabled, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateAppChecksumDefinitionTable_Test_DuplicateNameStateEnabled"); - UtTest_Add(CS_ValidateAppChecksumDefinitionTable_Test_DuplicateNameStateDisabled, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateAppChecksumDefinitionTable_Test_DuplicateNameStateDisabled"); - UtTest_Add(CS_ValidateAppChecksumDefinitionTable_Test_IllegalStateField, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateAppChecksumDefinitionTable_Test_IllegalStateField"); - UtTest_Add(CS_ValidateAppChecksumDefinitionTable_Test_IllegalStateEmptyName, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateAppChecksumDefinitionTable_Test_IllegalStateEmptyName"); - UtTest_Add(CS_ValidateAppChecksumDefinitionTable_Test_LongName, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateAppChecksumDefinitionTable_Test_LongName"); - UtTest_Add(CS_ValidateAppChecksumDefinitionTable_Test_TableErrorResult, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateAppChecksumDefinitionTable_Test_TableErrorResult"); - UtTest_Add(CS_ValidateAppChecksumDefinitionTable_Test_UndefTableErrorResult, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateAppChecksumDefinitionTable_Test_UndefTableErrorResult"); - UtTest_Add(CS_ValidateAppChecksumDefinitionTable_Test_EmptyNameTableResult, CS_Test_Setup, CS_Test_TearDown, - "CS_ValidateAppChecksumDefinitionTable_Test_EmptyNameTableResult"); - - UtTest_Add(CS_ProcessNewEepromMemoryDefinitionTable_Test_EEPROMTableNominal, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewEepromMemoryDefinitionTable_Test_EEPROMTableNominal"); - UtTest_Add(CS_ProcessNewEepromMemoryDefinitionTable_Test_MemoryTableNominal, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewEepromMemoryDefinitionTable_Test_MemoryTableNominal"); - UtTest_Add(CS_ProcessNewEepromMemoryDefinitionTable_Test_EEPROMTableNoValidEntries, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewEepromMemoryDefinitionTable_Test_EEPROMTableNoValidEntries"); - UtTest_Add(CS_ProcessNewEepromMemoryDefinitionTable_Test_MemoryTableNoValidEntries, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewEepromMemoryDefinitionTable_Test_MemoryTableNoValidEntries"); - - UtTest_Add(CS_ProcessNewTablesDefinitionTable_Test_DefEepromTableHandle, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewTablesDefinitionTable_Test_DefEepromTableHandle"); - UtTest_Add(CS_ProcessNewTablesDefinitionTable_Test_DefMemoryTableHandle, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewTablesDefinitionTable_Test_DefMemoryTableHandle"); - UtTest_Add(CS_ProcessNewTablesDefinitionTable_Test_DefTablesTableHandle, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewTablesDefinitionTable_Test_DefTablesTableHandle"); - UtTest_Add(CS_ProcessNewTablesDefinitionTable_Test_DefAppTableHandle, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewTablesDefinitionTable_Test_DefAppTableHandle"); - UtTest_Add(CS_ProcessNewTablesDefinitionTable_Test_ResEepromTableHandle, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewTablesDefinitionTable_Test_ResEepromTableHandle"); - UtTest_Add(CS_ProcessNewTablesDefinitionTable_Test_ResMemoryTableHandle, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewTablesDefinitionTable_Test_ResMemoryTableHandle"); - UtTest_Add(CS_ProcessNewTablesDefinitionTable_Test_ResTablesTableHandle, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewTablesDefinitionTable_Test_ResTablesTableHandle"); - UtTest_Add(CS_ProcessNewTablesDefinitionTable_Test_ResAppTableHandle, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewTablesDefinitionTable_Test_ResAppTableHandle"); - UtTest_Add(CS_ProcessNewTablesDefinitionTable_Test_StateEmptyNoValidEntries, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewTablesDefinitionTable_Test_StateEmptyNoValidEntries"); - UtTest_Add(CS_ProcessNewTablesDefinitionTable_Test_LimitApplicationNameLength, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewTablesDefinitionTable_Test_LimitApplicationNameLength"); - UtTest_Add(CS_ProcessNewTablesDefinitionTable_Test_LimitTableNameLength, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewTablesDefinitionTable_Test_LimitTableNameLength"); - UtTest_Add(CS_ProcessNewTablesDefinitionTable_Test_MaxTableNameLength, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewTablesDefinitionTable_Test_MaxTableNameLength"); - - UtTest_Add(CS_ProcessNewAppDefinitionTable_Test_Nominal, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewAppDefinitionTable_Test_Nominal"); - UtTest_Add(CS_ProcessNewAppDefinitionTable_Test_StateEmptyNoValidEntries, CS_Test_Setup, CS_Test_TearDown, - "CS_ProcessNewAppDefinitionTable_Test_StateEmptyNoValidEntries"); - - UtTest_Add(CS_TableInit_Test_DefaultDefinitionTableLoadErrorEEPROM, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_DefaultDefinitionTableLoadErrorEEPROM"); - UtTest_Add(CS_TableInit_Test_DefinitionTableGetAddressErrorEEPROM, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_DefinitionTableGetAddressErrorEEPROM"); - UtTest_Add(CS_TableInit_Test_DefinitionTableGetAddressErrorMemory, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_DefinitionTableGetAddressErrorMemory"); - UtTest_Add(CS_TableInit_Test_DefinitionTableGetAddressErrorTables, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_DefinitionTableGetAddressErrorTables"); - UtTest_Add(CS_TableInit_Test_DefinitionTableGetAddressErrorApps, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_DefinitionTableGetAddressErrorApps"); - UtTest_Add(CS_TableInit_Test_EepromTableAndNotLoadedFromMemory, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_EepromTableAndNotLoadedFromMemory"); - UtTest_Add(CS_TableInit_Test_EepromTableAndLoadedFromMemoryAfterResultsTableRegisterError, CS_Test_Setup, - CS_Test_TearDown, "CS_TableInit_Test_EepromTableAndLoadedFromMemoryAfterResultsTableRegisterError"); - UtTest_Add(CS_TableInit_Test_EepromTableAndLoadedFromMemoryAfterResultsTableGetAddressError, CS_Test_Setup, - CS_Test_TearDown, "CS_TableInit_Test_EepromTableAndLoadedFromMemoryAfterResultsTableGetAddressError"); - UtTest_Add(CS_TableInit_Test_EepromTableAndLoadedFromMemoryAfterDefinitionTableRegisterError, CS_Test_Setup, - CS_Test_TearDown, "CS_TableInit_Test_EepromTableAndLoadedFromMemoryAfterDefinitionTableRegisterError"); - UtTest_Add(CS_TableInit_Test_EepromTableAndLoadedFromMemoryAfterDefinitionTableFileLoadError, CS_Test_Setup, - CS_Test_TearDown, "CS_TableInit_Test_EepromTableAndLoadedFromMemoryAfterDefinitionTableFileLoadError"); - UtTest_Add(CS_TableInit_Test_MemoryTableAndNotLoadedFromMemory, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_MemoryTableAndNotLoadedFromMemory"); - UtTest_Add(CS_TableInit_Test_MemoryTableAndLoadedFromMemory, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_MemoryTableAndLoadedFromMemory"); - UtTest_Add(CS_TableInit_Test_AppTableAndNotLoadedFromMemory, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_AppTableAndNotLoadedFromMemory"); - UtTest_Add(CS_TableInit_Test_AppTableAndLoadedFromMemory, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_AppTableAndLoadedFromMemory"); - UtTest_Add(CS_TableInit_Test_TablesTableAndNotLoadedFromMemory, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_TablesTableAndNotLoadedFromMemory"); - UtTest_Add(CS_TableInit_Test_TablesTableAndLoadedFromMemory, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_TablesTableAndLoadedFromMemory"); - UtTest_Add(CS_TableInit_Test_DefaultAndLoadedFromMemory, CS_Test_Setup, CS_Test_TearDown, - "CS_TableInit_Test_DefaultAndLoadedFromMemory"); - - UtTest_Add(CS_HandleTableUpdate_Test_ProcessNewTablesDefinitionTable, CS_Test_Setup, CS_Test_TearDown, - "CS_HandleTableUpdate_Test_ProcessNewTablesDefinitionTable"); - UtTest_Add(CS_HandleTableUpdate_Test_ProcessNewAppDefinitionTable, CS_Test_Setup, CS_Test_TearDown, - "CS_HandleTableUpdate_Test_ProcessNewAppDefinitionTable"); - UtTest_Add(CS_HandleTableUpdate_Test_ProcessNewEepromMemoryDefinitionTable, CS_Test_Setup, CS_Test_TearDown, - "CS_HandleTableUpdate_Test_ProcessNewEepromMemoryDefinitionTable"); - UtTest_Add(CS_HandleTableUpdate_Test_ResultsTableGetAddressErrorEEPROM, CS_Test_Setup, CS_Test_TearDown, - "CS_HandleTableUpdate_Test_ResultsTableGetAddressErrorEEPROM"); - UtTest_Add(CS_HandleTableUpdate_Test_DefinitionTableGetAddressErrorEEPROM, CS_Test_Setup, CS_Test_TearDown, - "CS_HandleTableUpdate_Test_DefinitionTableGetAddressErrorEEPROM"); - UtTest_Add(CS_HandleTableUpdate_Test_DefinitionTableGetAddressErrorMemory, CS_Test_Setup, CS_Test_TearDown, - "CS_HandleTableUpdate_Test_DefinitionTableGetAddressErrorMemory"); - UtTest_Add(CS_HandleTableUpdate_Test_DefinitionTableGetAddressErrorTables, CS_Test_Setup, CS_Test_TearDown, - "CS_HandleTableUpdate_Test_DefinitionTableGetAddressErrorTables"); - UtTest_Add(CS_HandleTableUpdate_Test_DefinitionTableGetAddressErrorApps, CS_Test_Setup, CS_Test_TearDown, - "CS_HandleTableUpdate_Test_DefinitionTableGetAddressErrorApps"); - UtTest_Add(CS_HandleTableUpdate_Test_BadTableHandle, CS_Test_Setup, CS_Test_TearDown, - "CS_HandleTableUpdate_Test_BadTableHandle"); - UtTest_Add(CS_HandleTableUpdate_Test_CsOwner, CS_Test_Setup, CS_Test_TearDown, "CS_HandleTableUpdate_Test_CsOwner"); - UtTest_Add(CS_HandleTableUpdate_Test_GetAddressError, CS_Test_Setup, CS_Test_TearDown, - "CS_HandleTableUpdate_Test_GetAddressError"); - UtTest_Add(CS_HandleTableUpdate_Test_InvalidTable, CS_Test_Setup, CS_Test_TearDown, - "CS_HandleTableUpdate_Test_InvalidTable"); + UtTest_Add(Test_CS_ValidateEepromChecksumDefinitionTable, CS_Test_Setup, CS_Test_TearDown, + "CS_ValidateEepromChecksumDefinitionTable"); + UtTest_Add(Test_CS_ValidateMemoryChecksumDefinitionTable, CS_Test_Setup, CS_Test_TearDown, + "CS_ValidateMemoryChecksumDefinitionTable"); + UtTest_Add(Test_CS_ValidateTablesChecksumDefinitionTable, CS_Test_Setup, CS_Test_TearDown, + "CS_ValidateTablesChecksumDefinitionTable"); + UtTest_Add(Test_CS_ValidateAppChecksumDefinitionTable, CS_Test_Setup, CS_Test_TearDown, + "CS_ValidateAppChecksumDefinitionTable"); + UtTest_Add(Test_CS_ProcessNewEepromMemoryDefinitionTable, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessNewEepromMemoryDefinitionTable"); + UtTest_Add(Test_CS_ProcessNewTablesDefinitionTable, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessNewTablesDefinitionTable"); + UtTest_Add(Test_CS_ProcessNewAppDefinitionTable, CS_Test_Setup, CS_Test_TearDown, + "CS_ProcessNewAppDefinitionTable"); + UtTest_Add(Test_CS_TableInit, CS_Test_Setup, CS_Test_TearDown, "CS_TableInit"); + UtTest_Add(Test_CS_HandleTableUpdate, CS_Test_Setup, CS_Test_TearDown, "CS_HandleTableUpdate"); + UtTest_Add(Test_CS_CallTableUpdateHandler, CS_Test_Setup, CS_Test_TearDown, "CS_CallTableUpdateHandler"); } diff --git a/unit-test/cs_utils_tests.c b/unit-test/cs_utils_tests.c index c37c126..075c4c3 100644 --- a/unit-test/cs_utils_tests.c +++ b/unit-test/cs_utils_tests.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -24,7 +23,7 @@ #include "cs_utils.h" #include "cs_msg.h" #include "cs_msgdefs.h" -#include "cs_events.h" +#include "cs_eventids.h" #include "cs_version.h" #include "cs_compute.h" #include "cs_test_utils.h" @@ -49,37 +48,43 @@ void CS_UTILS_TEST_CS_ComputeHandler(void *UserObj, UT_EntryKey_t FuncKey, const void CS_ZeroEepromTempValues_Test(void) { - CS_ZeroEepromTempValues(); + UtAssert_VOIDCALL(CS_ZeroEepromTempValues()); } void CS_ZeroMemoryTempValues_Test(void) { - CS_ZeroMemoryTempValues(); + UtAssert_VOIDCALL(CS_ZeroMemoryTempValues()); } void CS_ZeroTablesTempValues_Test(void) { - CS_ZeroTablesTempValues(); + UtAssert_VOIDCALL(CS_ZeroTablesTempValues()); } void CS_ZeroAppTempValues_Test(void) { - CS_ZeroAppTempValues(); + UtAssert_VOIDCALL(CS_ZeroAppTempValues()); } void CS_ZeroCfeCoreTempValues_Test(void) { - CS_ZeroCfeCoreTempValues(); + UtAssert_VOIDCALL(CS_ZeroCfeCoreTempValues()); + + CS_AppData.Tbl[CS_ChecksumType_CFECORE].ResAddr = NULL; + UtAssert_VOIDCALL(CS_ZeroCfeCoreTempValues()); } void CS_ZeroOSTempValues_Test(void) { - CS_ZeroOSTempValues(); + UtAssert_VOIDCALL(CS_ZeroOSTempValues()); + + CS_AppData.Tbl[CS_ChecksumType_OSCORE].ResAddr = NULL; + UtAssert_VOIDCALL(CS_ZeroOSTempValues()); } void CS_InitializeDefaultTables_Test(void) { - CS_InitializeDefaultTables(); + UtAssert_VOIDCALL(CS_InitializeDefaultTables()); } void CS_GoToNextTable_Test(void) @@ -107,246 +112,227 @@ void CS_GoToNextTable_Test(void) void CS_GetTableResTblEntryByName_Test(void) { - CS_Res_Tables_Table_Entry_t *EntryPtr = NULL; + CS_Res_Tables_Table_Entry_t *EntryPtr = NULL; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE]; + CS_Res_Tables_Table_Entry_t *ResTablesTblPtr = tw->ResAddr; /* Empty name, enabled state */ - CS_AppData.ResTablesTblPtr[0].State = CS_STATE_ENABLED; + ResTablesTblPtr[0].State = CS_ChecksumState_ENABLED; /* Execute and verify */ UtAssert_BOOL_FALSE(CS_GetTableResTblEntryByName(&EntryPtr, "name")); UtAssert_ADDRESS_EQ(EntryPtr, NULL); /* Matching name, empty state */ - strncpy(CS_AppData.ResTablesTblPtr[0].Name, "name", 10); - CS_AppData.ResTablesTblPtr[0].State = CS_STATE_EMPTY; + strncpy(ResTablesTblPtr[0].Name, "name", 10); + ResTablesTblPtr[0].State = CS_ChecksumState_EMPTY; /* Execute and verify */ UtAssert_BOOL_FALSE(CS_GetTableResTblEntryByName(&EntryPtr, "name")); UtAssert_ADDRESS_EQ(EntryPtr, NULL); /* Matching name, enabled */ - CS_AppData.ResTablesTblPtr[0].State = CS_STATE_ENABLED; + ResTablesTblPtr[0].State = CS_ChecksumState_ENABLED; /* Execute and verify */ UtAssert_BOOL_TRUE(CS_GetTableResTblEntryByName(&EntryPtr, "name")); - UtAssert_ADDRESS_EQ(EntryPtr, CS_AppData.ResTablesTblPtr); + UtAssert_ADDRESS_EQ(EntryPtr, ResTablesTblPtr); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } void CS_GetTableDefTblEntryByName_Test(void) { - CS_Def_Tables_Table_Entry_t *EntryPtr = NULL; + CS_Def_Tables_Table_Entry_t *EntryPtr = NULL; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE]; + CS_Def_Tables_Table_Entry_t *DefTablesTblPtr = tw->DefAddr; /* Empty name, enabled state */ - CS_AppData.DefTablesTblPtr[0].State = CS_STATE_ENABLED; + DefTablesTblPtr[0].State = CS_ChecksumState_ENABLED; /* Execute and verify */ UtAssert_BOOL_FALSE(CS_GetTableDefTblEntryByName(&EntryPtr, "name")); UtAssert_ADDRESS_EQ(EntryPtr, NULL); /* Matching name, empty state */ - strncpy(CS_AppData.DefTablesTblPtr[0].Name, "name", 10); - CS_AppData.DefTablesTblPtr[0].State = CS_STATE_EMPTY; + strncpy(DefTablesTblPtr[0].Name, "name", 10); + DefTablesTblPtr[0].State = CS_ChecksumState_EMPTY; /* Execute and verify */ UtAssert_BOOL_FALSE(CS_GetTableDefTblEntryByName(&EntryPtr, "name")); UtAssert_ADDRESS_EQ(EntryPtr, NULL); /* Matching name, enabled */ - CS_AppData.DefTablesTblPtr[0].State = CS_STATE_ENABLED; + DefTablesTblPtr[0].State = CS_ChecksumState_ENABLED; /* Execute and verify */ UtAssert_BOOL_TRUE(CS_GetTableDefTblEntryByName(&EntryPtr, "name")); - UtAssert_ADDRESS_EQ(EntryPtr, CS_AppData.DefTablesTblPtr); + UtAssert_ADDRESS_EQ(EntryPtr, DefTablesTblPtr); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } void CS_GetAppResTblEntryByName_Test(void) { - CS_Res_App_Table_Entry_t *EntryPtr = NULL; + CS_Res_App_Table_Entry_t *EntryPtr = NULL; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_APP_TABLE]; + CS_Res_App_Table_Entry_t *ResAppTblPtr = tw->ResAddr; /* Empty name, enabled state */ - CS_AppData.ResAppTblPtr[0].State = CS_STATE_ENABLED; + ResAppTblPtr[0].State = CS_ChecksumState_ENABLED; /* Execute and verify */ UtAssert_BOOL_FALSE(CS_GetAppResTblEntryByName(&EntryPtr, "name")); UtAssert_ADDRESS_EQ(EntryPtr, NULL); /* Matching name, empty state */ - strncpy(CS_AppData.ResAppTblPtr[0].Name, "name", 10); - CS_AppData.ResAppTblPtr[0].State = CS_STATE_EMPTY; + strncpy(ResAppTblPtr[0].Name, "name", 10); + ResAppTblPtr[0].State = CS_ChecksumState_EMPTY; /* Execute and verify */ UtAssert_BOOL_FALSE(CS_GetAppResTblEntryByName(&EntryPtr, "name")); UtAssert_ADDRESS_EQ(EntryPtr, NULL); /* Matching name, enabled */ - CS_AppData.ResAppTblPtr[0].State = CS_STATE_ENABLED; + ResAppTblPtr[0].State = CS_ChecksumState_ENABLED; /* Execute and verify */ UtAssert_BOOL_TRUE(CS_GetAppResTblEntryByName(&EntryPtr, "name")); - UtAssert_ADDRESS_EQ(EntryPtr, CS_AppData.ResAppTblPtr); + UtAssert_ADDRESS_EQ(EntryPtr, ResAppTblPtr); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } void CS_GetAppDefTblEntryByName_Test(void) { - CS_Def_App_Table_Entry_t *EntryPtr = NULL; + CS_Def_App_Table_Entry_t *EntryPtr = NULL; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_APP_TABLE]; + CS_Def_App_Table_Entry_t *DefAppTblPtr = tw->DefAddr; /* Empty name, enabled state */ - CS_AppData.DefAppTblPtr[0].State = CS_STATE_ENABLED; + DefAppTblPtr[0].State = CS_ChecksumState_ENABLED; /* Execute and verify */ UtAssert_BOOL_FALSE(CS_GetAppDefTblEntryByName(&EntryPtr, "name")); UtAssert_ADDRESS_EQ(EntryPtr, NULL); /* Matching name, empty state */ - strncpy(CS_AppData.DefAppTblPtr[0].Name, "name", 10); - CS_AppData.DefAppTblPtr[0].State = CS_STATE_EMPTY; + strncpy(DefAppTblPtr[0].Name, "name", 10); + DefAppTblPtr[0].State = CS_ChecksumState_EMPTY; /* Execute and verify */ UtAssert_BOOL_FALSE(CS_GetAppDefTblEntryByName(&EntryPtr, "name")); UtAssert_ADDRESS_EQ(EntryPtr, NULL); /* Matching name, enabled */ - CS_AppData.DefAppTblPtr[0].State = CS_STATE_ENABLED; + DefAppTblPtr[0].State = CS_ChecksumState_ENABLED; /* Execute and verify */ UtAssert_BOOL_TRUE(CS_GetAppDefTblEntryByName(&EntryPtr, "name")); - UtAssert_ADDRESS_EQ(EntryPtr, CS_AppData.DefAppTblPtr); + UtAssert_ADDRESS_EQ(EntryPtr, DefAppTblPtr); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } void CS_FindEnabledEepromEntry_Test(void) { - uint16 EnabledEntry = 0; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE]; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = tw->ResAddr; /* Call with zeros */ - UtAssert_BOOL_FALSE(CS_FindEnabledEepromEntry(&EnabledEntry)); + UtAssert_NULL(CS_FindEnabledEepromEntry()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, CS_MAX_NUM_EEPROM_TABLE_ENTRIES); - UtAssert_UINT16_EQ(EnabledEntry, CS_MAX_NUM_EEPROM_TABLE_ENTRIES); /* Set up to find last entry (skip first) */ - CS_AppData.ResEepromTblPtr[0].State = CS_STATE_ENABLED; - CS_AppData.ResEepromTblPtr[CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1].State = CS_STATE_ENABLED; - CS_AppData.HkPacket.Payload.CurrentEntryInTable = 1; + ResEepromTblPtr[0].State = CS_ChecksumState_ENABLED; + ResEepromTblPtr[CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1].State = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.CurrentEntryInTable = 1; - UtAssert_BOOL_TRUE(CS_FindEnabledEepromEntry(&EnabledEntry)); + UtAssert_NOT_NULL(CS_FindEnabledEepromEntry()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1); - UtAssert_UINT16_EQ(EnabledEntry, CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } void CS_FindEnabledMemoryEntry_Test(void) { - uint16 EnabledEntry = 0; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE]; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = tw->ResAddr; /* Call with zeros */ - UtAssert_BOOL_FALSE(CS_FindEnabledMemoryEntry(&EnabledEntry)); + UtAssert_NULL(CS_FindEnabledMemoryEntry()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, CS_MAX_NUM_MEMORY_TABLE_ENTRIES); - UtAssert_UINT16_EQ(EnabledEntry, CS_MAX_NUM_MEMORY_TABLE_ENTRIES); /* Set up to find last entry (skip first) */ - CS_AppData.ResMemoryTblPtr[0].State = CS_STATE_ENABLED; - CS_AppData.ResMemoryTblPtr[CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1].State = CS_STATE_ENABLED; - CS_AppData.HkPacket.Payload.CurrentEntryInTable = 1; + ResMemoryTblPtr[0].State = CS_ChecksumState_ENABLED; + ResMemoryTblPtr[CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1].State = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.CurrentEntryInTable = 1; - UtAssert_BOOL_TRUE(CS_FindEnabledMemoryEntry(&EnabledEntry)); + UtAssert_NOT_NULL(CS_FindEnabledMemoryEntry()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1); - UtAssert_UINT16_EQ(EnabledEntry, CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } void CS_FindEnabledTablesEntry_Test(void) { - uint16 EnabledEntry = 0; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE]; + CS_Res_Tables_Table_Entry_t *ResTablesTblPtr = tw->ResAddr; /* Call with zeros */ - UtAssert_BOOL_FALSE(CS_FindEnabledTablesEntry(&EnabledEntry)); + UtAssert_NULL(CS_FindEnabledTablesEntry()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, CS_MAX_NUM_TABLES_TABLE_ENTRIES); - UtAssert_UINT16_EQ(EnabledEntry, CS_MAX_NUM_TABLES_TABLE_ENTRIES); /* Set up to find last entry (skip first) */ - CS_AppData.ResTablesTblPtr[0].State = CS_STATE_ENABLED; - CS_AppData.ResTablesTblPtr[CS_MAX_NUM_TABLES_TABLE_ENTRIES - 1].State = CS_STATE_ENABLED; - CS_AppData.HkPacket.Payload.CurrentEntryInTable = 1; + ResTablesTblPtr[0].State = CS_ChecksumState_ENABLED; + ResTablesTblPtr[CS_MAX_NUM_TABLES_TABLE_ENTRIES - 1].State = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.CurrentEntryInTable = 1; - UtAssert_BOOL_TRUE(CS_FindEnabledTablesEntry(&EnabledEntry)); + UtAssert_NOT_NULL(CS_FindEnabledTablesEntry()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, CS_MAX_NUM_TABLES_TABLE_ENTRIES - 1); - UtAssert_UINT16_EQ(EnabledEntry, CS_MAX_NUM_TABLES_TABLE_ENTRIES - 1); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } void CS_FindEnabledAppEntry_Test(void) { - uint16 EnabledEntry = 0; + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_APP_TABLE]; + CS_Res_App_Table_Entry_t *ResAppTblPtr = tw->ResAddr; /* Call with zeros */ - UtAssert_BOOL_FALSE(CS_FindEnabledAppEntry(&EnabledEntry)); + UtAssert_NULL(CS_FindEnabledAppEntry()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, CS_MAX_NUM_APP_TABLE_ENTRIES); - UtAssert_UINT16_EQ(EnabledEntry, CS_MAX_NUM_APP_TABLE_ENTRIES); /* Set up to find last entry (skip first) */ - CS_AppData.ResAppTblPtr[0].State = CS_STATE_ENABLED; - CS_AppData.ResAppTblPtr[CS_MAX_NUM_APP_TABLE_ENTRIES - 1].State = CS_STATE_ENABLED; - CS_AppData.HkPacket.Payload.CurrentEntryInTable = 1; + ResAppTblPtr[0].State = CS_ChecksumState_ENABLED; + ResAppTblPtr[CS_MAX_NUM_APP_TABLE_ENTRIES - 1].State = CS_ChecksumState_ENABLED; + CS_AppData.HkPacket.Payload.CurrentEntryInTable = 1; - UtAssert_BOOL_TRUE(CS_FindEnabledAppEntry(&EnabledEntry)); + UtAssert_NOT_NULL(CS_FindEnabledAppEntry()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, CS_MAX_NUM_APP_TABLE_ENTRIES - 1); - UtAssert_UINT16_EQ(EnabledEntry, CS_MAX_NUM_APP_TABLE_ENTRIES - 1); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } -void CS_VerifyCmdLength_Test(void) -{ - CS_OneShotCmd_t CmdPacket; - CFE_SB_MsgId_t TestMsgId = CFE_SB_MSGID_WRAP_VALUE(CS_CMD_MID); - CFE_MSG_FcnCode_t FcnCode = 99; - size_t MsgSize = sizeof(CmdPacket); - - /* Execute with passing size */ - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - - UtAssert_BOOL_TRUE(CS_VerifyCmdLength((CFE_MSG_Message_t *)(&CmdPacket), MsgSize)); - - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); - - /* Execute with failing size */ - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetMsgId), &TestMsgId, sizeof(TestMsgId), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &FcnCode, sizeof(FcnCode), false); - UT_SetDataBuffer(UT_KEY(CFE_MSG_GetSize), &MsgSize, sizeof(MsgSize), false); - - UtAssert_BOOL_FALSE(CS_VerifyCmdLength((CFE_MSG_Message_t *)(&CmdPacket), MsgSize - 1)); - - UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); - UtAssert_INT32_EQ(context_CFE_EVS_SendEvent[0].EventID, CS_CMD_LEN_ERR_EID); -} - void CS_BackgroundCfeCore_Test(void) { + CS_Res_EepromMemory_Table_Entry_t *CfeCoreCodeSeg = &CS_AppData.CfeCoreCodeSeg; + /* Entirely disabled */ - CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_ChecksumState_DISABLED; UtAssert_BOOL_FALSE(CS_BackgroundCfeCore()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, 0); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 1); /* Segment disabled */ - CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_STATE_ENABLED; - CS_AppData.CfeCoreCodeSeg.State = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.CfeCoreCSState = CS_ChecksumState_ENABLED; + CfeCoreCodeSeg->State = CS_ChecksumState_DISABLED; UtAssert_BOOL_FALSE(CS_BackgroundCfeCore()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, 0); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 2); /* Enabled, miscompare, not done with entry */ - CS_AppData.CfeCoreCodeSeg.State = CS_STATE_ENABLED; + CfeCoreCodeSeg->State = CS_ChecksumState_ENABLED; UT_SetDeferredRetcode(UT_KEY(CS_ComputeEepromMemory), 1, CS_ERROR); UtAssert_BOOL_TRUE(CS_BackgroundCfeCore()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CfeCoreCSErrCounter, 1); @@ -366,21 +352,23 @@ void CS_BackgroundCfeCore_Test(void) void CS_BackgroundOS_Test(void) { + CS_Res_EepromMemory_Table_Entry_t *OSCodeSeg = &CS_AppData.OSCodeSeg; + /* Entirely disabled */ - CS_AppData.HkPacket.Payload.OSCSState = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.OSCSState = CS_ChecksumState_DISABLED; UtAssert_BOOL_FALSE(CS_BackgroundOS()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, 0); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 1); /* Segment disabled */ - CS_AppData.HkPacket.Payload.OSCSState = CS_STATE_ENABLED; - CS_AppData.OSCodeSeg.State = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.OSCSState = CS_ChecksumState_ENABLED; + OSCodeSeg->State = CS_ChecksumState_DISABLED; UtAssert_BOOL_FALSE(CS_BackgroundOS()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, 0); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 2); /* Enabled, miscompare, not done with entry */ - CS_AppData.OSCodeSeg.State = CS_STATE_ENABLED; + OSCodeSeg->State = CS_ChecksumState_ENABLED; UT_SetDeferredRetcode(UT_KEY(CS_ComputeEepromMemory), 1, CS_ERROR); UtAssert_BOOL_TRUE(CS_BackgroundOS()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.OSCSErrCounter, 1); @@ -400,23 +388,26 @@ void CS_BackgroundOS_Test(void) void CS_BackgroundEeprom_Test(void) { + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE]; + CS_Res_EepromMemory_Table_Entry_t *ResEepromTblPtr = tw->ResAddr; + /* Entirely disabled */ - CS_AppData.HkPacket.Payload.EepromCSState = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.EepromCSState = CS_ChecksumState_DISABLED; UtAssert_BOOL_FALSE(CS_BackgroundEeprom()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, 0); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 1); /* All entries disabled */ - CS_AppData.HkPacket.Payload.EepromCSState = CS_STATE_ENABLED; - CS_AppData.ResEepromTblPtr[0].ComparisonValue = 1; - CS_AppData.ResEepromTblPtr[1].ComparisonValue = 2; + CS_AppData.HkPacket.Payload.EepromCSState = CS_ChecksumState_ENABLED; + ResEepromTblPtr[0].ComparisonValue = 1; + ResEepromTblPtr[1].ComparisonValue = 2; UtAssert_BOOL_FALSE(CS_BackgroundEeprom()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, 0); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 2); UtAssert_UINT32_EQ(CS_AppData.HkPacket.Payload.EepromBaseline, 3); /* Enabled, miscompare, not done with entry */ - CS_AppData.ResEepromTblPtr[0].State = CS_STATE_ENABLED; + ResEepromTblPtr[0].State = CS_ChecksumState_ENABLED; UT_SetDeferredRetcode(UT_KEY(CS_ComputeEepromMemory), 1, CS_ERROR); UtAssert_BOOL_TRUE(CS_BackgroundEeprom()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.EepromCSErrCounter, 1); @@ -426,9 +417,9 @@ void CS_BackgroundEeprom_Test(void) UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 2); /* Last entry, Enabled, compares, done with entry */ - CS_AppData.HkPacket.Payload.CurrentEntryInTable = CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1; - CS_AppData.ResEepromTblPtr[CS_AppData.HkPacket.Payload.CurrentEntryInTable].State = CS_STATE_ENABLED; - CS_AppData.ResEepromTblPtr[CS_AppData.HkPacket.Payload.CurrentEntryInTable].ComparisonValue = 3; + CS_AppData.HkPacket.Payload.CurrentEntryInTable = CS_MAX_NUM_EEPROM_TABLE_ENTRIES - 1; + ResEepromTblPtr[CS_AppData.HkPacket.Payload.CurrentEntryInTable].State = CS_ChecksumState_ENABLED; + ResEepromTblPtr[CS_AppData.HkPacket.Payload.CurrentEntryInTable].ComparisonValue = 3; UT_SetHandlerFunction(UT_KEY(CS_ComputeEepromMemory), CS_UTILS_TEST_CS_ComputeHandler, NULL); UtAssert_BOOL_TRUE(CS_BackgroundEeprom()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.EepromCSErrCounter, 1); @@ -440,20 +431,23 @@ void CS_BackgroundEeprom_Test(void) void CS_BackgroundMemory_Test(void) { + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE]; + CS_Res_EepromMemory_Table_Entry_t *ResMemoryTblPtr = tw->ResAddr; + /* Entirely disabled */ - CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.MemoryCSState = CS_ChecksumState_DISABLED; UtAssert_BOOL_FALSE(CS_BackgroundMemory()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, 0); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 1); /* All entries disabled */ - CS_AppData.HkPacket.Payload.MemoryCSState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.MemoryCSState = CS_ChecksumState_ENABLED; UtAssert_BOOL_FALSE(CS_BackgroundMemory()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, 0); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 2); /* Enabled, miscompare, not done with entry */ - CS_AppData.ResMemoryTblPtr[0].State = CS_STATE_ENABLED; + ResMemoryTblPtr[0].State = CS_ChecksumState_ENABLED; UT_SetDeferredRetcode(UT_KEY(CS_ComputeEepromMemory), 1, CS_ERROR); UtAssert_BOOL_TRUE(CS_BackgroundMemory()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.MemoryCSErrCounter, 1); @@ -463,8 +457,8 @@ void CS_BackgroundMemory_Test(void) UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 2); /* Last entry, Enabled, compares, done with entry */ - CS_AppData.HkPacket.Payload.CurrentEntryInTable = CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1; - CS_AppData.ResMemoryTblPtr[CS_AppData.HkPacket.Payload.CurrentEntryInTable].State = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.CurrentEntryInTable = CS_MAX_NUM_MEMORY_TABLE_ENTRIES - 1; + ResMemoryTblPtr[CS_AppData.HkPacket.Payload.CurrentEntryInTable].State = CS_ChecksumState_ENABLED; UT_SetHandlerFunction(UT_KEY(CS_ComputeEepromMemory), CS_UTILS_TEST_CS_ComputeHandler, NULL); UtAssert_BOOL_TRUE(CS_BackgroundMemory()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.MemoryCSErrCounter, 1); @@ -475,20 +469,23 @@ void CS_BackgroundMemory_Test(void) void CS_BackgroundTables_Test(void) { + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE]; + CS_Res_Tables_Table_Entry_t *ResTablesTblPtr = tw->ResAddr; + /* Entirely disabled */ - CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.TablesCSState = CS_ChecksumState_DISABLED; UtAssert_BOOL_FALSE(CS_BackgroundTables()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, 0); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 1); /* All entries disabled */ - CS_AppData.HkPacket.Payload.TablesCSState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.TablesCSState = CS_ChecksumState_ENABLED; UtAssert_BOOL_FALSE(CS_BackgroundTables()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, 0); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 2); /* Enabled, miscompare, not done with entry */ - CS_AppData.ResTablesTblPtr[0].State = CS_STATE_ENABLED; + ResTablesTblPtr[0].State = CS_ChecksumState_ENABLED; UT_SetDeferredRetcode(UT_KEY(CS_ComputeTables), 1, CS_ERROR); UtAssert_BOOL_TRUE(CS_BackgroundTables()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.TablesCSErrCounter, 1); @@ -507,8 +504,8 @@ void CS_BackgroundTables_Test(void) UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 2); /* Last entry, Enabled, compares, done with entry */ - CS_AppData.HkPacket.Payload.CurrentEntryInTable = CS_MAX_NUM_TABLES_TABLE_ENTRIES - 1; - CS_AppData.ResTablesTblPtr[CS_AppData.HkPacket.Payload.CurrentEntryInTable].State = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.CurrentEntryInTable = CS_MAX_NUM_TABLES_TABLE_ENTRIES - 1; + ResTablesTblPtr[CS_AppData.HkPacket.Payload.CurrentEntryInTable].State = CS_ChecksumState_ENABLED; UT_SetHandlerFunction(UT_KEY(CS_ComputeTables), CS_UTILS_TEST_CS_ComputeHandler, NULL); UtAssert_BOOL_TRUE(CS_BackgroundTables()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.TablesCSErrCounter, 1); @@ -519,20 +516,23 @@ void CS_BackgroundTables_Test(void) void CS_BackgroundApp_Test(void) { + CS_TableWrapper_t * tw = &CS_AppData.Tbl[CS_ChecksumType_APP_TABLE]; + CS_Res_App_Table_Entry_t *ResAppTblPtr = tw->ResAddr; + /* Entirely disabled */ - CS_AppData.HkPacket.Payload.AppCSState = CS_STATE_DISABLED; + CS_AppData.HkPacket.Payload.AppCSState = CS_ChecksumState_DISABLED; UtAssert_BOOL_FALSE(CS_BackgroundApp()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, 0); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 1); /* All entries disabled */ - CS_AppData.HkPacket.Payload.AppCSState = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.AppCSState = CS_ChecksumState_ENABLED; UtAssert_BOOL_FALSE(CS_BackgroundApp()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentEntryInTable, 0); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 2); /* Enabled, miscompare, not done with entry */ - CS_AppData.ResAppTblPtr[0].State = CS_STATE_ENABLED; + ResAppTblPtr[0].State = CS_ChecksumState_ENABLED; UT_SetDeferredRetcode(UT_KEY(CS_ComputeApp), 1, CS_ERROR); UtAssert_BOOL_TRUE(CS_BackgroundApp()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.AppCSErrCounter, 1); @@ -551,8 +551,8 @@ void CS_BackgroundApp_Test(void) UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.CurrentCSTable, 2); /* Last entry, Enabled, compares, done with entry */ - CS_AppData.HkPacket.Payload.CurrentEntryInTable = CS_MAX_NUM_APP_TABLE_ENTRIES - 1; - CS_AppData.ResAppTblPtr[CS_AppData.HkPacket.Payload.CurrentEntryInTable].State = CS_STATE_ENABLED; + CS_AppData.HkPacket.Payload.CurrentEntryInTable = CS_MAX_NUM_APP_TABLE_ENTRIES - 1; + ResAppTblPtr[CS_AppData.HkPacket.Payload.CurrentEntryInTable].State = CS_ChecksumState_ENABLED; UT_SetHandlerFunction(UT_KEY(CS_ComputeApp), CS_UTILS_TEST_CS_ComputeHandler, NULL); UtAssert_BOOL_TRUE(CS_BackgroundApp()); UtAssert_UINT16_EQ(CS_AppData.HkPacket.Payload.AppCSErrCounter, 1); @@ -580,10 +580,26 @@ void CS_ResetTablesTblResultEntry_Test(void) void CS_HandleRoutineTableUpdates_Test(void) { - uint16 ChildTaskTable[] = {CS_CFECORE, CS_EEPROM_TABLE, CS_MEMORY_TABLE, CS_APP_TABLE, CS_TABLES_TABLE}; + uint16 ChildTaskTable[] = {CS_ChecksumType_CFECORE, CS_ChecksumType_EEPROM_TABLE, CS_ChecksumType_MEMORY_TABLE, + CS_ChecksumType_APP_TABLE, CS_ChecksumType_TABLES_TABLE}; uint16 TblMax = sizeof(ChildTaskTable) / sizeof(ChildTaskTable[0]); uint16 i; + for (i = 0; i < TblMax; i++) + { + if (CS_AppData.Tbl[ChildTaskTable[i]].GlobalState) + { + *CS_AppData.Tbl[ChildTaskTable[i]].GlobalState = CS_ChecksumState_ENABLED; + } + } + + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.AppCSState, CS_ChecksumState_ENABLED); + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.TablesCSState, CS_ChecksumState_ENABLED); + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.MemoryCSState, CS_ChecksumState_ENABLED); + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.EepromCSState, CS_ChecksumState_ENABLED); + + CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE].GlobalState = NULL; + /* Cycle through each all true case */ CS_AppData.HkPacket.Payload.RecomputeInProgress = true; CS_AppData.HkPacket.Payload.OneShotInProgress = false; @@ -595,7 +611,7 @@ void CS_HandleRoutineTableUpdates_Test(void) UtAssert_INT32_EQ(CS_HandleRoutineTableUpdates(), CFE_SUCCESS); /* Confirm stub call count based on selected table */ - if (CS_AppData.ChildTaskTable == CS_CFECORE) + if (CS_AppData.ChildTaskTable == CS_ChecksumType_CFECORE) { UtAssert_STUB_COUNT(CS_HandleTableUpdate, 4); } @@ -638,47 +654,21 @@ void CS_HandleRoutineTableUpdates_Test(void) UtAssert_STUB_COUNT(CS_HandleTableUpdate, 4); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 4); + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.AppCSState, CS_ChecksumState_DISABLED); + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.TablesCSState, CS_ChecksumState_DISABLED); + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.MemoryCSState, CS_ChecksumState_DISABLED); + UtAssert_UINT8_EQ(CS_AppData.HkPacket.Payload.EepromCSState, CS_ChecksumState_ENABLED); + /* Force send event errors */ UT_ResetState(UT_KEY(CS_HandleTableUpdate)); UT_ResetState(UT_KEY(CFE_EVS_SendEvent)); UT_SetDefaultReturnValue(UT_KEY(CS_HandleTableUpdate), -1); UT_SetDefaultReturnValue(UT_KEY(CFE_EVS_SendEvent), -2); - UtAssert_INT32_EQ(CS_HandleRoutineTableUpdates(), -2); + UtAssert_INT32_EQ(CS_HandleRoutineTableUpdates(), CFE_SUCCESS); UtAssert_STUB_COUNT(CS_HandleTableUpdate, 4); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 4); } -void CS_AttemptTableReshare_Test(void) -{ - CS_Res_Tables_Table_Entry_t TblEntry; - CFE_TBL_Handle_t LocalTblHandle = CFE_TBL_BAD_TABLE_HANDLE; - CFE_TBL_Info_t TblInfo; - cpuaddr LocalAddress; - CFE_Status_t ResultGetInfo = -1; - - memset(&TblEntry, 0, sizeof(TblEntry)); - - /* Execute the function being tested */ - UtAssert_INT32_EQ(CS_AttemptTableReshare(&TblEntry, &LocalTblHandle, &TblInfo, &LocalAddress, &ResultGetInfo), - CFE_SUCCESS); - UtAssert_UINT32_EQ(TblEntry.TblHandle, LocalTblHandle); - UtAssert_INT32_EQ(ResultGetInfo, CFE_SUCCESS); - UtAssert_STUB_COUNT(CFE_TBL_ReleaseAddress, 0); - - /* Table never loaded to cause address release */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetAddress), CFE_TBL_ERR_NEVER_LOADED); - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_GetInfo), -1); - UtAssert_INT32_EQ(CS_AttemptTableReshare(&TblEntry, &LocalTblHandle, &TblInfo, &LocalAddress, &ResultGetInfo), - CFE_TBL_ERR_NEVER_LOADED); - UtAssert_UINT32_EQ(TblEntry.TblHandle, LocalTblHandle); - UtAssert_INT32_EQ(ResultGetInfo, -1); - UtAssert_STUB_COUNT(CFE_TBL_ReleaseAddress, 1); - - /* Failed share */ - UT_SetDefaultReturnValue(UT_KEY(CFE_TBL_Share), -2); - UtAssert_INT32_EQ(CS_AttemptTableReshare(&TblEntry, &LocalTblHandle, &TblInfo, &LocalAddress, &ResultGetInfo), -2); -} - void CS_CheckRecomputeOneShot_Test(void) { /* Set up for false return */ @@ -712,10 +702,122 @@ void CS_GetTableTypeAsString_Test(void) /* Just call the function with every table type, it should never return NULL */ for (i = 0; i <= CS_NUM_TABLES; ++i) { - UtAssert_NOT_NULL(CS_GetTableTypeAsString(i)); + UtAssert_NOT_NULL(CS_GetTableTypeAsString(&CS_AppData.Tbl[i])); } } +void Test_CS_SetDefEntryState(void) +{ + /* Test case for: + * uint16 CS_SetDefEntryState(CS_TableWrapper_t *tw, void *EntryPtr, uint16 NewState); + */ + CS_TableWrapper_t * tw; + CS_Def_EepromMemory_Table_Entry_t *DefEntry; + + tw = &CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE]; + DefEntry = tw->DefAddr; + + tw->DefStateOffset = offsetof(CS_Def_EepromMemory_Table_Entry_t, State); + + DefEntry->State = CS_ChecksumState_UNDEFINED; + UtAssert_UINT16_EQ(CS_SetDefEntryState(tw, DefEntry, CS_ChecksumState_ENABLED), CS_ChecksumState_UNDEFINED); + UtAssert_STUB_COUNT(CFE_TBL_Modified, 0); + UtAssert_UINT16_EQ(DefEntry->State, CS_ChecksumState_UNDEFINED); + + DefEntry->State = CS_ChecksumState_ENABLED; + UtAssert_UINT16_EQ(CS_SetDefEntryState(tw, DefEntry, CS_ChecksumState_DISABLED), CS_ChecksumState_ENABLED); + UtAssert_STUB_COUNT(CFE_TBL_Modified, 1); + UtAssert_UINT16_EQ(DefEntry->State, CS_ChecksumState_DISABLED); + UtAssert_UINT16_EQ(CS_SetDefEntryState(tw, DefEntry, CS_ChecksumState_DISABLED), CS_ChecksumState_DISABLED); + UtAssert_STUB_COUNT(CFE_TBL_Modified, 1); + UtAssert_UINT16_EQ(DefEntry->State, CS_ChecksumState_DISABLED); + UtAssert_UINT16_EQ(CS_SetDefEntryState(tw, DefEntry, CS_ChecksumState_ENABLED), CS_ChecksumState_DISABLED); + UtAssert_STUB_COUNT(CFE_TBL_Modified, 2); + UtAssert_UINT16_EQ(DefEntry->State, CS_ChecksumState_ENABLED); + + UtAssert_UINT16_EQ(CS_SetDefEntryState(tw, DefEntry, CS_ChecksumState_EMPTY), CS_ChecksumState_UNDEFINED); + UtAssert_STUB_COUNT(CFE_TBL_Modified, 2); + UtAssert_UINT16_EQ(DefEntry->State, CS_ChecksumState_ENABLED); +} + +void Test_CS_CheckDefTableNameMatch(void) +{ + /* Test case for: + * bool CS_CheckDefTableNameMatch(const char *Name, uint16 TableIdx); + */ + CS_TableWrapper_t *tw; + + tw = &CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE]; + + tw->DefTableName = NULL; + UtAssert_BOOL_FALSE(CS_CheckDefTableNameMatch("UT", CS_ChecksumType_MEMORY_TABLE)); + UtAssert_BOOL_FALSE(CS_CheckDefTableNameMatch(NULL, CS_ChecksumType_MEMORY_TABLE)); + + tw->DefTableName = "UT"; + UtAssert_BOOL_TRUE(CS_CheckDefTableNameMatch("UT", CS_ChecksumType_MEMORY_TABLE)); + UtAssert_BOOL_FALSE(CS_CheckDefTableNameMatch("X", CS_ChecksumType_MEMORY_TABLE)); + UtAssert_BOOL_FALSE(CS_CheckDefTableNameMatch(NULL, CS_ChecksumType_MEMORY_TABLE)); +} + +void Test_CS_CheckResTableNameMatch(void) +{ + /* Test case for: + * bool CS_CheckResTableNameMatch(const char *Name, uint16 TableIdx); + */ + CS_TableWrapper_t *tw; + + tw = &CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE]; + + tw->ResTableName = NULL; + UtAssert_BOOL_FALSE(CS_CheckResTableNameMatch("UT", CS_ChecksumType_MEMORY_TABLE)); + UtAssert_BOOL_FALSE(CS_CheckResTableNameMatch(NULL, CS_ChecksumType_MEMORY_TABLE)); + + tw->ResTableName = "UT"; + UtAssert_BOOL_TRUE(CS_CheckResTableNameMatch("UT", CS_ChecksumType_MEMORY_TABLE)); + UtAssert_BOOL_FALSE(CS_CheckResTableNameMatch("X", CS_ChecksumType_MEMORY_TABLE)); + UtAssert_BOOL_FALSE(CS_CheckResTableNameMatch(NULL, CS_ChecksumType_MEMORY_TABLE)); +} + +void Test_CS_GetDefEntryAddr(void) +{ + /* Test case for: + * void *CS_GetDefEntryAddr(CS_TableWrapper_t *tw, uint16 EntryIdx); + */ + + CS_TableWrapper_t * tw; + CS_Def_EepromMemory_Table_Entry_t *DefEntry; + + tw = &CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE]; + DefEntry = tw->DefAddr; + + UtAssert_ADDRESS_EQ(CS_GetDefEntryAddr(tw, 0), DefEntry); + UtAssert_ADDRESS_EQ(CS_GetDefEntryAddr(tw, 3), &DefEntry[3]); + UtAssert_NULL(CS_GetDefEntryAddr(tw, tw->NumEntries + 1)); + + tw->DefAddr = NULL; + UtAssert_NULL(CS_GetDefEntryAddr(tw, tw->NumEntries - 1)); +} + +void Test_CS_GetResEntryAddr(void) +{ + /* Test case for: + * void *CS_GetResEntryAddr(CS_TableWrapper_t *tw, uint16 EntryIdx); + */ + + CS_TableWrapper_t * tw; + CS_Res_EepromMemory_Table_Entry_t *ResEntry; + + tw = &CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE]; + ResEntry = tw->ResAddr; + + UtAssert_ADDRESS_EQ(CS_GetResEntryAddr(tw, 0), ResEntry); + UtAssert_ADDRESS_EQ(CS_GetResEntryAddr(tw, 3), &ResEntry[3]); + UtAssert_NULL(CS_GetResEntryAddr(tw, tw->NumEntries + 1)); + + tw->ResAddr = NULL; + UtAssert_NULL(CS_GetResEntryAddr(tw, tw->NumEntries - 1)); +} + void UtTest_Setup(void) { UtTest_Add(CS_ZeroEepromTempValues_Test, CS_Test_Setup, CS_Test_TearDown, "CS_ZeroEepromTempValues_Test"); @@ -734,7 +836,6 @@ void UtTest_Setup(void) UtTest_Add(CS_FindEnabledMemoryEntry_Test, CS_Test_Setup, CS_Test_TearDown, "CS_FindEnabledMemoryEntry_Test"); UtTest_Add(CS_FindEnabledTablesEntry_Test, CS_Test_Setup, CS_Test_TearDown, "CS_FindEnabledTablesEntry_Test"); UtTest_Add(CS_FindEnabledAppEntry_Test, CS_Test_Setup, CS_Test_TearDown, "CS_FindEnabledAppEntry_Test"); - UtTest_Add(CS_VerifyCmdLength_Test, CS_Test_Setup, CS_Test_TearDown, "CS_VerifyCmdLength_Test"); UtTest_Add(CS_BackgroundCfeCore_Test, CS_Test_Setup, CS_Test_TearDown, "CS_BackgroundCfeCore_Test"); UtTest_Add(CS_BackgroundOS_Test, CS_Test_Setup, CS_Test_TearDown, "CS_BackgroundOS_Test"); UtTest_Add(CS_BackgroundEeprom_Test, CS_Test_Setup, CS_Test_TearDown, "CS_BackgroundEeprom_Test"); @@ -743,7 +844,12 @@ void UtTest_Setup(void) UtTest_Add(CS_BackgroundApp_Test, CS_Test_Setup, CS_Test_TearDown, "CS_BackgroundApp_Test"); UtTest_Add(CS_ResetTablesTblResultEntry_Test, CS_Test_Setup, CS_Test_TearDown, "CS_ResetTablesTblResultEntry_Test"); UtTest_Add(CS_HandleRoutineTableUpdates_Test, CS_Test_Setup, CS_Test_TearDown, "CS_HandleRoutineTableUpdates_Test"); - UtTest_Add(CS_AttemptTableReshare_Test, CS_Test_Setup, CS_Test_TearDown, "CS_AttemptTableReshare_Test"); UtTest_Add(CS_CheckRecomputeOneShot_Test, CS_Test_Setup, CS_Test_TearDown, "CS_CheckRecomputeOneShot_Test"); UtTest_Add(CS_GetTableTypeAsString_Test, CS_Test_Setup, CS_Test_TearDown, "CS_GetTableTypeAsString_Test"); + + UtTest_Add(Test_CS_SetDefEntryState, CS_Test_Setup, CS_Test_TearDown, "CS_SetDefEntryState"); + UtTest_Add(Test_CS_CheckDefTableNameMatch, CS_Test_Setup, CS_Test_TearDown, "CS_CheckDefTableNameMatch"); + UtTest_Add(Test_CS_CheckResTableNameMatch, CS_Test_Setup, CS_Test_TearDown, "CS_CheckResTableNameMatch"); + UtTest_Add(Test_CS_GetDefEntryAddr, CS_Test_Setup, CS_Test_TearDown, "CS_GetDefEntryAddr"); + UtTest_Add(Test_CS_GetResEntryAddr, CS_Test_Setup, CS_Test_TearDown, "CS_GetResEntryAddr"); } diff --git a/unit-test/stubs/cs_app_cmds_stubs.c b/unit-test/stubs/cs_app_cmds_stubs.c index ce747d5..f36540c 100644 --- a/unit-test/stubs/cs_app_cmds_stubs.c +++ b/unit-test/stubs/cs_app_cmds_stubs.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -28,14 +27,18 @@ /* * ---------------------------------------------------- - * Generated stub function for CS_DisableAppCmd() + * Generated stub function for CS_DisableAppsCmd() * ---------------------------------------------------- */ -void CS_DisableAppCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableAppsCmd(const CS_DisableAppsCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_DisableAppCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_DisableAppsCmd, CFE_Status_t); - UT_GenStub_Execute(CS_DisableAppCmd, Basic, NULL); + UT_GenStub_AddParam(CS_DisableAppsCmd, const CS_DisableAppsCmd_t *, CmdPtr); + + UT_GenStub_Execute(CS_DisableAppsCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_DisableAppsCmd, CFE_Status_t); } /* @@ -43,23 +46,31 @@ void CS_DisableAppCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_DisableNameAppCmd() * ---------------------------------------------------- */ -void CS_DisableNameAppCmd(const CS_AppNameCmd_t *CmdPtr) +CFE_Status_t CS_DisableNameAppCmd(const CS_DisableNameAppCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_DisableNameAppCmd, const CS_AppNameCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_DisableNameAppCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_DisableNameAppCmd, const CS_DisableNameAppCmd_t *, CmdPtr); UT_GenStub_Execute(CS_DisableNameAppCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_DisableNameAppCmd, CFE_Status_t); } /* * ---------------------------------------------------- - * Generated stub function for CS_EnableAppCmd() + * Generated stub function for CS_EnableAppsCmd() * ---------------------------------------------------- */ -void CS_EnableAppCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableAppsCmd(const CS_EnableAppsCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_EnableAppCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_EnableAppsCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_EnableAppsCmd, const CS_EnableAppsCmd_t *, CmdPtr); + + UT_GenStub_Execute(CS_EnableAppsCmd, Basic, NULL); - UT_GenStub_Execute(CS_EnableAppCmd, Basic, NULL); + return UT_GenStub_GetReturnValue(CS_EnableAppsCmd, CFE_Status_t); } /* @@ -67,11 +78,15 @@ void CS_EnableAppCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_EnableNameAppCmd() * ---------------------------------------------------- */ -void CS_EnableNameAppCmd(const CS_AppNameCmd_t *CmdPtr) +CFE_Status_t CS_EnableNameAppCmd(const CS_EnableNameAppCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_EnableNameAppCmd, const CS_AppNameCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_EnableNameAppCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_EnableNameAppCmd, const CS_EnableNameAppCmd_t *, CmdPtr); UT_GenStub_Execute(CS_EnableNameAppCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_EnableNameAppCmd, CFE_Status_t); } /* @@ -79,11 +94,15 @@ void CS_EnableNameAppCmd(const CS_AppNameCmd_t *CmdPtr) * Generated stub function for CS_RecomputeBaselineAppCmd() * ---------------------------------------------------- */ -void CS_RecomputeBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) +CFE_Status_t CS_RecomputeBaselineAppCmd(const CS_RecomputeBaselineAppCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_RecomputeBaselineAppCmd, const CS_AppNameCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_RecomputeBaselineAppCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_RecomputeBaselineAppCmd, const CS_RecomputeBaselineAppCmd_t *, CmdPtr); UT_GenStub_Execute(CS_RecomputeBaselineAppCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_RecomputeBaselineAppCmd, CFE_Status_t); } /* @@ -91,9 +110,13 @@ void CS_RecomputeBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) * Generated stub function for CS_ReportBaselineAppCmd() * ---------------------------------------------------- */ -void CS_ReportBaselineAppCmd(const CS_AppNameCmd_t *CmdPtr) +CFE_Status_t CS_ReportBaselineAppCmd(const CS_ReportBaselineAppCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_ReportBaselineAppCmd, const CS_AppNameCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_ReportBaselineAppCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_ReportBaselineAppCmd, const CS_ReportBaselineAppCmd_t *, CmdPtr); UT_GenStub_Execute(CS_ReportBaselineAppCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_ReportBaselineAppCmd, CFE_Status_t); } diff --git a/unit-test/stubs/cs_app_stubs.c b/unit-test/stubs/cs_app_stubs.c index fd08536..d4be065 100644 --- a/unit-test/stubs/cs_app_stubs.c +++ b/unit-test/stubs/cs_app_stubs.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -51,22 +50,6 @@ void CS_AppMain(void) UT_GenStub_Execute(CS_AppMain, Basic, NULL); } -/* - * ---------------------------------------------------- - * Generated stub function for CS_AppPipe() - * ---------------------------------------------------- - */ -CFE_Status_t CS_AppPipe(const CFE_SB_Buffer_t *BufPtr) -{ - UT_GenStub_SetupReturnBuffer(CS_AppPipe, CFE_Status_t); - - UT_GenStub_AddParam(CS_AppPipe, const CFE_SB_Buffer_t *, BufPtr); - - UT_GenStub_Execute(CS_AppPipe, Basic, NULL); - - return UT_GenStub_GetReturnValue(CS_AppPipe, CFE_Status_t); -} - /* * ---------------------------------------------------- * Generated stub function for CS_CreateRestoreStatesFromCDS() @@ -81,30 +64,6 @@ CFE_Status_t CS_CreateRestoreStatesFromCDS(void) return UT_GenStub_GetReturnValue(CS_CreateRestoreStatesFromCDS, CFE_Status_t); } -/* - * ---------------------------------------------------- - * Generated stub function for CS_HousekeepingCmd() - * ---------------------------------------------------- - */ -void CS_HousekeepingCmd(const CS_NoArgsCmd_t *CmdPtr) -{ - UT_GenStub_AddParam(CS_HousekeepingCmd, const CS_NoArgsCmd_t *, CmdPtr); - - UT_GenStub_Execute(CS_HousekeepingCmd, Basic, NULL); -} - -/* - * ---------------------------------------------------- - * Generated stub function for CS_ProcessCmd() - * ---------------------------------------------------- - */ -void CS_ProcessCmd(const CFE_SB_Buffer_t *BufPtr) -{ - UT_GenStub_AddParam(CS_ProcessCmd, const CFE_SB_Buffer_t *, BufPtr); - - UT_GenStub_Execute(CS_ProcessCmd, Basic, NULL); -} - /* * ---------------------------------------------------- * Generated stub function for CS_UpdateCDS() diff --git a/unit-test/stubs/cs_appdata_global_stub.c b/unit-test/stubs/cs_appdata_global_stub.c index a7938ac..b65194c 100644 --- a/unit-test/stubs/cs_appdata_global_stub.c +++ b/unit-test/stubs/cs_appdata_global_stub.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * diff --git a/unit-test/stubs/cs_cmds_stubs.c b/unit-test/stubs/cs_cmds_stubs.c index 760e9ba..26ff0b9 100644 --- a/unit-test/stubs/cs_cmds_stubs.c +++ b/unit-test/stubs/cs_cmds_stubs.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -28,14 +27,18 @@ /* * ---------------------------------------------------- - * Generated stub function for CS_BackgroundCheckCycle() + * Generated stub function for CS_BackgroundCheckCycleCmd() * ---------------------------------------------------- */ -void CS_BackgroundCheckCycle(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_BackgroundCheckCycleCmd(const CS_BackgroundCheckCycleCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_BackgroundCheckCycle, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_BackgroundCheckCycleCmd, CFE_Status_t); - UT_GenStub_Execute(CS_BackgroundCheckCycle, Basic, NULL); + UT_GenStub_AddParam(CS_BackgroundCheckCycleCmd, const CS_BackgroundCheckCycleCmd_t *, CmdPtr); + + UT_GenStub_Execute(CS_BackgroundCheckCycleCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_BackgroundCheckCycleCmd, CFE_Status_t); } /* @@ -43,11 +46,15 @@ void CS_BackgroundCheckCycle(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_CancelOneShotCmd() * ---------------------------------------------------- */ -void CS_CancelOneShotCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_CancelOneShotCmd(const CS_CancelOneShotCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_CancelOneShotCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_CancelOneShotCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_CancelOneShotCmd, const CS_CancelOneShotCmd_t *, CmdPtr); UT_GenStub_Execute(CS_CancelOneShotCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_CancelOneShotCmd, CFE_Status_t); } /* @@ -55,11 +62,15 @@ void CS_CancelOneShotCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_DisableAllCSCmd() * ---------------------------------------------------- */ -void CS_DisableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableAllCSCmd(const CS_DisableAllCSCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_DisableAllCSCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_DisableAllCSCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_DisableAllCSCmd, const CS_DisableAllCSCmd_t *, CmdPtr); UT_GenStub_Execute(CS_DisableAllCSCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_DisableAllCSCmd, CFE_Status_t); } /* @@ -67,11 +78,15 @@ void CS_DisableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_DisableCfeCoreCmd() * ---------------------------------------------------- */ -void CS_DisableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableCfeCoreCmd(const CS_DisableCfeCoreCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_DisableCfeCoreCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_DisableCfeCoreCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_DisableCfeCoreCmd, const CS_DisableCfeCoreCmd_t *, CmdPtr); UT_GenStub_Execute(CS_DisableCfeCoreCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_DisableCfeCoreCmd, CFE_Status_t); } /* @@ -79,11 +94,15 @@ void CS_DisableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_DisableOSCmd() * ---------------------------------------------------- */ -void CS_DisableOSCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableOSCmd(const CS_DisableOSCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_DisableOSCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_DisableOSCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_DisableOSCmd, const CS_DisableOSCmd_t *, CmdPtr); UT_GenStub_Execute(CS_DisableOSCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_DisableOSCmd, CFE_Status_t); } /* @@ -91,11 +110,15 @@ void CS_DisableOSCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_EnableAllCSCmd() * ---------------------------------------------------- */ -void CS_EnableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableAllCSCmd(const CS_EnableAllCSCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_EnableAllCSCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_EnableAllCSCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_EnableAllCSCmd, const CS_EnableAllCSCmd_t *, CmdPtr); UT_GenStub_Execute(CS_EnableAllCSCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_EnableAllCSCmd, CFE_Status_t); } /* @@ -103,11 +126,15 @@ void CS_EnableAllCSCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_EnableCfeCoreCmd() * ---------------------------------------------------- */ -void CS_EnableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableCfeCoreCmd(const CS_EnableCfeCoreCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_EnableCfeCoreCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_EnableCfeCoreCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_EnableCfeCoreCmd, const CS_EnableCfeCoreCmd_t *, CmdPtr); UT_GenStub_Execute(CS_EnableCfeCoreCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_EnableCfeCoreCmd, CFE_Status_t); } /* @@ -115,11 +142,15 @@ void CS_EnableCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_EnableOSCmd() * ---------------------------------------------------- */ -void CS_EnableOSCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableOSCmd(const CS_EnableOSCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_EnableOSCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_EnableOSCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_EnableOSCmd, const CS_EnableOSCmd_t *, CmdPtr); UT_GenStub_Execute(CS_EnableOSCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_EnableOSCmd, CFE_Status_t); } /* @@ -127,11 +158,15 @@ void CS_EnableOSCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_NoopCmd() * ---------------------------------------------------- */ -void CS_NoopCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_NoopCmd(const CS_NoopCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_NoopCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_NoopCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_NoopCmd, const CS_NoopCmd_t *, CmdPtr); UT_GenStub_Execute(CS_NoopCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_NoopCmd, CFE_Status_t); } /* @@ -139,11 +174,15 @@ void CS_NoopCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_OneShotCmd() * ---------------------------------------------------- */ -void CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr) +CFE_Status_t CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr) { + UT_GenStub_SetupReturnBuffer(CS_OneShotCmd, CFE_Status_t); + UT_GenStub_AddParam(CS_OneShotCmd, const CS_OneShotCmd_t *, CmdPtr); UT_GenStub_Execute(CS_OneShotCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_OneShotCmd, CFE_Status_t); } /* @@ -151,11 +190,15 @@ void CS_OneShotCmd(const CS_OneShotCmd_t *CmdPtr) * Generated stub function for CS_RecomputeBaselineCfeCoreCmd() * ---------------------------------------------------- */ -void CS_RecomputeBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_RecomputeBaselineCfeCoreCmd(const CS_RecomputeBaselineCfeCoreCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_RecomputeBaselineCfeCoreCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_RecomputeBaselineCfeCoreCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_RecomputeBaselineCfeCoreCmd, const CS_RecomputeBaselineCfeCoreCmd_t *, CmdPtr); UT_GenStub_Execute(CS_RecomputeBaselineCfeCoreCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_RecomputeBaselineCfeCoreCmd, CFE_Status_t); } /* @@ -163,11 +206,15 @@ void CS_RecomputeBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_RecomputeBaselineOSCmd() * ---------------------------------------------------- */ -void CS_RecomputeBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_RecomputeBaselineOSCmd(const CS_RecomputeBaselineOSCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_RecomputeBaselineOSCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_RecomputeBaselineOSCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_RecomputeBaselineOSCmd, const CS_RecomputeBaselineOSCmd_t *, CmdPtr); UT_GenStub_Execute(CS_RecomputeBaselineOSCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_RecomputeBaselineOSCmd, CFE_Status_t); } /* @@ -175,11 +222,15 @@ void CS_RecomputeBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_ReportBaselineCfeCoreCmd() * ---------------------------------------------------- */ -void CS_ReportBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_ReportBaselineCfeCoreCmd(const CS_ReportBaselineCfeCoreCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_ReportBaselineCfeCoreCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_ReportBaselineCfeCoreCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_ReportBaselineCfeCoreCmd, const CS_ReportBaselineCfeCoreCmd_t *, CmdPtr); UT_GenStub_Execute(CS_ReportBaselineCfeCoreCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_ReportBaselineCfeCoreCmd, CFE_Status_t); } /* @@ -187,11 +238,15 @@ void CS_ReportBaselineCfeCoreCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_ReportBaselineOSCmd() * ---------------------------------------------------- */ -void CS_ReportBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_ReportBaselineOSCmd(const CS_ReportBaselineOSCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_ReportBaselineOSCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_ReportBaselineOSCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_ReportBaselineOSCmd, const CS_ReportBaselineOSCmd_t *, CmdPtr); UT_GenStub_Execute(CS_ReportBaselineOSCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_ReportBaselineOSCmd, CFE_Status_t); } /* @@ -199,9 +254,29 @@ void CS_ReportBaselineOSCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_ResetCmd() * ---------------------------------------------------- */ -void CS_ResetCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_ResetCmd(const CS_ResetCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_ResetCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_ResetCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_ResetCmd, const CS_ResetCmd_t *, CmdPtr); UT_GenStub_Execute(CS_ResetCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_ResetCmd, CFE_Status_t); +} + +/* + * ---------------------------------------------------- + * Generated stub function for CS_SendHkCmd() + * ---------------------------------------------------- + */ +CFE_Status_t CS_SendHkCmd(const CS_SendHkCmd_t *CmdPtr) +{ + UT_GenStub_SetupReturnBuffer(CS_SendHkCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_SendHkCmd, const CS_SendHkCmd_t *, CmdPtr); + + UT_GenStub_Execute(CS_SendHkCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_SendHkCmd, CFE_Status_t); } diff --git a/unit-test/stubs/cs_compute_stubs.c b/unit-test/stubs/cs_compute_stubs.c index 111ab5c..24a1cc8 100644 --- a/unit-test/stubs/cs_compute_stubs.c +++ b/unit-test/stubs/cs_compute_stubs.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * diff --git a/unit-test/stubs/cs_dispatch_stubs.c b/unit-test/stubs/cs_dispatch_stubs.c new file mode 100644 index 0000000..72f8a43 --- /dev/null +++ b/unit-test/stubs/cs_dispatch_stubs.c @@ -0,0 +1,54 @@ +/************************************************************************ + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" + * + * Copyright (c) 2023 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 + * + * Auto-Generated stub implementations for functions defined in cs_dispatch header + */ + +#include "cs_dispatch.h" +#include "utgenstub.h" + +/* + * ---------------------------------------------------- + * Generated stub function for CS_AppPipe() + * ---------------------------------------------------- + */ +CFE_Status_t CS_AppPipe(const CFE_SB_Buffer_t *BufPtr) +{ + UT_GenStub_SetupReturnBuffer(CS_AppPipe, CFE_Status_t); + + UT_GenStub_AddParam(CS_AppPipe, const CFE_SB_Buffer_t *, BufPtr); + + UT_GenStub_Execute(CS_AppPipe, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_AppPipe, CFE_Status_t); +} + +/* + * ---------------------------------------------------- + * Generated stub function for CS_ProcessCmd() + * ---------------------------------------------------- + */ +void CS_ProcessCmd(const CFE_SB_Buffer_t *BufPtr) +{ + UT_GenStub_AddParam(CS_ProcessCmd, const CFE_SB_Buffer_t *, BufPtr); + + UT_GenStub_Execute(CS_ProcessCmd, Basic, NULL); +} diff --git a/unit-test/stubs/cs_eeprom_cmds_stubs.c b/unit-test/stubs/cs_eeprom_cmds_stubs.c index 372f9c8..d3a798b 100644 --- a/unit-test/stubs/cs_eeprom_cmds_stubs.c +++ b/unit-test/stubs/cs_eeprom_cmds_stubs.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -31,11 +30,15 @@ * Generated stub function for CS_DisableEepromCmd() * ---------------------------------------------------- */ -void CS_DisableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableEepromCmd(const CS_DisableEepromCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_DisableEepromCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_DisableEepromCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_DisableEepromCmd, const CS_DisableEepromCmd_t *, CmdPtr); UT_GenStub_Execute(CS_DisableEepromCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_DisableEepromCmd, CFE_Status_t); } /* @@ -43,11 +46,15 @@ void CS_DisableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_DisableEntryIDEepromCmd() * ---------------------------------------------------- */ -void CS_DisableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_DisableEntryIDEepromCmd(const CS_DisableEntryIDEepromCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_DisableEntryIDEepromCmd, const CS_EntryCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_DisableEntryIDEepromCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_DisableEntryIDEepromCmd, const CS_DisableEntryIDEepromCmd_t *, CmdPtr); UT_GenStub_Execute(CS_DisableEntryIDEepromCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_DisableEntryIDEepromCmd, CFE_Status_t); } /* @@ -55,11 +62,15 @@ void CS_DisableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) * Generated stub function for CS_EnableEepromCmd() * ---------------------------------------------------- */ -void CS_EnableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableEepromCmd(const CS_EnableEepromCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_EnableEepromCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_EnableEepromCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_EnableEepromCmd, const CS_EnableEepromCmd_t *, CmdPtr); UT_GenStub_Execute(CS_EnableEepromCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_EnableEepromCmd, CFE_Status_t); } /* @@ -67,11 +78,15 @@ void CS_EnableEepromCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_EnableEntryIDEepromCmd() * ---------------------------------------------------- */ -void CS_EnableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_EnableEntryIDEepromCmd(const CS_EnableEntryIDEepromCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_EnableEntryIDEepromCmd, const CS_EntryCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_EnableEntryIDEepromCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_EnableEntryIDEepromCmd, const CS_EnableEntryIDEepromCmd_t *, CmdPtr); UT_GenStub_Execute(CS_EnableEntryIDEepromCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_EnableEntryIDEepromCmd, CFE_Status_t); } /* @@ -79,11 +94,15 @@ void CS_EnableEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) * Generated stub function for CS_GetEntryIDEepromCmd() * ---------------------------------------------------- */ -void CS_GetEntryIDEepromCmd(const CS_GetEntryIDCmd_t *CmdPtr) +CFE_Status_t CS_GetEntryIDEepromCmd(const CS_GetEntryIDEepromCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_GetEntryIDEepromCmd, const CS_GetEntryIDCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_GetEntryIDEepromCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_GetEntryIDEepromCmd, const CS_GetEntryIDEepromCmd_t *, CmdPtr); UT_GenStub_Execute(CS_GetEntryIDEepromCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_GetEntryIDEepromCmd, CFE_Status_t); } /* @@ -91,11 +110,15 @@ void CS_GetEntryIDEepromCmd(const CS_GetEntryIDCmd_t *CmdPtr) * Generated stub function for CS_RecomputeBaselineEepromCmd() * ---------------------------------------------------- */ -void CS_RecomputeBaselineEepromCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_RecomputeBaselineEepromCmd(const CS_RecomputeBaselineEepromCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_RecomputeBaselineEepromCmd, const CS_EntryCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_RecomputeBaselineEepromCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_RecomputeBaselineEepromCmd, const CS_RecomputeBaselineEepromCmd_t *, CmdPtr); UT_GenStub_Execute(CS_RecomputeBaselineEepromCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_RecomputeBaselineEepromCmd, CFE_Status_t); } /* @@ -103,9 +126,13 @@ void CS_RecomputeBaselineEepromCmd(const CS_EntryCmd_t *CmdPtr) * Generated stub function for CS_ReportBaselineEntryIDEepromCmd() * ---------------------------------------------------- */ -void CS_ReportBaselineEntryIDEepromCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_ReportBaselineEntryIDEepromCmd(const CS_ReportBaselineEntryIDEepromCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_ReportBaselineEntryIDEepromCmd, const CS_EntryCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_ReportBaselineEntryIDEepromCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_ReportBaselineEntryIDEepromCmd, const CS_ReportBaselineEntryIDEepromCmd_t *, CmdPtr); UT_GenStub_Execute(CS_ReportBaselineEntryIDEepromCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_ReportBaselineEntryIDEepromCmd, CFE_Status_t); } diff --git a/unit-test/stubs/cs_init_stubs.c b/unit-test/stubs/cs_init_stubs.c index a44251f..8658924 100644 --- a/unit-test/stubs/cs_init_stubs.c +++ b/unit-test/stubs/cs_init_stubs.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * diff --git a/unit-test/stubs/cs_memory_cmds_stubs.c b/unit-test/stubs/cs_memory_cmds_stubs.c index 31bcf80..a53f1d3 100644 --- a/unit-test/stubs/cs_memory_cmds_stubs.c +++ b/unit-test/stubs/cs_memory_cmds_stubs.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -31,11 +30,15 @@ * Generated stub function for CS_DisableEntryIDMemoryCmd() * ---------------------------------------------------- */ -void CS_DisableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_DisableEntryIDMemoryCmd(const CS_DisableEntryIDMemoryCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_DisableEntryIDMemoryCmd, const CS_EntryCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_DisableEntryIDMemoryCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_DisableEntryIDMemoryCmd, const CS_DisableEntryIDMemoryCmd_t *, CmdPtr); UT_GenStub_Execute(CS_DisableEntryIDMemoryCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_DisableEntryIDMemoryCmd, CFE_Status_t); } /* @@ -43,11 +46,15 @@ void CS_DisableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) * Generated stub function for CS_DisableMemoryCmd() * ---------------------------------------------------- */ -void CS_DisableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableMemoryCmd(const CS_DisableMemoryCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_DisableMemoryCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_DisableMemoryCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_DisableMemoryCmd, const CS_DisableMemoryCmd_t *, CmdPtr); UT_GenStub_Execute(CS_DisableMemoryCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_DisableMemoryCmd, CFE_Status_t); } /* @@ -55,11 +62,15 @@ void CS_DisableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_EnableEntryIDMemoryCmd() * ---------------------------------------------------- */ -void CS_EnableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_EnableEntryIDMemoryCmd(const CS_EnableEntryIDMemoryCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_EnableEntryIDMemoryCmd, const CS_EntryCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_EnableEntryIDMemoryCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_EnableEntryIDMemoryCmd, const CS_EnableEntryIDMemoryCmd_t *, CmdPtr); UT_GenStub_Execute(CS_EnableEntryIDMemoryCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_EnableEntryIDMemoryCmd, CFE_Status_t); } /* @@ -67,11 +78,15 @@ void CS_EnableEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) * Generated stub function for CS_EnableMemoryCmd() * ---------------------------------------------------- */ -void CS_EnableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableMemoryCmd(const CS_EnableMemoryCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_EnableMemoryCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_EnableMemoryCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_EnableMemoryCmd, const CS_EnableMemoryCmd_t *, CmdPtr); UT_GenStub_Execute(CS_EnableMemoryCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_EnableMemoryCmd, CFE_Status_t); } /* @@ -79,11 +94,15 @@ void CS_EnableMemoryCmd(const CS_NoArgsCmd_t *CmdPtr) * Generated stub function for CS_GetEntryIDMemoryCmd() * ---------------------------------------------------- */ -void CS_GetEntryIDMemoryCmd(const CS_GetEntryIDCmd_t *CmdPtr) +CFE_Status_t CS_GetEntryIDMemoryCmd(const CS_GetEntryIDMemoryCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_GetEntryIDMemoryCmd, const CS_GetEntryIDCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_GetEntryIDMemoryCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_GetEntryIDMemoryCmd, const CS_GetEntryIDMemoryCmd_t *, CmdPtr); UT_GenStub_Execute(CS_GetEntryIDMemoryCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_GetEntryIDMemoryCmd, CFE_Status_t); } /* @@ -91,11 +110,15 @@ void CS_GetEntryIDMemoryCmd(const CS_GetEntryIDCmd_t *CmdPtr) * Generated stub function for CS_RecomputeBaselineMemoryCmd() * ---------------------------------------------------- */ -void CS_RecomputeBaselineMemoryCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_RecomputeBaselineMemoryCmd(const CS_RecomputeBaselineMemoryCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_RecomputeBaselineMemoryCmd, const CS_EntryCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_RecomputeBaselineMemoryCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_RecomputeBaselineMemoryCmd, const CS_RecomputeBaselineMemoryCmd_t *, CmdPtr); UT_GenStub_Execute(CS_RecomputeBaselineMemoryCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_RecomputeBaselineMemoryCmd, CFE_Status_t); } /* @@ -103,9 +126,13 @@ void CS_RecomputeBaselineMemoryCmd(const CS_EntryCmd_t *CmdPtr) * Generated stub function for CS_ReportBaselineEntryIDMemoryCmd() * ---------------------------------------------------- */ -void CS_ReportBaselineEntryIDMemoryCmd(const CS_EntryCmd_t *CmdPtr) +CFE_Status_t CS_ReportBaselineEntryIDMemoryCmd(const CS_ReportBaselineEntryIDMemoryCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_ReportBaselineEntryIDMemoryCmd, const CS_EntryCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_ReportBaselineEntryIDMemoryCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_ReportBaselineEntryIDMemoryCmd, const CS_ReportBaselineEntryIDMemoryCmd_t *, CmdPtr); UT_GenStub_Execute(CS_ReportBaselineEntryIDMemoryCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_ReportBaselineEntryIDMemoryCmd, CFE_Status_t); } diff --git a/unit-test/stubs/cs_table_cmds_stubs.c b/unit-test/stubs/cs_table_cmds_stubs.c index 92ffcf7..7bfa65a 100644 --- a/unit-test/stubs/cs_table_cmds_stubs.c +++ b/unit-test/stubs/cs_table_cmds_stubs.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -28,14 +27,18 @@ /* * ---------------------------------------------------- - * Generated stub function for CS_DisableNameTablesCmd() + * Generated stub function for CS_DisableNameTableCmd() * ---------------------------------------------------- */ -void CS_DisableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr) +CFE_Status_t CS_DisableNameTableCmd(const CS_DisableNameTableCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_DisableNameTablesCmd, const CS_TableNameCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_DisableNameTableCmd, CFE_Status_t); - UT_GenStub_Execute(CS_DisableNameTablesCmd, Basic, NULL); + UT_GenStub_AddParam(CS_DisableNameTableCmd, const CS_DisableNameTableCmd_t *, CmdPtr); + + UT_GenStub_Execute(CS_DisableNameTableCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_DisableNameTableCmd, CFE_Status_t); } /* @@ -43,23 +46,31 @@ void CS_DisableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr) * Generated stub function for CS_DisableTablesCmd() * ---------------------------------------------------- */ -void CS_DisableTablesCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_DisableTablesCmd(const CS_DisableTablesCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_DisableTablesCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_DisableTablesCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_DisableTablesCmd, const CS_DisableTablesCmd_t *, CmdPtr); UT_GenStub_Execute(CS_DisableTablesCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_DisableTablesCmd, CFE_Status_t); } /* * ---------------------------------------------------- - * Generated stub function for CS_EnableNameTablesCmd() + * Generated stub function for CS_EnableNameTableCmd() * ---------------------------------------------------- */ -void CS_EnableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr) +CFE_Status_t CS_EnableNameTableCmd(const CS_EnableNameTableCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_EnableNameTablesCmd, const CS_TableNameCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_EnableNameTableCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_EnableNameTableCmd, const CS_EnableNameTableCmd_t *, CmdPtr); + + UT_GenStub_Execute(CS_EnableNameTableCmd, Basic, NULL); - UT_GenStub_Execute(CS_EnableNameTablesCmd, Basic, NULL); + return UT_GenStub_GetReturnValue(CS_EnableNameTableCmd, CFE_Status_t); } /* @@ -67,33 +78,45 @@ void CS_EnableNameTablesCmd(const CS_TableNameCmd_t *CmdPtr) * Generated stub function for CS_EnableTablesCmd() * ---------------------------------------------------- */ -void CS_EnableTablesCmd(const CS_NoArgsCmd_t *CmdPtr) +CFE_Status_t CS_EnableTablesCmd(const CS_EnableTablesCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_EnableTablesCmd, const CS_NoArgsCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_EnableTablesCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_EnableTablesCmd, const CS_EnableTablesCmd_t *, CmdPtr); UT_GenStub_Execute(CS_EnableTablesCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_EnableTablesCmd, CFE_Status_t); } /* * ---------------------------------------------------- - * Generated stub function for CS_RecomputeBaselineTablesCmd() + * Generated stub function for CS_RecomputeBaselineTableCmd() * ---------------------------------------------------- */ -void CS_RecomputeBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr) +CFE_Status_t CS_RecomputeBaselineTableCmd(const CS_RecomputeBaselineTableCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_RecomputeBaselineTablesCmd, const CS_TableNameCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_RecomputeBaselineTableCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_RecomputeBaselineTableCmd, const CS_RecomputeBaselineTableCmd_t *, CmdPtr); - UT_GenStub_Execute(CS_RecomputeBaselineTablesCmd, Basic, NULL); + UT_GenStub_Execute(CS_RecomputeBaselineTableCmd, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_RecomputeBaselineTableCmd, CFE_Status_t); } /* * ---------------------------------------------------- - * Generated stub function for CS_ReportBaselineTablesCmd() + * Generated stub function for CS_ReportBaselineTableCmd() * ---------------------------------------------------- */ -void CS_ReportBaselineTablesCmd(const CS_TableNameCmd_t *CmdPtr) +CFE_Status_t CS_ReportBaselineTableCmd(const CS_ReportBaselineTableCmd_t *CmdPtr) { - UT_GenStub_AddParam(CS_ReportBaselineTablesCmd, const CS_TableNameCmd_t *, CmdPtr); + UT_GenStub_SetupReturnBuffer(CS_ReportBaselineTableCmd, CFE_Status_t); + + UT_GenStub_AddParam(CS_ReportBaselineTableCmd, const CS_ReportBaselineTableCmd_t *, CmdPtr); + + UT_GenStub_Execute(CS_ReportBaselineTableCmd, Basic, NULL); - UT_GenStub_Execute(CS_ReportBaselineTablesCmd, Basic, NULL); + return UT_GenStub_GetReturnValue(CS_ReportBaselineTableCmd, CFE_Status_t); } diff --git a/unit-test/stubs/cs_table_processing_stubs.c b/unit-test/stubs/cs_table_processing_stubs.c index 0d6b3b7..f9c828d 100644 --- a/unit-test/stubs/cs_table_processing_stubs.c +++ b/unit-test/stubs/cs_table_processing_stubs.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -26,22 +25,28 @@ #include "cs_table_processing.h" #include "utgenstub.h" +/* + * ---------------------------------------------------- + * Generated stub function for CS_CallTableUpdateHandler() + * ---------------------------------------------------- + */ +void CS_CallTableUpdateHandler(CS_TableWrapper_t *tw) +{ + UT_GenStub_AddParam(CS_CallTableUpdateHandler, CS_TableWrapper_t *, tw); + + UT_GenStub_Execute(CS_CallTableUpdateHandler, Basic, NULL); +} + /* * ---------------------------------------------------- * Generated stub function for CS_HandleTableUpdate() * ---------------------------------------------------- */ -CFE_Status_t CS_HandleTableUpdate(void **DefinitionTblPtr, void **ResultsTblPtr, CFE_TBL_Handle_t DefinitionTableHandle, - CFE_TBL_Handle_t ResultsTableHandle, uint16 Table, uint16 NumEntries) +CFE_Status_t CS_HandleTableUpdate(CS_TableWrapper_t *tw) { UT_GenStub_SetupReturnBuffer(CS_HandleTableUpdate, CFE_Status_t); - UT_GenStub_AddParam(CS_HandleTableUpdate, void **, DefinitionTblPtr); - UT_GenStub_AddParam(CS_HandleTableUpdate, void **, ResultsTblPtr); - UT_GenStub_AddParam(CS_HandleTableUpdate, CFE_TBL_Handle_t, DefinitionTableHandle); - UT_GenStub_AddParam(CS_HandleTableUpdate, CFE_TBL_Handle_t, ResultsTableHandle); - UT_GenStub_AddParam(CS_HandleTableUpdate, uint16, Table); - UT_GenStub_AddParam(CS_HandleTableUpdate, uint16, NumEntries); + UT_GenStub_AddParam(CS_HandleTableUpdate, CS_TableWrapper_t *, tw); UT_GenStub_Execute(CS_HandleTableUpdate, Basic, NULL); @@ -53,11 +58,9 @@ CFE_Status_t CS_HandleTableUpdate(void **DefinitionTblPtr, void **ResultsTblPtr, * Generated stub function for CS_ProcessNewAppDefinitionTable() * ---------------------------------------------------- */ -void CS_ProcessNewAppDefinitionTable(const CS_Def_App_Table_Entry_t *DefinitionTblPtr, - CS_Res_App_Table_Entry_t * ResultsTblPtr) +void CS_ProcessNewAppDefinitionTable(CS_TableWrapper_t *tw) { - UT_GenStub_AddParam(CS_ProcessNewAppDefinitionTable, const CS_Def_App_Table_Entry_t *, DefinitionTblPtr); - UT_GenStub_AddParam(CS_ProcessNewAppDefinitionTable, CS_Res_App_Table_Entry_t *, ResultsTblPtr); + UT_GenStub_AddParam(CS_ProcessNewAppDefinitionTable, CS_TableWrapper_t *, tw); UT_GenStub_Execute(CS_ProcessNewAppDefinitionTable, Basic, NULL); } @@ -67,15 +70,9 @@ void CS_ProcessNewAppDefinitionTable(const CS_Def_App_Table_Entry_t *DefinitionT * Generated stub function for CS_ProcessNewEepromMemoryDefinitionTable() * ---------------------------------------------------- */ -void CS_ProcessNewEepromMemoryDefinitionTable(const CS_Def_EepromMemory_Table_Entry_t *DefinitionTblPtr, - CS_Res_EepromMemory_Table_Entry_t *ResultsTblPtr, uint16 NumEntries, - uint16 Table) +void CS_ProcessNewEepromMemoryDefinitionTable(CS_TableWrapper_t *tw) { - UT_GenStub_AddParam(CS_ProcessNewEepromMemoryDefinitionTable, const CS_Def_EepromMemory_Table_Entry_t *, - DefinitionTblPtr); - UT_GenStub_AddParam(CS_ProcessNewEepromMemoryDefinitionTable, CS_Res_EepromMemory_Table_Entry_t *, ResultsTblPtr); - UT_GenStub_AddParam(CS_ProcessNewEepromMemoryDefinitionTable, uint16, NumEntries); - UT_GenStub_AddParam(CS_ProcessNewEepromMemoryDefinitionTable, uint16, Table); + UT_GenStub_AddParam(CS_ProcessNewEepromMemoryDefinitionTable, CS_TableWrapper_t *, tw); UT_GenStub_Execute(CS_ProcessNewEepromMemoryDefinitionTable, Basic, NULL); } @@ -85,11 +82,9 @@ void CS_ProcessNewEepromMemoryDefinitionTable(const CS_Def_EepromMemory_Table_En * Generated stub function for CS_ProcessNewTablesDefinitionTable() * ---------------------------------------------------- */ -void CS_ProcessNewTablesDefinitionTable(const CS_Def_Tables_Table_Entry_t *DefinitionTblPtr, - CS_Res_Tables_Table_Entry_t * ResultsTblPtr) +void CS_ProcessNewTablesDefinitionTable(CS_TableWrapper_t *tw) { - UT_GenStub_AddParam(CS_ProcessNewTablesDefinitionTable, const CS_Def_Tables_Table_Entry_t *, DefinitionTblPtr); - UT_GenStub_AddParam(CS_ProcessNewTablesDefinitionTable, CS_Res_Tables_Table_Entry_t *, ResultsTblPtr); + UT_GenStub_AddParam(CS_ProcessNewTablesDefinitionTable, CS_TableWrapper_t *, tw); UT_GenStub_Execute(CS_ProcessNewTablesDefinitionTable, Basic, NULL); } @@ -99,26 +94,13 @@ void CS_ProcessNewTablesDefinitionTable(const CS_Def_Tables_Table_Entry_t *Defin * Generated stub function for CS_TableInit() * ---------------------------------------------------- */ -CFE_Status_t CS_TableInit(CFE_TBL_Handle_t *DefinitionTableHandle, CFE_TBL_Handle_t *ResultsTableHandle, - void **DefinitionTblPtr, void **ResultsTblPtr, uint16 Table, const char *DefinitionTableName, - const char *ResultsTableName, uint16 NumEntries, const char *DefinitionTableFileName, - const void *DefaultDefTableAddress, uint16 SizeofDefinitionTableEntry, - uint16 SizeofResultsTableEntry, CFE_TBL_CallbackFuncPtr_t CallBackFunction) +CFE_Status_t CS_TableInit(CS_TableWrapper_t *tw, const char *DefinitionTableFileName, + CFE_TBL_CallbackFuncPtr_t CallBackFunction) { UT_GenStub_SetupReturnBuffer(CS_TableInit, CFE_Status_t); - UT_GenStub_AddParam(CS_TableInit, CFE_TBL_Handle_t *, DefinitionTableHandle); - UT_GenStub_AddParam(CS_TableInit, CFE_TBL_Handle_t *, ResultsTableHandle); - UT_GenStub_AddParam(CS_TableInit, void **, DefinitionTblPtr); - UT_GenStub_AddParam(CS_TableInit, void **, ResultsTblPtr); - UT_GenStub_AddParam(CS_TableInit, uint16, Table); - UT_GenStub_AddParam(CS_TableInit, const char *, DefinitionTableName); - UT_GenStub_AddParam(CS_TableInit, const char *, ResultsTableName); - UT_GenStub_AddParam(CS_TableInit, uint16, NumEntries); + UT_GenStub_AddParam(CS_TableInit, CS_TableWrapper_t *, tw); UT_GenStub_AddParam(CS_TableInit, const char *, DefinitionTableFileName); - UT_GenStub_AddParam(CS_TableInit, const void *, DefaultDefTableAddress); - UT_GenStub_AddParam(CS_TableInit, uint16, SizeofDefinitionTableEntry); - UT_GenStub_AddParam(CS_TableInit, uint16, SizeofResultsTableEntry); UT_GenStub_AddParam(CS_TableInit, CFE_TBL_CallbackFuncPtr_t, CallBackFunction); UT_GenStub_Execute(CS_TableInit, Basic, NULL); diff --git a/unit-test/stubs/cs_utils_stubs.c b/unit-test/stubs/cs_utils_stubs.c index 51c4651..5ab708b 100644 --- a/unit-test/stubs/cs_utils_stubs.c +++ b/unit-test/stubs/cs_utils_stubs.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -26,27 +25,6 @@ #include "cs_utils.h" #include "utgenstub.h" -/* - * ---------------------------------------------------- - * Generated stub function for CS_AttemptTableReshare() - * ---------------------------------------------------- - */ -CFE_Status_t CS_AttemptTableReshare(CS_Res_Tables_Table_Entry_t *ResultsEntry, CFE_TBL_Handle_t *LocalTblHandle, - CFE_TBL_Info_t *TblInfo, cpuaddr *LocalAddress, int32 *ResultGetInfo) -{ - UT_GenStub_SetupReturnBuffer(CS_AttemptTableReshare, CFE_Status_t); - - UT_GenStub_AddParam(CS_AttemptTableReshare, CS_Res_Tables_Table_Entry_t *, ResultsEntry); - UT_GenStub_AddParam(CS_AttemptTableReshare, CFE_TBL_Handle_t *, LocalTblHandle); - UT_GenStub_AddParam(CS_AttemptTableReshare, CFE_TBL_Info_t *, TblInfo); - UT_GenStub_AddParam(CS_AttemptTableReshare, cpuaddr *, LocalAddress); - UT_GenStub_AddParam(CS_AttemptTableReshare, int32 *, ResultGetInfo); - - UT_GenStub_Execute(CS_AttemptTableReshare, Basic, NULL); - - return UT_GenStub_GetReturnValue(CS_AttemptTableReshare, CFE_Status_t); -} - /* * ---------------------------------------------------- * Generated stub function for CS_BackgroundApp() @@ -131,6 +109,23 @@ bool CS_BackgroundTables(void) return UT_GenStub_GetReturnValue(CS_BackgroundTables, bool); } +/* + * ---------------------------------------------------- + * Generated stub function for CS_CheckDefTableNameMatch() + * ---------------------------------------------------- + */ +bool CS_CheckDefTableNameMatch(const char *Name, uint16 TableIdx) +{ + UT_GenStub_SetupReturnBuffer(CS_CheckDefTableNameMatch, bool); + + UT_GenStub_AddParam(CS_CheckDefTableNameMatch, const char *, Name); + UT_GenStub_AddParam(CS_CheckDefTableNameMatch, uint16, TableIdx); + + UT_GenStub_Execute(CS_CheckDefTableNameMatch, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_CheckDefTableNameMatch, bool); +} + /* * ---------------------------------------------------- * Generated stub function for CS_CheckRecomputeOneshot() @@ -147,18 +142,33 @@ bool CS_CheckRecomputeOneshot(void) /* * ---------------------------------------------------- - * Generated stub function for CS_FindEnabledAppEntry() + * Generated stub function for CS_CheckResTableNameMatch() * ---------------------------------------------------- */ -bool CS_FindEnabledAppEntry(uint16 *EnabledEntry) +bool CS_CheckResTableNameMatch(const char *Name, uint16 TableIdx) { - UT_GenStub_SetupReturnBuffer(CS_FindEnabledAppEntry, bool); + UT_GenStub_SetupReturnBuffer(CS_CheckResTableNameMatch, bool); - UT_GenStub_AddParam(CS_FindEnabledAppEntry, uint16 *, EnabledEntry); + UT_GenStub_AddParam(CS_CheckResTableNameMatch, const char *, Name); + UT_GenStub_AddParam(CS_CheckResTableNameMatch, uint16, TableIdx); + + UT_GenStub_Execute(CS_CheckResTableNameMatch, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_CheckResTableNameMatch, bool); +} + +/* + * ---------------------------------------------------- + * Generated stub function for CS_FindEnabledAppEntry() + * ---------------------------------------------------- + */ +CS_Res_App_Table_Entry_t *CS_FindEnabledAppEntry(void) +{ + UT_GenStub_SetupReturnBuffer(CS_FindEnabledAppEntry, CS_Res_App_Table_Entry_t *); UT_GenStub_Execute(CS_FindEnabledAppEntry, Basic, NULL); - return UT_GenStub_GetReturnValue(CS_FindEnabledAppEntry, bool); + return UT_GenStub_GetReturnValue(CS_FindEnabledAppEntry, CS_Res_App_Table_Entry_t *); } /* @@ -166,15 +176,13 @@ bool CS_FindEnabledAppEntry(uint16 *EnabledEntry) * Generated stub function for CS_FindEnabledEepromEntry() * ---------------------------------------------------- */ -bool CS_FindEnabledEepromEntry(uint16 *EnabledEntry) +CS_Res_EepromMemory_Table_Entry_t *CS_FindEnabledEepromEntry(void) { - UT_GenStub_SetupReturnBuffer(CS_FindEnabledEepromEntry, bool); - - UT_GenStub_AddParam(CS_FindEnabledEepromEntry, uint16 *, EnabledEntry); + UT_GenStub_SetupReturnBuffer(CS_FindEnabledEepromEntry, CS_Res_EepromMemory_Table_Entry_t *); UT_GenStub_Execute(CS_FindEnabledEepromEntry, Basic, NULL); - return UT_GenStub_GetReturnValue(CS_FindEnabledEepromEntry, bool); + return UT_GenStub_GetReturnValue(CS_FindEnabledEepromEntry, CS_Res_EepromMemory_Table_Entry_t *); } /* @@ -182,15 +190,13 @@ bool CS_FindEnabledEepromEntry(uint16 *EnabledEntry) * Generated stub function for CS_FindEnabledMemoryEntry() * ---------------------------------------------------- */ -bool CS_FindEnabledMemoryEntry(uint16 *EnabledEntry) +CS_Res_EepromMemory_Table_Entry_t *CS_FindEnabledMemoryEntry(void) { - UT_GenStub_SetupReturnBuffer(CS_FindEnabledMemoryEntry, bool); - - UT_GenStub_AddParam(CS_FindEnabledMemoryEntry, uint16 *, EnabledEntry); + UT_GenStub_SetupReturnBuffer(CS_FindEnabledMemoryEntry, CS_Res_EepromMemory_Table_Entry_t *); UT_GenStub_Execute(CS_FindEnabledMemoryEntry, Basic, NULL); - return UT_GenStub_GetReturnValue(CS_FindEnabledMemoryEntry, bool); + return UT_GenStub_GetReturnValue(CS_FindEnabledMemoryEntry, CS_Res_EepromMemory_Table_Entry_t *); } /* @@ -198,15 +204,13 @@ bool CS_FindEnabledMemoryEntry(uint16 *EnabledEntry) * Generated stub function for CS_FindEnabledTablesEntry() * ---------------------------------------------------- */ -bool CS_FindEnabledTablesEntry(uint16 *EnabledEntry) +CS_Res_Tables_Table_Entry_t *CS_FindEnabledTablesEntry(void) { - UT_GenStub_SetupReturnBuffer(CS_FindEnabledTablesEntry, bool); - - UT_GenStub_AddParam(CS_FindEnabledTablesEntry, uint16 *, EnabledEntry); + UT_GenStub_SetupReturnBuffer(CS_FindEnabledTablesEntry, CS_Res_Tables_Table_Entry_t *); UT_GenStub_Execute(CS_FindEnabledTablesEntry, Basic, NULL); - return UT_GenStub_GetReturnValue(CS_FindEnabledTablesEntry, bool); + return UT_GenStub_GetReturnValue(CS_FindEnabledTablesEntry, CS_Res_Tables_Table_Entry_t *); } /* @@ -243,6 +247,40 @@ bool CS_GetAppResTblEntryByName(CS_Res_App_Table_Entry_t **EntryPtr, const char return UT_GenStub_GetReturnValue(CS_GetAppResTblEntryByName, bool); } +/* + * ---------------------------------------------------- + * Generated stub function for CS_GetDefEntryAddr() + * ---------------------------------------------------- + */ +void *CS_GetDefEntryAddr(CS_TableWrapper_t *tw, uint16 EntryIdx) +{ + UT_GenStub_SetupReturnBuffer(CS_GetDefEntryAddr, void *); + + UT_GenStub_AddParam(CS_GetDefEntryAddr, CS_TableWrapper_t *, tw); + UT_GenStub_AddParam(CS_GetDefEntryAddr, uint16, EntryIdx); + + UT_GenStub_Execute(CS_GetDefEntryAddr, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_GetDefEntryAddr, void *); +} + +/* + * ---------------------------------------------------- + * Generated stub function for CS_GetResEntryAddr() + * ---------------------------------------------------- + */ +void *CS_GetResEntryAddr(CS_TableWrapper_t *tw, uint16 EntryIdx) +{ + UT_GenStub_SetupReturnBuffer(CS_GetResEntryAddr, void *); + + UT_GenStub_AddParam(CS_GetResEntryAddr, CS_TableWrapper_t *, tw); + UT_GenStub_AddParam(CS_GetResEntryAddr, uint16, EntryIdx); + + UT_GenStub_Execute(CS_GetResEntryAddr, Basic, NULL); + + return UT_GenStub_GetReturnValue(CS_GetResEntryAddr, void *); +} + /* * ---------------------------------------------------- * Generated stub function for CS_GetTableDefTblEntryByName() @@ -282,11 +320,11 @@ bool CS_GetTableResTblEntryByName(CS_Res_Tables_Table_Entry_t **EntryPtr, const * Generated stub function for CS_GetTableTypeAsString() * ---------------------------------------------------- */ -const char *CS_GetTableTypeAsString(uint32 TableId) +const char *CS_GetTableTypeAsString(const CS_TableWrapper_t *Tbl) { UT_GenStub_SetupReturnBuffer(CS_GetTableTypeAsString, const char *); - UT_GenStub_AddParam(CS_GetTableTypeAsString, uint32, TableId); + UT_GenStub_AddParam(CS_GetTableTypeAsString, const CS_TableWrapper_t *, Tbl); UT_GenStub_Execute(CS_GetTableTypeAsString, Basic, NULL); @@ -343,19 +381,20 @@ void CS_ResetTablesTblResultEntry(CS_Res_Tables_Table_Entry_t *TablesTblResultEn /* * ---------------------------------------------------- - * Generated stub function for CS_VerifyCmdLength() + * Generated stub function for CS_SetDefEntryState() * ---------------------------------------------------- */ -bool CS_VerifyCmdLength(const CFE_MSG_Message_t *msg, size_t ExpectedLength) +CS_ChecksumState_Enum_t CS_SetDefEntryState(CS_TableWrapper_t *tw, void *EntryPtr, CS_ChecksumState_Enum_t NewState) { - UT_GenStub_SetupReturnBuffer(CS_VerifyCmdLength, bool); + UT_GenStub_SetupReturnBuffer(CS_SetDefEntryState, CS_ChecksumState_Enum_t); - UT_GenStub_AddParam(CS_VerifyCmdLength, const CFE_MSG_Message_t *, msg); - UT_GenStub_AddParam(CS_VerifyCmdLength, size_t, ExpectedLength); + UT_GenStub_AddParam(CS_SetDefEntryState, CS_TableWrapper_t *, tw); + UT_GenStub_AddParam(CS_SetDefEntryState, void *, EntryPtr); + UT_GenStub_AddParam(CS_SetDefEntryState, CS_ChecksumState_Enum_t, NewState); - UT_GenStub_Execute(CS_VerifyCmdLength, Basic, NULL); + UT_GenStub_Execute(CS_SetDefEntryState, Basic, NULL); - return UT_GenStub_GetReturnValue(CS_VerifyCmdLength, bool); + return UT_GenStub_GetReturnValue(CS_SetDefEntryState, CS_ChecksumState_Enum_t); } /* diff --git a/unit-test/utilities/cs_test_utils.c b/unit-test/utilities/cs_test_utils.c index d16f696..86eddbb 100644 --- a/unit-test/utilities/cs_test_utils.c +++ b/unit-test/utilities/cs_test_utils.c @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -22,6 +21,7 @@ */ #include "cs_test_utils.h" +#include "cs_utils.h" #include "cs_tbldefs.h" /* UT includes */ @@ -42,6 +42,15 @@ CS_Res_App_Table_Entry_t CS_DefaultAppResTable[CS_MAX_NUM_APP_TABLE_ENT CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent[UT_MAX_SENDEVENT_DEPTH]; CFE_ES_WriteToSysLog_context_t context_CFE_ES_WriteToSysLog; +struct CS_SetDefEntryState_Context +{ + void * EntryPtr; + CS_ChecksumState_Enum_t NewState; + CS_ChecksumState_Enum_t OldState; +}; + +static struct CS_SetDefEntryState_Context CS_SetDefEntryState_Context; + void UT_Handler_CFE_EVS_SendEvent(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context, va_list va) { uint16 CallCount; @@ -73,27 +82,117 @@ void UT_Handler_CFE_ES_WriteToSysLog(void *UserObj, UT_EntryKey_t FuncKey, const context_CFE_ES_WriteToSysLog.Spec[CFE_MISSION_EVS_MAX_MESSAGE_LENGTH - 1] = '\0'; } +void UT_Handler_CS_TableEntry(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context) +{ + CS_TableWrapper_t *tw = UT_Hook_GetArgValueByName(Context, "tw", CS_TableWrapper_t *); + uint16 EntryIdx = UT_Hook_GetArgValueByName(Context, "EntryIdx", uint16); + uint8 * Base; + int32 Status; + + Base = NULL; + Status = 0; + + if ((!UT_Stub_GetInt32StatusCode(Context, &Status) && EntryIdx < tw->NumEntries) || Status != 0) + { + if (FuncKey == UT_KEY(CS_GetDefEntryAddr)) + { + Base = tw->DefAddr; + Base += (tw->DefEntrySize * EntryIdx); + } + else if (FuncKey == UT_KEY(CS_GetResEntryAddr)) + { + Base = tw->ResAddr; + Base += (tw->ResEntrySize * EntryIdx); + } + } + + UT_Stub_SetReturnValue(FuncKey, Base); +} + +void UT_Handler_CS_SetDefEntryState(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context) +{ + struct CS_SetDefEntryState_Context *Ctxt = UserObj; + + Ctxt->EntryPtr = UT_Hook_GetArgValueByName(Context, "EntryPtr", void *); + Ctxt->NewState = UT_Hook_GetArgValueByName(Context, "NewState", CS_ChecksumState_Enum_t); + + UT_Stub_SetReturnValue(FuncKey, Ctxt->OldState); +} + +void CS_Test_Setup_SetDefEntryState(CS_ChecksumState_Enum_t OldState) +{ + memset(&CS_SetDefEntryState_Context, 0, sizeof(CS_SetDefEntryState_Context)); + CS_SetDefEntryState_Context.OldState = OldState; + UT_SetHandlerFunction(UT_KEY(CS_SetDefEntryState), UT_Handler_CS_SetDefEntryState, &CS_SetDefEntryState_Context); +} + +void CS_Test_Check_SetDefEntryState(void *EntryPtr, CS_ChecksumState_Enum_t NewState) +{ + UtAssert_ADDRESS_EQ(CS_SetDefEntryState_Context.EntryPtr, EntryPtr); + UtAssert_UINT32_EQ(CS_SetDefEntryState_Context.NewState, NewState); +} + +void CS_Test_ResetEventCheck(void) +{ + memset(context_CFE_EVS_SendEvent, 0, sizeof(context_CFE_EVS_SendEvent)); + UT_ResetState(UT_KEY(CFE_EVS_SendEvent)); + UT_SetVaHandlerFunction(UT_KEY(CFE_EVS_SendEvent), UT_Handler_CFE_EVS_SendEvent, NULL); +} + void CS_Test_Setup(void) { + CS_TableWrapper_t *tw; /* initialize test environment to default state for every test */ UT_ResetState(0); memset(&CS_AppData, 0, sizeof(CS_AppData)); - memset(context_CFE_EVS_SendEvent, 0, sizeof(context_CFE_EVS_SendEvent)); memset(&context_CFE_ES_WriteToSysLog, 0, sizeof(context_CFE_ES_WriteToSysLog)); /* Register custom handlers */ - UT_SetVaHandlerFunction(UT_KEY(CFE_EVS_SendEvent), UT_Handler_CFE_EVS_SendEvent, NULL); + CS_Test_ResetEventCheck(); UT_SetVaHandlerFunction(UT_KEY(CFE_ES_WriteToSysLog), UT_Handler_CFE_ES_WriteToSysLog, NULL); - CS_AppData.DefEepromTblPtr = &CS_AppData.DefaultEepromDefTable[0]; - CS_AppData.ResEepromTblPtr = &CS_DefaultEepromResTable[0]; - CS_AppData.DefMemoryTblPtr = &CS_AppData.DefaultMemoryDefTable[0]; - CS_AppData.ResMemoryTblPtr = &CS_DefaultMemoryResTable[0]; - CS_AppData.DefTablesTblPtr = &CS_AppData.DefaultTablesDefTable[0]; - CS_AppData.ResTablesTblPtr = &CS_DefaultTablesResTable[0]; - CS_AppData.DefAppTblPtr = &CS_AppData.DefaultAppDefTable[0]; - CS_AppData.ResAppTblPtr = &CS_DefaultAppResTable[0]; + UT_SetHandlerFunction(UT_KEY(CS_GetDefEntryAddr), UT_Handler_CS_TableEntry, NULL); + UT_SetHandlerFunction(UT_KEY(CS_GetResEntryAddr), UT_Handler_CS_TableEntry, NULL); + + tw = &CS_AppData.Tbl[CS_ChecksumType_CFECORE]; + tw->ResAddr = &CS_AppData.CfeCoreCodeSeg; + tw->NumEntries = 1; + tw->ResEntrySize = sizeof(CS_Res_EepromMemory_Table_Entry_t); + tw->BaselineValue = &CS_AppData.HkPacket.Payload.CfeCoreBaseline; + tw = &CS_AppData.Tbl[CS_ChecksumType_OSCORE]; + tw->ResAddr = &CS_AppData.OSCodeSeg; + tw->NumEntries = 1; + tw->ResEntrySize = sizeof(CS_Res_EepromMemory_Table_Entry_t); + tw->BaselineValue = &CS_AppData.HkPacket.Payload.OSBaseline; + tw = &CS_AppData.Tbl[CS_ChecksumType_EEPROM_TABLE]; + tw->DefAddr = &CS_AppData.DefaultEepromDefTable[0]; + tw->ResAddr = &CS_DefaultEepromResTable[0]; + tw->NumEntries = CS_MAX_NUM_EEPROM_TABLE_ENTRIES; + tw->DefEntrySize = sizeof(CS_Def_EepromMemory_Table_Entry_t); + tw->ResEntrySize = sizeof(CS_Res_EepromMemory_Table_Entry_t); + tw->GlobalState = &CS_AppData.HkPacket.Payload.EepromCSState; + tw = &CS_AppData.Tbl[CS_ChecksumType_MEMORY_TABLE]; + tw->DefAddr = &CS_AppData.DefaultMemoryDefTable[0]; + tw->ResAddr = &CS_DefaultMemoryResTable[0]; + tw->NumEntries = CS_MAX_NUM_MEMORY_TABLE_ENTRIES; + tw->DefEntrySize = sizeof(CS_Def_EepromMemory_Table_Entry_t); + tw->ResEntrySize = sizeof(CS_Res_EepromMemory_Table_Entry_t); + tw->GlobalState = &CS_AppData.HkPacket.Payload.MemoryCSState; + tw = &CS_AppData.Tbl[CS_ChecksumType_TABLES_TABLE]; + tw->DefAddr = &CS_AppData.DefaultTablesDefTable[0]; + tw->ResAddr = &CS_DefaultTablesResTable[0]; + tw->NumEntries = CS_MAX_NUM_TABLES_TABLE_ENTRIES; + tw->DefEntrySize = sizeof(CS_Def_Tables_Table_Entry_t); + tw->ResEntrySize = sizeof(CS_Res_Tables_Table_Entry_t); + tw->GlobalState = &CS_AppData.HkPacket.Payload.TablesCSState; + tw = &CS_AppData.Tbl[CS_ChecksumType_APP_TABLE]; + tw->DefAddr = &CS_AppData.DefaultAppDefTable[0]; + tw->ResAddr = &CS_DefaultAppResTable[0]; + tw->NumEntries = CS_MAX_NUM_APP_TABLE_ENTRIES; + tw->DefEntrySize = sizeof(CS_Def_App_Table_Entry_t); + tw->ResEntrySize = sizeof(CS_Res_App_Table_Entry_t); + tw->GlobalState = &CS_AppData.HkPacket.Payload.AppCSState; memset(CS_DefaultEepromResTable, 0, sizeof(CS_DefaultEepromResTable)); memset(CS_DefaultMemoryResTable, 0, sizeof(CS_DefaultMemoryResTable)); diff --git a/unit-test/utilities/cs_test_utils.h b/unit-test/utilities/cs_test_utils.h index 66a5b1c..0b027a1 100644 --- a/unit-test/utilities/cs_test_utils.h +++ b/unit-test/utilities/cs_test_utils.h @@ -1,8 +1,7 @@ /************************************************************************ - * NASA Docket No. GSC-18,915-1, and identified as “cFS Checksum - * Application version 2.5.1” + * NASA Docket No. GSC-19,200-1, and identified as "cFS Draco" * - * Copyright (c) 2021 United States Government as represented by the + * Copyright (c) 2023 United States Government as represented by the * Administrator of the National Aeronautics and Space Administration. * All Rights Reserved. * @@ -54,4 +53,8 @@ extern CFE_ES_WriteToSysLog_context_t context_CFE_ES_WriteToSysLog; void CS_Test_Setup(void); void CS_Test_TearDown(void); +void CS_Test_ResetEventCheck(void); +void CS_Test_Setup_SetDefEntryState(CS_ChecksumState_Enum_t OldState); +void CS_Test_Check_SetDefEntryState(void *EntryPtr, CS_ChecksumState_Enum_t NewState); + #endif