Merge pull request #174 from jphickey/fix-168-psp-coverage-ut

Fix #168, PSP coverage unit test

CMakeLists.txt

@@ -28,6 +28,7 @@ add_library(psp-${CFE_PSP_TARGETNAME} STATIC
 )
 
 if (ENABLE_UNIT_TESTS)
- add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/fsw/ut-stubs)
+ add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ut-stubs)
+ add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/unit-test-coverage)
 endif (ENABLE_UNIT_TESTS)
 

unit-test-coverage/.gitignore

@@ -0,0 +1,7 @@
+*~
+*.o
+*.gcov
+*.gcda
+*.gcno
+*.exe
+*_log.txt

unit-test-coverage/CMakeLists.txt

@@ -0,0 +1,38 @@
+######################################################################
+#
+# CMAKE build recipe for PSP white-box coverage tests
+#
+######################################################################
+
+# The following cache variables are recognized:
+# PSPCOVERAGE_TARGETS -> the intended PSP module(s) that run on the actual target
+#
+# Like OSAL coverage testing, the actual underlying OS calls are stubbed out, there
+# is no dependency on the actual underlying OS. All coverage tests can be built on
+# all platforms regardless of the actual PSP in use for flight software.
+
+project(PSPCOVERAGE C)
+
+# Currently only mcp750-vxworks is implemented a demonstration of how this works.
+set(PSPCOVERAGE_TARGETS "mcp750-vxworks" CACHE STRING "PSP target(s) to build coverage tests for (default=all)")
+
+# Check that coverage has been implemented for this PSPTYPE
+foreach(PSPTYPE ${PSPCOVERAGE_TARGETS})
+ if (NOT IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${PSPTYPE})
+ message(FATAL_ERROR "No coverage tests implemented for ${PSPTYPE}")
+ endif (NOT IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${PSPTYPE})
+endforeach(PSPTYPE ${PSPCOVERAGE_TARGETS})
+
+message(STATUS "PSP Coverage Test Targets: ${PSPCOVERAGE_TARGETS}")
+
+# Utilize the shared UT assert library, along with the standard OSAL includes
+include_directories(${UT_ASSERT_SOURCE_DIR}/inc)
+include_directories(${PSPCOVERAGE_SOURCE_DIR}/ut-stubs/inc)
+
+add_subdirectory(ut-stubs)
+
+# Build targets for each of the indicated PSPs
+foreach(SETNAME ${PSPCOVERAGE_TARGETS})
+ add_subdirectory(${SETNAME})
+endforeach(SETNAME ${PSPCOVERAGE_TARGETS})
+

unit-test-coverage/mcp750-vxworks/CMakeLists.txt

@@ -0,0 +1,63 @@
+######################################################################
+#
+# CMAKE build recipe for mcp750-vxworks PSP white-box coverage tests
+#
+######################################################################
+
+include_directories("${CFEPSP_SOURCE_DIR}/fsw/mcp750-vxworks/inc")
+include_directories("${PSPCOVERAGE_SOURCE_DIR}/shared/inc")
+
+# The target names will be the PSP name with a "ut" prefix
+# this is to distinguish these test targets from the FSW targets.
+set(CFE_PSP_TARGETNAME "ut-${SETNAME}")
+add_subdirectory("${CFEPSP_SOURCE_DIR}/fsw/${SETNAME}" "${CFE_PSP_TARGETNAME}-impl")
+add_subdirectory("${CFEPSP_SOURCE_DIR}/fsw/shared" "${CFE_PSP_TARGETNAME}-shared")
+add_subdirectory(adaptors)
+
+# as UT assert defines OS_Application_Startup and OS_Application_Run, we need
+# to change the ones in this module to a different name.
+target_compile_definitions(psp-${CFE_PSP_TARGETNAME}-impl PRIVATE
+ OS_Application_Startup=UT_OS_Application_Startup
+ OS_Application_Run=UT_OS_Application_Run
+)
+
+# only the actual FSW src file gets the coverage instrumentation
+target_compile_options(psp-${CFE_PSP_TARGETNAME}-impl PRIVATE
+ ${UT_COVERAGE_COMPILE_FLAGS}
+)
+target_compile_options(psp-${CFE_PSP_TARGETNAME}-shared PRIVATE
+ ${UT_COVERAGE_COMPILE_FLAGS}
+)
+
+# both the FSW src file and the adaptor file get compiled with override includes
+target_include_directories(psp-${CFE_PSP_TARGETNAME}-impl BEFORE PRIVATE
+ ${PSPCOVERAGE_SOURCE_DIR}/ut-stubs/override_inc
+)
+target_include_directories(psp-${CFE_PSP_TARGETNAME}-shared BEFORE PRIVATE
+ ${PSPCOVERAGE_SOURCE_DIR}/ut-stubs/override_inc
+)
+
+add_executable(coverage-${CFE_PSP_TARGETNAME}-testrunner
+ src/coveragetest-psp-mcp750-vxworks.c
+ src/coveragetest-cfe-psp-start.c
+ src/coveragetest-cfe-psp-support.c
+ ${PSPCOVERAGE_SOURCE_DIR}/shared/src/coveragetest-cfe-psp-exceptionstorage.c
+ $<TARGET_OBJECTS:psp-${CFE_PSP_TARGETNAME}-shared>
+ $<TARGET_OBJECTS:psp-${CFE_PSP_TARGETNAME}-impl>
+)
+
+target_link_libraries(coverage-${CFE_PSP_TARGETNAME}-testrunner
+ ${UT_COVERAGE_LINK_FLAGS}
+ ut-adaptor-${CFE_PSP_TARGETNAME}
+ ut_psp_cfe_stubs
+ ut_psp_libc_stubs
+ ut_osapi_stubs
+ ut_assert
+)
+
+add_test(coverage-${CFE_PSP_TARGETNAME} coverage-${CFE_PSP_TARGETNAME}-testrunner)
+
+foreach(TGT ${INSTALL_TARGET_LIST})
+ install(TARGETS coverage-${CFE_PSP_TARGETNAME}-testrunner DESTINATION ${TGTNAME}/${UT_INSTALL_SUBDIR})
+endforeach()
+

unit-test-coverage/mcp750-vxworks/adaptors/CMakeLists.txt

@@ -0,0 +1,33 @@
+#
+# Copyright (c) 2019, United States government as represented by the
+# administrator of the National Aeronautics Space Administration.
+# All rights reserved. This software was created at NASA Goddard
+# Space Flight Center pursuant to government contracts.
+#
+# This is governed by the NASA Open Source Agreement and may be used,
+# distributed and modified only according to the terms of that agreement.
+#
+
+
+# "Adaptors" help enable the unit test code to reach functions/objects that
+# are otherwise not exposed. 
+
+# NOTE: These source files are compile with OVERRIDES on the headers just like
+# the FSW code is compiled. This is how it is able to include internal headers
+# which otherwise would fail. But that also means that adaptor code cannot call
+# any library functions, as this would also reach a stub, not the real function.
+
+add_library(ut-adaptor-${CFE_PSP_TARGETNAME} STATIC
+ src/ut-adaptor-bootrec.c
+ ${PSPCOVERAGE_SOURCE_DIR}/shared/adaptors/src/ut-adaptor-exceptions.c
+)
+
+# the "override_inc" dir contains replacement versions of the C-library include files.
+target_include_directories(ut-adaptor-${CFE_PSP_TARGETNAME} BEFORE PRIVATE
+ ${PSPCOVERAGE_SOURCE_DIR}/ut-stubs/override_inc
+)
+
+target_include_directories(ut-adaptor-${CFE_PSP_TARGETNAME} PUBLIC
+ ${CMAKE_CURRENT_SOURCE_DIR}/inc
+ ${PSPCOVERAGE_SOURCE_DIR}/shared/adaptors/inc
+)

unit-test-coverage/mcp750-vxworks/adaptors/inc/ut-adaptor-bootrec.h

@@ -0,0 +1,32 @@
+/*
+ * 
+ * Copyright (c) 2020, United States government as represented by the
+ * administrator of the National Aeronautics Space Administration.
+ * All rights reserved. This software was created at NASA Goddard
+ * Space Flight Center pursuant to government contracts.
+ * 
+ * This is governed by the NASA Open Source Agreement and may be used,
+ * distributed and modified only according to the terms of that agreement.
+ * 
+ */
+
+
+/**
+ * \file ut-adaptor-bootrec.h
+ * \ingroup adaptors
+ * \author joseph.p.hickey@nasa.gov
+ *
+ */
+
+#ifndef INCLUDE_UT_ADAPTOR_BOOTREC_H_
+#define INCLUDE_UT_ADAPTOR_BOOTREC_H_
+
+#include <common_types.h>
+
+void UT_Setup_ReservedMem_BootRec(void);
+uint32 UT_Get_ReservedMem_BootType(void);
+void UT_Set_ReservedMem_BootType(uint32 reset_type);
+
+
+#endif /* INCLUDE_UT_ADAPTOR_BOOTREC_H_ */
+

unit-test-coverage/mcp750-vxworks/adaptors/src/ut-adaptor-bootrec.c

@@ -0,0 +1,47 @@
+/*
+ * 
+ * Copyright (c) 2020, United States government as represented by the
+ * administrator of the National Aeronautics Space Administration.
+ * All rights reserved. This software was created at NASA Goddard
+ * Space Flight Center pursuant to government contracts.
+ * 
+ * This is governed by the NASA Open Source Agreement and may be used,
+ * distributed and modified only according to the terms of that agreement.
+ * 
+ */
+
+
+/**
+ * \file ut-adaptor-bootrec.c
+ * \ingroup adaptors
+ * \author joseph.p.hickey@nasa.gov
+ *
+ */
+
+#include "ut-adaptor-bootrec.h"
+#include <cfe_psp_config.h>
+#include <cfe_psp_memory.h>
+
+
+static CFE_PSP_ReservedMemoryBootRecord_t UT_BOOTREC;
+
+static const CFE_PSP_ReservedMemoryBootRecord_t UT_DEFAULT_BOOTREC = { 0 };
+
+
+void UT_Setup_ReservedMem_BootRec(void)
+{
+ UT_BOOTREC = UT_DEFAULT_BOOTREC;
+ CFE_PSP_ReservedMemoryMap.BootPtr = &UT_BOOTREC;
+}
+
+uint32 UT_Get_ReservedMem_BootType(void)
+{
+ return UT_BOOTREC.bsp_reset_type;
+}
+
+void UT_Set_ReservedMem_BootType(uint32 reset_type)
+{
+ UT_BOOTREC.bsp_reset_type = reset_type;
+}
+
+

unit-test-coverage/mcp750-vxworks/src/coveragetest-cfe-psp-start.c

@@ -0,0 +1,150 @@
+/*
+ * 
+ * Copyright (c) 2020, United States government as represented by the
+ * administrator of the National Aeronautics Space Administration.
+ * All rights reserved. This software was created at NASA Goddard
+ * Space Flight Center pursuant to government contracts.
+ * 
+ * This is governed by the NASA Open Source Agreement and may be used,
+ * distributed and modified only according to the terms of that agreement.
+ * 
+ */
+
+
+/**
+ * \file coveragetest-binsem.c
+ * \ingroup vxworks
+ * \author joseph.p.hickey@nasa.gov
+ *
+ */
+
+
+#include "coveragetest-psp-mcp750-vxworks.h"
+#include "ut-adaptor-bootrec.h"
+
+#include <cfe_psp.h>
+
+#include <PCS_sysLib.h>
+#include <PCS_mcpx750.h>
+#include <PCS_stdlib.h>
+#include <PCS_cfe_configdata.h>
+
+extern void UT_OS_Application_Startup(void);
+extern void UT_OS_Application_Run(void);
+
+uint32 UT_ReservedMemBuffer[256];
+
+typedef struct
+{
+ uint32 StartType;
+ uint32 StartSubtype;
+} PSP_UT_StartType_t;
+
+/*
+ * A hook function that can check/verify the reset sub type
+ */
+static int32 Test_Hook_ResetSubType(void *UserObj, int32 StubRetcode, uint32 CallCount, const UT_StubContext_t *Context)
+{
+ PSP_UT_StartType_t *UserBuffer = UserObj;
+ UserBuffer->StartType = UT_Hook_GetArgValueByName(Context, "StartType", uint32);
+ UserBuffer->StartSubtype = UT_Hook_GetArgValueByName(Context, "StartSubtype", uint32);
+ return StubRetcode;
+}
+
+void Test_OS_Application_Startup(void)
+{
+ /*
+ * Test Case For:
+ * void OS_Application_Startup(void)
+ *
+ * NOTE: The UT assert library itself defines OS_Application_Startup
+ * To avoid conflict with the UT assert, the unit under test is renamed
+ * to "UT_OS_Application_Startup" using a preprocessor definition
+ */
+ PSP_UT_StartType_t StartType;
+
+ /* Install a hook function to grab the start type parameters from the system main call */
+ UT_SetHookFunction(UT_KEY(PCS_SystemMain), Test_Hook_ResetSubType, &StartType);
+ UT_Setup_ReservedMem_BootRec();
+
+ /* nominal */
+ UT_SetDataBuffer(UT_KEY(PCS_sysMemTop), UT_ReservedMemBuffer, sizeof(UT_ReservedMemBuffer), false);
+ UT_OS_Application_Startup();
+ UtAssert_INT32_EQ(UT_GetStubCount(UT_KEY(OS_printf)), 4);
+ UtAssert_INT32_EQ(UT_GetStubCount(UT_KEY(PCS_SystemMain)), 1);
+ UtAssert_INT32_EQ(StartType.StartType, CFE_PSP_RST_TYPE_POWERON);
+ UtAssert_INT32_EQ(StartType.StartSubtype, CFE_PSP_RST_SUBTYPE_UNDEFINED_RESET);
+
+ /* failure of OS_API_Init */
+ UT_SetForceFail(UT_KEY(OS_API_Init), OS_ERROR);
+ UT_OS_Application_Startup();
+ UtAssert_INT32_EQ(UT_GetStubCount(UT_KEY(PCS_exit)), 1);
+ UT_ClearForceFail(UT_KEY(OS_API_Init));
+
+ /* failure of OS_FileSysAddFixedMap - an extra OS_printf */
+ UT_SetForceFail(UT_KEY(OS_FileSysAddFixedMap), OS_ERROR);
+ UT_OS_Application_Startup();
+ UtAssert_INT32_EQ(UT_GetStubCount(UT_KEY(OS_printf)), 9);
+ UtAssert_INT32_EQ(UT_GetStubCount(UT_KEY(PCS_SystemMain)), 2);
+ UT_ClearForceFail(UT_KEY(OS_FileSysAddFixedMap));
+
+ /* coverage for each of the reset types */
+ *PCS_SYS_REG_BLRR = PCS_SYS_REG_BLRR_PWRON;
+ UT_OS_Application_Startup();
+ UtAssert_INT32_EQ(UT_GetStubCount(UT_KEY(PCS_SystemMain)), 3);
+ UtAssert_INT32_EQ(StartType.StartType, CFE_PSP_RST_TYPE_POWERON);
+ UtAssert_INT32_EQ(StartType.StartSubtype, CFE_PSP_RST_SUBTYPE_POWER_CYCLE);
+
+ *PCS_SYS_REG_BLRR = PCS_SYS_REG_BLRR_PBRST;
+ UT_OS_Application_Startup();
+ UtAssert_INT32_EQ(UT_GetStubCount(UT_KEY(PCS_SystemMain)), 4);
+ UtAssert_INT32_EQ(StartType.StartType, CFE_PSP_RST_TYPE_POWERON);
+ UtAssert_INT32_EQ(StartType.StartSubtype, CFE_PSP_RST_SUBTYPE_PUSH_BUTTON);
+
+ *PCS_SYS_REG_BLRR = PCS_SYS_REG_BLRR_FBTN;
+ UT_OS_Application_Startup();
+ UtAssert_INT32_EQ(UT_GetStubCount(UT_KEY(PCS_SystemMain)), 5);
+ UtAssert_INT32_EQ(StartType.StartType, CFE_PSP_RST_SUBTYPE_PUSH_BUTTON);
+ UtAssert_INT32_EQ(StartType.StartSubtype, 3);
+
+ *PCS_SYS_REG_BLRR = PCS_SYS_REG_BLRR_WDT2;
+ UT_OS_Application_Startup();
+ UtAssert_INT32_EQ(UT_GetStubCount(UT_KEY(PCS_SystemMain)), 6);
+ UtAssert_INT32_EQ(StartType.StartType, CFE_PSP_RST_TYPE_PROCESSOR);
+ UtAssert_INT32_EQ(StartType.StartSubtype, CFE_PSP_RST_SUBTYPE_HW_WATCHDOG);
+
+ *PCS_SYS_REG_BLRR = PCS_SYS_REG_BLRR_SWSRST;
+ UT_OS_Application_Startup();
+ UtAssert_INT32_EQ(UT_GetStubCount(UT_KEY(PCS_SystemMain)), 7);
+ UtAssert_INT32_EQ(StartType.StartType, CFE_PSP_RST_TYPE_PROCESSOR);
+ UtAssert_INT32_EQ(StartType.StartSubtype, CFE_PSP_RST_SUBTYPE_RESET_COMMAND);
+
+ *PCS_SYS_REG_BLRR = PCS_SYS_REG_BLRR_SWHRST;
+ UT_Set_ReservedMem_BootType(CFE_PSP_RST_TYPE_POWERON);
+ UT_OS_Application_Startup();
+ UtAssert_INT32_EQ(UT_GetStubCount(UT_KEY(PCS_SystemMain)), 8);
+ UtAssert_INT32_EQ(StartType.StartType, CFE_PSP_RST_TYPE_POWERON);
+ UtAssert_INT32_EQ(StartType.StartSubtype, CFE_PSP_RST_SUBTYPE_RESET_COMMAND);
+
+ UT_Set_ReservedMem_BootType(CFE_PSP_RST_TYPE_PROCESSOR);
+ UT_OS_Application_Startup();
+ UtAssert_INT32_EQ(UT_GetStubCount(UT_KEY(PCS_SystemMain)), 9);
+ UtAssert_INT32_EQ(StartType.StartType, CFE_PSP_RST_TYPE_PROCESSOR);
+ UtAssert_INT32_EQ(StartType.StartSubtype, CFE_PSP_RST_SUBTYPE_RESET_COMMAND);
+
+}
+
+void Test_OS_Application_Run(void)
+{
+ /*
+ * Test Case For:
+ * void OS_Application_Run(void)
+ *
+ * NOTE: The UT assert library itself defines OS_Application_Run
+ * To avoid conflict with the UT assert, the unit under test is renamed
+ * to "UT_OS_Application_Run" using a preprocessor definition
+ */
+
+ /* The function currently contains an infinite loop so cannot be tested now */
+}
+