From 2a292d041a3644844517cc10344abbf0c4ecccc2 Mon Sep 17 00:00:00 2001 From: Elizabeth Timmons Date: Fri, 19 Nov 2021 11:47:32 -0500 Subject: [PATCH] SUMMARY: update with various fixes for stakeholders This summary commit includes a number of minor updates/fixes from initial users/stakeholders of the CF-3.0.0 release candidate. --- .gitattributes | 6 - .gitignore | 2 + CMakeLists.txt | 1 - README.md | 53 +- cosmos/big_endian/CF/cf_cmd.txt | 223 ++ cosmos/big_endian/CF/cf_tlm.txt | 90 + cosmos/little_endian/CF/cf_cmd.txt | 223 ++ cosmos/little_endian/CF/cf_tlm.txt | 90 + docs/.gitkeep | 0 docs/CF_v3.0.0_VersionDescriptionDocument.pdf | Bin 0 -> 460520 bytes unit-test/cf_app_tests.c | 30 +- unit-test/cf_cfdp_helpers_tests.c | 166 +- unit-test/cf_cfdp_r_tests.c | 501 ++-- unit-test/cf_cfdp_s_tests.c | 451 +-- unit-test/cf_cfdp_tests.c | 2484 +++++++++-------- unit-test/cf_chunk_tests.c | 810 +++--- unit-test/cf_clist_tests.c | 931 +++--- unit-test/cf_cmd_tests.c | 1139 ++++---- unit-test/cf_crc_tests.c | 142 +- unit-test/cf_timer_tests.c | 69 +- unit-test/cf_utils_tests.c | 573 ++-- unit-test/stubs/cf_app_stubs.c | 81 +- unit-test/stubs/cf_assert_stubs.c | 1 - unit-test/stubs/cf_cfdp_helpers_stubs.c | 2 +- unit-test/stubs/cf_cfdp_r_stubs.c | 198 +- unit-test/stubs/cf_cfdp_s_stubs.c | 173 +- unit-test/stubs/cf_cfdp_stubs.c | 290 +- unit-test/stubs/cf_chunk_stubs.c | 84 +- unit-test/stubs/cf_clist_stubs.c | 22 +- unit-test/stubs/cf_cmd_stubs.c | 390 +-- unit-test/stubs/cf_timer_stubs.c | 10 +- unit-test/stubs/cf_utils_stubs.c | 40 +- unit-test/utilities/cf_test_utils.c | 73 +- unit-test/utilities/cf_test_utils.h | 14 +- unit-test/utilities/ut_utils_cfe_hooks.c | 40 +- unit-test/utilities/ut_utils_cfe_hooks.h | 1 - 36 files changed, 4870 insertions(+), 4533 deletions(-) delete mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 cosmos/big_endian/CF/cf_cmd.txt create mode 100644 cosmos/big_endian/CF/cf_tlm.txt create mode 100644 cosmos/little_endian/CF/cf_cmd.txt create mode 100644 cosmos/little_endian/CF/cf_tlm.txt create mode 100644 docs/.gitkeep create mode 100644 docs/CF_v3.0.0_VersionDescriptionDocument.pdf diff --git a/.gitattributes b/.gitattributes deleted file mode 100644 index a950de29..00000000 --- a/.gitattributes +++ /dev/null @@ -1,6 +0,0 @@ -*.h linguist-language=c - -*.css linguist-documentation=true -*.htm linguist-documentation=true -*.html linguist-documentation=true -*.prc linguist-documentation=true diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..783cd5ba --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.swp + diff --git a/CMakeLists.txt b/CMakeLists.txt index 500b9f90..ab45c69a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -21,6 +21,5 @@ add_definitions("-D_DEFAULT_SOURCE") add_definitions(-D_DEFAULT_SOURCE=1) add_definitions(-D_EL -DENDIAN=_EL -DSOFTWARE_BIG_BIT_ORDER) if (ENABLE_UNIT_TESTS) - set(CMAKE_C_FLAGS "-O0") add_subdirectory(unit-test) endif (ENABLE_UNIT_TESTS) diff --git a/README.md b/README.md index 4319d59e..e0706fe7 100644 --- a/README.md +++ b/README.md @@ -1,17 +1,52 @@ -# CCSDS File Delivery Protocol +core Flight System (cFS) CFDP Application (CF) +====================================================== -NASA core Flight System File Transfer Application +Open Source Release Readme +========================== -## Description +CF Release 3.0.0 -The CCSDS File Delivery Protocol (CFDP) application (CF) is a core Flight System (cFS) application that is a plug in to the Core Flight Executive (cFE) component of the cFS. +Date: 09/28/2021 -The cFS is a platform and project independent reusable software framework and set of reusable applications developed by NASA Goddard Space Flight Center. This framework is used as the basis for the flight software for satellite data systems and instruments, but can be used on other embedded systems. More information on the cFS can be found at [http://cfs.gsfc.nasa.gov](http://cfs.gsfc.nasa.gov) +Introduction +------------- + The CFDP application (CF) is a core Flight System (cFS) application + that is a plug in to the Core Flight Executive (cFE) component of the cFS. -The CF application is used for transmitting and receiving files. To transfer files using CFDP, the CF application must communicate with a CFDP compliant peer. + CF 3.0 is a cFS application for providing CFDP (CCSDS File Delivery Protocol) + services. Its primary function is to provide file receive and transmit + functionality to this protocol. It works by mapping CFDP PDUs on and off cFS's + software bus. -CF sends and receives file information and file-data in Protocol Data Units (PDUs) that are compliant with the CFDP standard protocol defined in the CCSDS 727.0-B-4 Blue Book. The PDUs are transferred to and from the CF application via CCSDS packets on the cFE's software bus middleware. + The CF application is written in C and depends on the cFS Operating System + Abstraction Layer (OSAL) and cFE components. There is additional CF application + specific configuration information contained in the application user's guide. + + Developer's guide information can be generated using Doxygen: + doxygen cf_doxygen_config.txt -## License + -This software is licensed under the NASA Open Source Agreement. http://ti.arc.nasa.gov/opensource/nosa +Software Included +------------------ + + CFDP application (CF) 3.0.0 + + +Software Required +------------------ + + cFS Caelum + + Note: An integrated bundle including the cFE, OSAL, and PSP can + be obtained at https://github.com/nasa/cfs + +About cFS +---------- + The cFS is a platform and project independent reusable software framework and + set of reusable applications developed by NASA Goddard Space Flight Center. + This framework is used as the basis for the flight software for satellite data + systems and instruments, but can be used on other embedded systems. More + information on the cFS can be found at http://cfs.gsfc.nasa.gov + +EOF diff --git a/cosmos/big_endian/CF/cf_cmd.txt b/cosmos/big_endian/CF/cf_cmd.txt new file mode 100644 index 00000000..56e898bb --- /dev/null +++ b/cosmos/big_endian/CF/cf_cmd.txt @@ -0,0 +1,223 @@ +COMMAND CF NOOP BIG_ENDIAN "Generate an info event message with app version" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 1 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 0 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + +COMMAND CF RESET_CTRS BIG_ENDIAN "Resets HK TLM parent and child task counters" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 1 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER VALUE 8 UINT 0 4 0 "0=all, 1=cmd, 2=fault 3=up 4=down" + APPEND_PARAMETER SPARE_1 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + + +COMMAND CF TX_FILE BIG_ENDIAN "Send file from Spacecraft to Ground" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 135 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 2 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CLASS 8 UINT 0 1 0 "0=CFDP class 1, 1=CFDP class 2" + APPEND_PARAMETER KEEP 8 UINT 0 1 1 "0=delete file after transfer, 1=keep file" + APPEND_PARAMETER CHAN 8 UINT 0 1 0 "Channel number (0 or 1)" + APPEND_PARAMETER PRIO 8 UINT 0 255 0 "Priority (0 is highest)" + APPEND_PARAMETER DEST_ID 16 UINT MIN_UINT16 MAX_UINT16 26 "CFDP destination entity ID" + APPEND_PARAMETER SRC_FILENAME 512 STRING "/cf/example.bin" "Spacecraft /path/filename" + APPEND_PARAMETER DEST_FILENAME 512 STRING "/home/vagrant/temp.bin" "Complete host /path/filename" + +COMMAND CF PLAYBACK_DIR BIG_ENDIAN "Playback a directory" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 135 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 3 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CLASS 8 UINT 0 1 0 "0=CFDP class 1, 1=CFDP class 2" + APPEND_PARAMETER KEEP 8 UINT 0 1 1 "0=delete file after transfer, 1=keep file" + APPEND_PARAMETER CHAN 8 UINT 0 1 0 "Channel number (0 or 1)" + APPEND_PARAMETER PRIO 8 UINT 0 255 0 "Priority (0 is highest)" + APPEND_PARAMETER DEST_ID 16 UINT MIN_UINT16 MAX_UINT16 26 "CFDP destination entity ID" + APPEND_PARAMETER SRC_FILENAME 512 STRING "/cf/example.bin" "Spacecraft /path/filename of directory" + APPEND_PARAMETER DEST_FILENAME 512 STRING "/home/vagrant/temp.bin" "directory prefix for files on host" + + +COMMAND CF WRITE_QUEUE BIG_ENDIAN "Write a queue to file" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 69 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 15 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER TYPE 8 UINT 0 2 0 "0=all, 1=up, 2=down" + APPEND_PARAMETER CHAN 8 UINT 0 1 0 "Channel number (0 or 1)" + APPEND_PARAMETER QUEUE 8 UINT 0 3 0 "0=pending, 1=active, 2=history, 3=all" + APPEND_PARAMETER SPARE 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SRC_FILENAME 512 STRING "/cf/example.txt" "Spacecraft /path/filename of directory" + + +COMMAND CF FREEZE_CHAN BIG_ENDIAN "Freeze a channel (unable to send messages, and timers stop)" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 4 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER SPARE_1 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + + +COMMAND CF THAW_CHAN BIG_ENDIAN "Thaw a channel" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 5 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER SPARE_1 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + + +COMMAND CF SUSPEND_TRANSACTION BIG_ENDIAN "Suspend a transaction" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 7 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 6 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER TSN 32 UINT 0 0xffffffff 0 "transaction id number" + APPEND_PARAMETER EID 8 UINT 0 0xff 25 "Entity ID of transaction source" + APPEND_PARAMETER CHAN 8 UINT 0 0xff 0xfe "Specify a channel to suspend all. 254 means use TSN. 255 means all transactions" + + +COMMAND CF RESUME_TRANSACTION BIG_ENDIAN "Resume a transaction" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 7 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 7 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER TSN 32 UINT 0 0xffffffff 0 "transaction id number" + APPEND_PARAMETER EID 8 UINT 0 0xff 25 "Entity ID of transaction source" + APPEND_PARAMETER CHAN 8 UINT 0 0xff 0xfe "Specify a channel to resume all. 254 means use TSN. 255 means all transactions" + + +COMMAND CF CANCEL_TRANSACTION BIG_ENDIAN "Cancel a transaction" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 7 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 8 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER TSN 32 UINT 0 0xffffffff 0 "transaction id number" + APPEND_PARAMETER EID 8 UINT 0 0xff 25 "Entity ID of transaction source" + APPEND_PARAMETER CHAN 8 UINT 0 0xff 0xfe "Specify a channel to cancel all. 254 means use TSN. 255 means all transactions" + + +COMMAND CF ABANDON_TRANSACTION BIG_ENDIAN "Abandon a transaction" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 7 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 9 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER TSN 32 UINT 0 0xffffffff 0 "transaction id number" + APPEND_PARAMETER EID 8 UINT 0 0xff 25 "Entity ID of transaction source" + APPEND_PARAMETER CHAN 8 UINT 0 0xff 0xfe "Specify a channel to abandon all. 254 means use TSN. 255 means all transactions" + +COMMAND CF ENABLE_DEQUEUE BIG_ENDIAN "Enable dequeue (tx file) for a channel" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 16 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER SPARE_1 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF DISABLE_DEQUEUE BIG_ENDIAN "Disable dequeue (tx file) for a channel" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 17 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER SPARE_1 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF ENABLE_POLLDIR BIG_ENDIAN "Enable polling directory" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 18 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER POLLDIR 8 UINT MIN_UINT8 MAX_UINT8 0 "polldir (as indexed in the table) 255 means all polldirs" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF DISABLE_POLLDIR BIG_ENDIAN "Disable polling directory" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 19 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER POLLDIR 8 UINT MIN_UINT8 MAX_UINT8 0 "polldir (as indexed in the table) 255 means all polldirs" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF PURGE_QUEUE BIG_ENDIAN "Purge either the PEND or HISTORY queue" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 21 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER QUEUE 8 UINT MIN_UINT8 MAX_UINT8 0 "queue number. 0 is PEND, 1 is HISTORY, 2 is both" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF SEND_CFG_PARAMS BIG_ENDIAN "Send a packet with the current local MIB parameters" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 1 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 14 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + +COMMAND CF SET_MIB_PARAM BIG_ENDIAN "Set a local parameter" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 7 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 10 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER VALUE 32 UINT MIN_UINT32 MAX_UINT32 0 "Value to set parameter to" + APPEND_PARAMETER KEY 8 UINT 0 255 0 "The parameter ID (see item index of CFG_TLM_PKT)" + APPEND_PARAMETER CHAN_INDEX 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF GET_MIB_PARAM BIG_ENDIAN "Get a local parameter" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 3 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 11 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER KEY 8 UINT 0 255 0 "The parameter ID (see item index of CFG_TLM_PKT)" + APPEND_PARAMETER CHAN_INDEX 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF ENABLE_ENGINE BIG_ENDIAN "Enable the CFDP engine to cycle per app wakeup, and reload configuration" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 1 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 22 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + +COMMAND CF DISABLE_ENGINE BIG_ENDIAN "Disable and reset the CFDP engine" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 1 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 23 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + diff --git a/cosmos/big_endian/CF/cf_tlm.txt b/cosmos/big_endian/CF/cf_tlm.txt new file mode 100644 index 00000000..1bb09420 --- /dev/null +++ b/cosmos/big_endian/CF/cf_tlm.txt @@ -0,0 +1,90 @@ +TELEMETRY CF HK_TLM_PKT BIG_ENDIAN "CFDP housekeeping Packet" + APPEND_ID_ITEM CCSDS_STREAMID 16 UINT 0x08B0 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_ITEM CCSDS_SEQUENCE 16 UINT "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_ITEM CCSDS_LENGTH 16 UINT "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_ITEM CCSDS_SECONDS 32 UINT "CCSDS Telemetry Secondary Header (seconds)" + APPEND_ITEM CCSDS_SUBSECS 16 UINT "CCSDS Telemetry Secondary Header (subseconds)" + APPEND_ITEM CMD_VALID_COUNT 16 UINT "Count of valid commands received." + APPEND_ITEM CMD_ERROR_COUNT 16 UINT "Count of invalid commands received." + APPEND_ITEM SENT_FD0 64 UINT "File data bytes sent" + APPEND_ITEM SENT_PDU0 32 UINT "Count of PDUs sent" + APPEND_ITEM SENT_NAK_SR0 32 UINT "Count of sent segment requests" + APPEND_ITEM RECV_FD0 64 UINT "File data bytes received" + APPEND_ITEM RECV_PDU0 32 UINT "Count of PDUs received" + APPEND_ITEM RECV_PDU_ERROR0 32 UINT "Count of invalid PDUs received" + APPEND_ITEM RECV_PDU_SPURIOUS0 16 UINT "Count of spurious PDUs received" + APPEND_ITEM RECV_PDU_DROPPED0 16 UINT "Count of dropped PDUs received" + APPEND_ITEM RECV_NAK_SR0 32 UINT "Count of received segment requests" + APPEND_ITEM FAULT_FILE_OPEN0 16 UINT "Count of file open errors" + APPEND_ITEM FAULT_FILE_READ0 16 UINT "Count of file read errors" + APPEND_ITEM FAULT_FILE_SEEK0 16 UINT "Count of file seek errors" + APPEND_ITEM FAULT_FILE_WRITE0 16 UINT "Count of file write errors" + APPEND_ITEM FAULT_FILE_RENAME0 16 UINT "Count of file rename errors" + APPEND_ITEM FAULT_FILE_DIR_READ0 16 UINT "Count of dir read errors" + APPEND_ITEM FAULT_FILE_CRC_MISMATCH0 16 UINT "Count of file crc mismatch errors" + APPEND_ITEM FAULT_FILE_FILE_SIZE_MISMATCH0 16 UINT "Count of file size mismatch errors" + APPEND_ITEM NAK_LIMIT0 16 UINT "Number of times nak limit reached for transaction" + APPEND_ITEM ACK_LIMIT0 16 UINT "Number of times ack limit reached for transaction" + APPEND_ITEM INACTIVITY_TIMER0 16 UINT "Number of times inactivity timer timed out for transaction" + APPEND_ITEM SPARE0 16 UINT "Number of times inactivity timer timed out for transaction" + APPEND_ITEM QPEND0 16 UINT "Count of transactions on pending queue (ch0)" + APPEND_ITEM QTXA0 16 UINT "Count of active TX transactions (ch0)" + APPEND_ITEM QTXW0 16 UINT "Count of TX transactions waiting for ACK/NAK (ch0)" + APPEND_ITEM QRX0 16 UINT "Number of active RX transactions (ch0)" + APPEND_ITEM QHIST0 16 UINT "Number of active history items (ch0)" + APPEND_ITEM QHISTFREE0 16 UINT "Number of free history items (ch0)" + APPEND_ITEM QFREE0 16 UINT "Count of free transactions available for the channel (ch0)" + APPEND_ITEM POLL_COUNT0 8 UINT "Count of number of active polling directories on channel" + APPEND_ITEM PLAYBACK_DIR_COUNT0 8 UINT "Count of number of active playback directories on channel" + APPEND_ITEM FLAGS0 8 UINT "If 1, the channel is frozen" + APPEND_ITEM SPARE30 16 UINT "" + APPEND_ITEM SPARE40 8 UINT "" + APPEND_ITEM SENT_FD1 64 UINT "File data bytes sent" + APPEND_ITEM SENT_PDU1 32 UINT "Count of PDUs sent" + APPEND_ITEM SENT_NAK_SR1 32 UINT "Count of sent segment requests" + APPEND_ITEM RECV_FD1 64 UINT "File data bytes received" + APPEND_ITEM RECV_PDU1 32 UINT "Count of PDUs received" + APPEND_ITEM RECV_PDU_ERROR1 32 UINT "Count of invalid PDUs received" + APPEND_ITEM RECV_PDU_SPURIOUS1 16 UINT "Count of spurious PDUs received" + APPEND_ITEM RECV_PDU_DROPPED1 16 UINT "Count of dropped PDUs received" + APPEND_ITEM RECV_NAK_SR1 32 UINT "Count of received segment requests" + APPEND_ITEM FAULT_FILE_OPEN1 16 UINT "Count of file open errors" + APPEND_ITEM FAULT_FILE_READ1 16 UINT "Count of file read errors" + APPEND_ITEM FAULT_FILE_SEEK1 16 UINT "Count of file seek errors" + APPEND_ITEM FAULT_FILE_WRITE1 16 UINT "Count of file write errors" + APPEND_ITEM FAULT_FILE_RENAME1 16 UINT "Count of file rename errors" + APPEND_ITEM FAULT_FILE_DIR_READ1 16 UINT "Count of dir read errors" + APPEND_ITEM FAULT_FILE_CRC_MISMATCH1 16 UINT "Count of file crc mismatch errors" + APPEND_ITEM FAULT_FILE_FILE_SIZE_MISMATCH1 16 UINT "Count of file size mismatch errors" + APPEND_ITEM NAK_LIMIT1 16 UINT "Number of times nak limit reached for transaction" + APPEND_ITEM ACK_LIMIT1 16 UINT "Number of times ack limit reached for transaction" + APPEND_ITEM INACTIVITY_TIMER1 16 UINT "Number of times inactivity timer timed out for transaction" + APPEND_ITEM SPARE1 16 UINT "Number of times inactivity timer timed out for transaction" + APPEND_ITEM QPEND1 16 UINT "Count of transactions on pending queue (ch1)" + APPEND_ITEM QTXA1 16 UINT "Count of active TX transactions (ch1)" + APPEND_ITEM QTXW1 16 UINT "Count of TX transactions waiting for ACK/NAK (ch1)" + APPEND_ITEM QRX1 16 UINT "Number of active RX transactions (ch1)" + APPEND_ITEM QHIST1 16 UINT "Number of active history items (ch1)" + APPEND_ITEM QHISTFREE1 16 UINT "Number of free history items (ch1)" + APPEND_ITEM QFREE1 16 UINT "Count of free transactions available for the channel (ch1)" + APPEND_ITEM POLL_COUNT1 8 UINT "Count of number of active polling directories on channel" + APPEND_ITEM PLAYBACK_DIR_COUNT1 8 UINT "Count of number of active playback directories on channel" + APPEND_ITEM FLAGS1 8 UINT "If 1, the channel is frozen" + APPEND_ITEM SPARE31 16 UINT "" + APPEND_ITEM SPARE41 8 UINT "" + +TELEMETRY CF CFG_TLM_PKT BIG_ENDIAN "CF config parameters" + APPEND_ID_ITEM CCSDS_STREAMID 16 UINT 0x08B2 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_ITEM CCSDS_SEQUENCE 16 UINT "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_ITEM CCSDS_LENGTH 16 UINT "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_ITEM CCSDS_SECONDS 32 UINT "CCSDS Telemetry Secondary Header (seconds)" + APPEND_ITEM CCSDS_SUBSECS 16 UINT "CCSDS Telemetry Secondary Header (subseconds)" + APPEND_ITEM TICKS_PER_SECOND 32 UINT "Number of ticks (SCH wakeup messages) per second" + APPEND_ITEM R2_CRC_BYTES_PER_WAKEUP 32 UINT "Number of bytes of CRC to calculate for each R2 transaction per wakeup" + APPEND_ITEM ACK_TIMER_S 32 UINT "Number of seconds for ack timer" + APPEND_ITEM NAK_TIMER_S 32 UINT "Number of seconds for nak timer" + APPEND_ITEM INACTIVITY_TIMER_S 32 UINT "Number of seconds for inactivity timer" + APPEND_ITEM OUTGOING_FILE_CHUNK_SIZE 16 UINT "Max amount of file data per outgoing PDU" + APPEND_ITEM ACK_LIMIT 8 UINT "Number of times to retry ack" + APPEND_ITEM NAK_LIMIT 8 UINT "Number of times to retry nak" + APPEND_ITEM LOCAL_EID 8 UINT "The local entity ID" diff --git a/cosmos/little_endian/CF/cf_cmd.txt b/cosmos/little_endian/CF/cf_cmd.txt new file mode 100644 index 00000000..6f006a58 --- /dev/null +++ b/cosmos/little_endian/CF/cf_cmd.txt @@ -0,0 +1,223 @@ +COMMAND CF NOOP LITTLE_ENDIAN "Generate an info event message with app version" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 1 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 0 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + +COMMAND CF RESET_CTRS LITTLE_ENDIAN "Resets HK TLM parent and child task counters" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 1 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER VALUE 8 UINT 0 4 0 "0=all, 1=cmd, 2=fault 3=up 4=down" + APPEND_PARAMETER SPARE_1 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + + +COMMAND CF TX_FILE LITTLE_ENDIAN "Send file from Spacecraft to Ground" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 135 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 2 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CLASS 8 UINT 0 1 0 "0=CFDP class 1, 1=CFDP class 2" + APPEND_PARAMETER KEEP 8 UINT 0 1 1 "0=delete file after transfer, 1=keep file" + APPEND_PARAMETER CHAN 8 UINT 0 1 0 "Channel number (0 or 1)" + APPEND_PARAMETER PRIO 8 UINT 0 255 0 "Priority (0 is highest)" + APPEND_PARAMETER DEST_ID 16 UINT MIN_UINT16 MAX_UINT16 26 "CFDP destination entity ID" + APPEND_PARAMETER SRC_FILENAME 512 STRING "/cf/example.bin" "Spacecraft /path/filename" + APPEND_PARAMETER DEST_FILENAME 512 STRING "/home/vagrant/temp.bin" "Complete host /path/filename" + +COMMAND CF PLAYBACK_DIR LITTLE_ENDIAN "Playback a directory" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 135 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 3 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CLASS 8 UINT 0 1 0 "0=CFDP class 1, 1=CFDP class 2" + APPEND_PARAMETER KEEP 8 UINT 0 1 1 "0=delete file after transfer, 1=keep file" + APPEND_PARAMETER CHAN 8 UINT 0 1 0 "Channel number (0 or 1)" + APPEND_PARAMETER PRIO 8 UINT 0 255 0 "Priority (0 is highest)" + APPEND_PARAMETER DEST_ID 16 UINT MIN_UINT16 MAX_UINT16 26 "CFDP destination entity ID" + APPEND_PARAMETER SRC_FILENAME 512 STRING "/cf/example.bin" "Spacecraft /path/filename of directory" + APPEND_PARAMETER DEST_FILENAME 512 STRING "/home/vagrant/temp.bin" "directory prefix for files on host" + + +COMMAND CF WRITE_QUEUE LITTLE_ENDIAN "Write a queue to file" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 69 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 15 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER TYPE 8 UINT 0 2 0 "0=all, 1=up, 2=down" + APPEND_PARAMETER CHAN 8 UINT 0 1 0 "Channel number (0 or 1)" + APPEND_PARAMETER QUEUE 8 UINT 0 3 0 "0=pending, 1=active, 2=history, 3=all" + APPEND_PARAMETER SPARE 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SRC_FILENAME 512 STRING "/cf/example.txt" "Spacecraft /path/filename of directory" + + +COMMAND CF FREEZE_CHAN LITTLE_ENDIAN "Freeze a channel (unable to send messages, and timers stop)" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 4 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER SPARE_1 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + + +COMMAND CF THAW_CHAN LITTLE_ENDIAN "Thaw a channel" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 5 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER SPARE_1 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + + +COMMAND CF SUSPEND_TRANSACTION LITTLE_ENDIAN "Suspend a transaction" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 7 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 6 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER TSN 32 UINT 0 0xffffffff 0 "transaction id number" + APPEND_PARAMETER EID 8 UINT 0 0xff 25 "Entity ID of transaction source" + APPEND_PARAMETER CHAN 8 UINT 0 0xff 0xfe "Specify a channel to suspend all. 254 means use TSN. 255 means all transactions" + + +COMMAND CF RESUME_TRANSACTION LITTLE_ENDIAN "Resume a transaction" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 7 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 7 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER TSN 32 UINT 0 0xffffffff 0 "transaction id number" + APPEND_PARAMETER EID 8 UINT 0 0xff 25 "Entity ID of transaction source" + APPEND_PARAMETER CHAN 8 UINT 0 0xff 0xfe "Specify a channel to resume all. 254 means use TSN. 255 means all transactions" + + +COMMAND CF CANCEL_TRANSACTION LITTLE_ENDIAN "Cancel a transaction" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 7 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 8 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER TSN 32 UINT 0 0xffffffff 0 "transaction id number" + APPEND_PARAMETER EID 8 UINT 0 0xff 25 "Entity ID of transaction source" + APPEND_PARAMETER CHAN 8 UINT 0 0xff 0xfe "Specify a channel to cancel all. 254 means use TSN. 255 means all transactions" + + +COMMAND CF ABANDON_TRANSACTION LITTLE_ENDIAN "Abandon a transaction" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 7 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 9 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER TSN 32 UINT 0 0xffffffff 0 "transaction id number" + APPEND_PARAMETER EID 8 UINT 0 0xff 25 "Entity ID of transaction source" + APPEND_PARAMETER CHAN 8 UINT 0 0xff 0xfe "Specify a channel to abandon all. 254 means use TSN. 255 means all transactions" + +COMMAND CF ENABLE_DEQUEUE LITTLE_ENDIAN "Enable dequeue (tx file) for a channel" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 16 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER SPARE_1 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF DISABLE_DEQUEUE LITTLE_ENDIAN "Disable dequeue (tx file) for a channel" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 17 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER SPARE_1 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF ENABLE_POLLDIR LITTLE_ENDIAN "Enable polling directory" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 18 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER POLLDIR 8 UINT MIN_UINT8 MAX_UINT8 0 "polldir (as indexed in the table) 255 means all polldirs" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF DISABLE_POLLDIR LITTLE_ENDIAN "Disable polling directory" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 19 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER POLLDIR 8 UINT MIN_UINT8 MAX_UINT8 0 "polldir (as indexed in the table) 255 means all polldirs" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF PURGE_QUEUE LITTLE_ENDIAN "Purge either the PEND or HISTORY queue" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 5 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 21 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER CHANNEL 8 UINT 0 255 0 "channel number (0, 1, ...) 255 means all channels" + APPEND_PARAMETER QUEUE 8 UINT MIN_UINT8 MAX_UINT8 0 "queue number. 0 is PEND, 1 is HISTORY, 2 is both" + APPEND_PARAMETER SPARE_2 8 UINT MIN_UINT8 MAX_UINT8 0 "" + APPEND_PARAMETER SPARE_3 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF SEND_CFG_PARAMS LITTLE_ENDIAN "Send a packet with the current local MIB parameters" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 1 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 14 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + +COMMAND CF SET_MIB_PARAM LITTLE_ENDIAN "Set a local parameter" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 7 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 10 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER VALUE 32 UINT MIN_UINT32 MAX_UINT32 0 "Value to set parameter to" + APPEND_PARAMETER KEY 8 UINT 0 255 0 "The parameter ID (see item index of CFG_TLM_PKT)" + APPEND_PARAMETER CHAN_INDEX 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF GET_MIB_PARAM LITTLE_ENDIAN "Get a local parameter" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 3 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 11 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + APPEND_PARAMETER KEY 8 UINT 0 255 0 "The parameter ID (see item index of CFG_TLM_PKT)" + APPEND_PARAMETER CHAN_INDEX 8 UINT MIN_UINT8 MAX_UINT8 0 "" + +COMMAND CF ENABLE_ENGINE LITTLE_ENDIAN "Enable the CFDP engine to cycle per app wakeup, and reload configuration" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 1 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 22 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + +COMMAND CF DISABLE_ENGINE LITTLE_ENDIAN "Disable and reset the CFDP engine" + APPEND_ID_PARAMETER CCSDS_STREAMID 16 UINT MIN_UINT16 MAX_UINT16 0x18B3 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_PARAMETER CCSDS_SEQUENCE 16 UINT MIN_UINT16 MAX_UINT16 0xC000 "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_PARAMETER CCSDS_LENGTH 16 UINT MIN_UINT16 MAX_UINT16 1 "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_PARAMETER CCSDS_FC 8 UINT MIN_UINT8 MAX_UINT8 23 "CCSDS Command Function Code" + APPEND_PARAMETER CCSDS_CHECKSUM 8 UINT MIN_UINT8 MIN_UINT8 0 "Checksum" + diff --git a/cosmos/little_endian/CF/cf_tlm.txt b/cosmos/little_endian/CF/cf_tlm.txt new file mode 100644 index 00000000..4b3a3e52 --- /dev/null +++ b/cosmos/little_endian/CF/cf_tlm.txt @@ -0,0 +1,90 @@ +TELEMETRY CF HK_TLM_PKT LITTLE_ENDIAN "CFDP housekeeping Packet" + APPEND_ID_ITEM CCSDS_STREAMID 16 UINT 0x08B0 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_ITEM CCSDS_SEQUENCE 16 UINT "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_ITEM CCSDS_LENGTH 16 UINT "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_ITEM CCSDS_SECONDS 32 UINT "CCSDS Telemetry Secondary Header (seconds)" + APPEND_ITEM CCSDS_SUBSECS 16 UINT "CCSDS Telemetry Secondary Header (subseconds)" + APPEND_ITEM CMD_VALID_COUNT 16 UINT "Count of valid commands received." + APPEND_ITEM CMD_ERROR_COUNT 16 UINT "Count of invalid commands received." + APPEND_ITEM SENT_FD0 64 UINT "File data bytes sent" + APPEND_ITEM SENT_PDU0 32 UINT "Count of PDUs sent" + APPEND_ITEM SENT_NAK_SR0 32 UINT "Count of sent segment requests" + APPEND_ITEM RECV_FD0 64 UINT "File data bytes received" + APPEND_ITEM RECV_PDU0 32 UINT "Count of PDUs received" + APPEND_ITEM RECV_PDU_ERROR0 32 UINT "Count of invalid PDUs received" + APPEND_ITEM RECV_PDU_SPURIOUS0 16 UINT "Count of spurious PDUs received" + APPEND_ITEM RECV_PDU_DROPPED0 16 UINT "Count of dropped PDUs received" + APPEND_ITEM RECV_NAK_SR0 32 UINT "Count of received segment requests" + APPEND_ITEM FAULT_FILE_OPEN0 16 UINT "Count of file open errors" + APPEND_ITEM FAULT_FILE_READ0 16 UINT "Count of file read errors" + APPEND_ITEM FAULT_FILE_SEEK0 16 UINT "Count of file seek errors" + APPEND_ITEM FAULT_FILE_WRITE0 16 UINT "Count of file write errors" + APPEND_ITEM FAULT_FILE_RENAME0 16 UINT "Count of file rename errors" + APPEND_ITEM FAULT_FILE_DIR_READ0 16 UINT "Count of dir read errors" + APPEND_ITEM FAULT_FILE_CRC_MISMATCH0 16 UINT "Count of file crc mismatch errors" + APPEND_ITEM FAULT_FILE_FILE_SIZE_MISMATCH0 16 UINT "Count of file size mismatch errors" + APPEND_ITEM NAK_LIMIT0 16 UINT "Number of times nak limit reached for transaction" + APPEND_ITEM ACK_LIMIT0 16 UINT "Number of times ack limit reached for transaction" + APPEND_ITEM INACTIVITY_TIMER0 16 UINT "Number of times inactivity timer timed out for transaction" + APPEND_ITEM SPARE0 16 UINT "Number of times inactivity timer timed out for transaction" + APPEND_ITEM QPEND0 16 UINT "Count of transactions on pending queue (ch0)" + APPEND_ITEM QTXA0 16 UINT "Count of active TX transactions (ch0)" + APPEND_ITEM QTXW0 16 UINT "Count of TX transactions waiting for ACK/NAK (ch0)" + APPEND_ITEM QRX0 16 UINT "Number of active RX transactions (ch0)" + APPEND_ITEM QHIST0 16 UINT "Number of active history items (ch0)" + APPEND_ITEM QHISTFREE0 16 UINT "Number of free history items (ch0)" + APPEND_ITEM QFREE0 16 UINT "Count of free transactions available for the channel (ch0)" + APPEND_ITEM POLL_COUNT0 8 UINT "Count of number of active polling directories on channel" + APPEND_ITEM PLAYBACK_DIR_COUNT0 8 UINT "Count of number of active playback directories on channel" + APPEND_ITEM FLAGS0 8 UINT "If 1, the channel is frozen" + APPEND_ITEM SPARE30 16 UINT "" + APPEND_ITEM SPARE40 8 UINT "" + APPEND_ITEM SENT_FD1 64 UINT "File data bytes sent" + APPEND_ITEM SENT_PDU1 32 UINT "Count of PDUs sent" + APPEND_ITEM SENT_NAK_SR1 32 UINT "Count of sent segment requests" + APPEND_ITEM RECV_FD1 64 UINT "File data bytes received" + APPEND_ITEM RECV_PDU1 32 UINT "Count of PDUs received" + APPEND_ITEM RECV_PDU_ERROR1 32 UINT "Count of invalid PDUs received" + APPEND_ITEM RECV_PDU_SPURIOUS1 16 UINT "Count of spurious PDUs received" + APPEND_ITEM RECV_PDU_DROPPED1 16 UINT "Count of dropped PDUs received" + APPEND_ITEM RECV_NAK_SR1 32 UINT "Count of received segment requests" + APPEND_ITEM FAULT_FILE_OPEN1 16 UINT "Count of file open errors" + APPEND_ITEM FAULT_FILE_READ1 16 UINT "Count of file read errors" + APPEND_ITEM FAULT_FILE_SEEK1 16 UINT "Count of file seek errors" + APPEND_ITEM FAULT_FILE_WRITE1 16 UINT "Count of file write errors" + APPEND_ITEM FAULT_FILE_RENAME1 16 UINT "Count of file rename errors" + APPEND_ITEM FAULT_FILE_DIR_READ1 16 UINT "Count of dir read errors" + APPEND_ITEM FAULT_FILE_CRC_MISMATCH1 16 UINT "Count of file crc mismatch errors" + APPEND_ITEM FAULT_FILE_FILE_SIZE_MISMATCH1 16 UINT "Count of file size mismatch errors" + APPEND_ITEM NAK_LIMIT1 16 UINT "Number of times nak limit reached for transaction" + APPEND_ITEM ACK_LIMIT1 16 UINT "Number of times ack limit reached for transaction" + APPEND_ITEM INACTIVITY_TIMER1 16 UINT "Number of times inactivity timer timed out for transaction" + APPEND_ITEM SPARE1 16 UINT "Number of times inactivity timer timed out for transaction" + APPEND_ITEM QPEND1 16 UINT "Count of transactions on pending queue (ch1)" + APPEND_ITEM QTXA1 16 UINT "Count of active TX transactions (ch1)" + APPEND_ITEM QTXW1 16 UINT "Count of TX transactions waiting for ACK/NAK (ch1)" + APPEND_ITEM QRX1 16 UINT "Number of active RX transactions (ch1)" + APPEND_ITEM QHIST1 16 UINT "Number of active history items (ch1)" + APPEND_ITEM QHISTFREE1 16 UINT "Number of free history items (ch1)" + APPEND_ITEM QFREE1 16 UINT "Count of free transactions available for the channel (ch1)" + APPEND_ITEM POLL_COUNT1 8 UINT "Count of number of active polling directories on channel" + APPEND_ITEM PLAYBACK_DIR_COUNT1 8 UINT "Count of number of active playback directories on channel" + APPEND_ITEM FLAGS1 8 UINT "If 1, the channel is frozen" + APPEND_ITEM SPARE31 16 UINT "" + APPEND_ITEM SPARE41 8 UINT "" + +TELEMETRY CF CFG_TLM_PKT LITTLE_ENDIAN "CF config parameters" + APPEND_ID_ITEM CCSDS_STREAMID 16 UINT 0x08B2 "CCSDS Packet Identification" BIG_ENDIAN + APPEND_ITEM CCSDS_SEQUENCE 16 UINT "CCSDS Packet Sequence Control" BIG_ENDIAN + APPEND_ITEM CCSDS_LENGTH 16 UINT "CCSDS Packet Data Length" BIG_ENDIAN + APPEND_ITEM CCSDS_SECONDS 32 UINT "CCSDS Telemetry Secondary Header (seconds)" + APPEND_ITEM CCSDS_SUBSECS 16 UINT "CCSDS Telemetry Secondary Header (subseconds)" + APPEND_ITEM TICKS_PER_SECOND 32 UINT "Number of ticks (SCH wakeup messages) per second" + APPEND_ITEM R2_CRC_BYTES_PER_WAKEUP 32 UINT "Number of bytes of CRC to calculate for each R2 transaction per wakeup" + APPEND_ITEM ACK_TIMER_S 32 UINT "Number of seconds for ack timer" + APPEND_ITEM NAK_TIMER_S 32 UINT "Number of seconds for nak timer" + APPEND_ITEM INACTIVITY_TIMER_S 32 UINT "Number of seconds for inactivity timer" + APPEND_ITEM OUTGOING_FILE_CHUNK_SIZE 16 UINT "Max amount of file data per outgoing PDU" + APPEND_ITEM ACK_LIMIT 8 UINT "Number of times to retry ack" + APPEND_ITEM NAK_LIMIT 8 UINT "Number of times to retry nak" + APPEND_ITEM LOCAL_EID 8 UINT "The local entity ID" diff --git a/docs/.gitkeep b/docs/.gitkeep new file mode 100644 index 00000000..e69de29b diff --git a/docs/CF_v3.0.0_VersionDescriptionDocument.pdf b/docs/CF_v3.0.0_VersionDescriptionDocument.pdf new file mode 100644 index 0000000000000000000000000000000000000000..83dbc023f6493e4d842e644ef65669052ee0414d GIT binary patch literal 460520 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

    r>(PLyP~H=T^aAj?~!cd#=Djsl$R&6 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", - context_CFE_MSG_GetMsgId.MsgPtr, arg_msg); + UtAssert_ADDRESS_EQ(context_CFE_MSG_GetMsgId.MsgPtr, (CFE_MSG_Message_t*)arg_msg); UtAssert_STUB_COUNT(CF_ProcessGroundCommand, 1); - UtAssert_True(context_CF_ProcessGroundCommand_msg == arg_msg, - "ProcessGroundCommand received msg %p and should be %p", - context_CF_ProcessGroundCommand_msg, arg_msg); + UtAssert_ADDRESS_EQ(context_CF_ProcessGroundCommand_msg, arg_msg); } /* end Test_CF_ProcessMsg_ProcessGroundCommand */ void Test_CF_ProcessMsg_WakeUp(void) @@ -661,9 +652,7 @@ void Test_CF_ProcessMsg_WakeUp(void) /* Assert */ UtAssert_STUB_COUNT(CFE_MSG_GetMsgId, 1); - UtAssert_True(context_CFE_MSG_GetMsgId.MsgPtr == &arg_msg->Msg, - "CFE_MSG_GetMsgId received MsgPtr %p and should be %p (&msg->Msg)", - context_CFE_MSG_GetMsgId.MsgPtr, &arg_msg->Msg); + UtAssert_ADDRESS_EQ(context_CFE_MSG_GetMsgId.MsgPtr, &arg_msg->Msg); /* Assert Unstubbable - CF_WakeUp */ UtAssert_STUB_COUNT(CF_CFDP_CycleEngine, 1); } /* end Test_CF_ProcessMsg_WakeUp */ @@ -694,9 +683,7 @@ void Test_CF_ProcessMsg_SendHk(void) /* Assert */ UtAssert_STUB_COUNT(CFE_MSG_GetMsgId, 1); /* Assert for CF_HkCmd*/ - UtAssert_True(context_CFE_SB_TransmitMsg.MsgPtr == &CF_AppData.hk.tlm_header.Msg, - "CFE_SB_TransmitMsg received %p and should be %p (&CF_AppData.hk.tlm_header.Msg)", - context_CFE_SB_TransmitMsg.MsgPtr, &CF_AppData.hk.tlm_header.Msg); + UtAssert_ADDRESS_EQ(context_CFE_SB_TransmitMsg.MsgPtr, &CF_AppData.hk.tlm_header.Msg); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } /* end Test_CF_ProcessMsg_SendHk */ @@ -753,7 +740,7 @@ void Test_CF_AppMain_CallTo_CF_Init_DoNotReturn_CFE_SUCCESS_Set_CF_AppData_run_s /* Arrange unstubbable: CF_Init */ CFE_Status_t forced_return_CFE_EVS_Register = Any_CFE_Status_t_Except(CFE_SUCCESS); - UT_SetDefaultReturnValue(CFE_EVS_Register, forced_return_CFE_EVS_Register); + UT_SetDefaultReturnValue(UT_KEY(CFE_EVS_Register), forced_return_CFE_EVS_Register); /* Act */ CF_AppMain(); @@ -784,7 +771,6 @@ void Test_CF_AppMain_CallTo_CFE_ES_RunLoop_Returns_false_AppExit(void) void Test_CF_AppMain_RunLoopCallTo_CFE_SB_ReceiveBuffer_ReturnsNot_CFE_SUCCESS_AndNot_CFE_SB_TIME_OUT_SendEvent(void) { /* Arrange */ - int32 exceptions[2] = {CFE_SUCCESS, CFE_SB_TIME_OUT}; int32 forced_return_CFE_SB_ReceiveBuffer = Any_int32_Negative(); /* TODO: has to be negative unless a handler is used */ CFE_SB_Buffer_t* dummy_msg = NULL; @@ -871,7 +857,7 @@ void Test_CF_AppMain_RunLoopCallTo_CFE_SB_ReceiveBuffer_Returns_CFE_SUCCESS_AndV UT_SetDefaultReturnValue(UT_KEY(CFE_SB_ReceiveBuffer), forced_return_CFE_SB_ReceiveBuffer); /* Arrange unstubbable: CF_ProcessMsg */ - UT_SetDefaultReturnValue(CFE_MSG_GetMsgId, UINT32_MAX); /* UINT32_MAX selected because it should error out */ + UT_SetDefaultReturnValue(UT_KEY(CFE_MSG_GetMsgId), UINT32_MAX); /* UINT32_MAX selected because it should error out */ CF_AppData.hk.counters.err = initial_hk_counters_err; /* Act */ diff --git a/unit-test/cf_cfdp_helpers_tests.c b/unit-test/cf_cfdp_helpers_tests.c index 82aa6243..5ffdb4d2 100644 --- a/unit-test/cf_cfdp_helpers_tests.c +++ b/unit-test/cf_cfdp_helpers_tests.c @@ -72,6 +72,8 @@ void *CSLO_memset(void *__s, int __c, size_t __n) UT_Stub_CopyFromLocal(UT_KEY(CSLO_memset), &__n, sizeof(__n)); UT_DEFAULT_IMPL(CSLO_memset); + + return __s; } /* end cf standard lib overrides */ @@ -86,7 +88,7 @@ void cf_cfdp_helpers_tests_Setup(void) { cf_tests_Setup(); - memset_context.__s = ut_default_ptr; + memset_context.__s = NULL; memset_context.__c = UT_INT_32_DEFAULT; memset_context.__n = UT_INT_32_DEFAULT; @@ -229,16 +231,16 @@ void Test_CF_GetMemcpySize_WhenGiven_num_ElementsAre_0_FromGiven_size_UntilAnoth void Test_CF_MemcpyToBE_Asserts_src_size_EqTo_0(void) { - /* Arrange */ - uint8 * arg_dst; - uint8 * arg_src; - int arg_src_size = 0; - int arg_dst_size = Any_int_Positive(); + // /* Arrange */ + // uint8 * arg_dst; + // uint8 * arg_src; + // int arg_src_size = 0; + // int arg_dst_size = Any_int_Positive(); - /* Act */ - //CF_MemcpyToBE(arg_dst, arg_src, arg_src_size, arg_dst_size); + // /* Act */ + // CF_MemcpyToBE(arg_dst, arg_src, arg_src_size, arg_dst_size); - /* Assert */ + // /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - (src_size>0)&&(dst_size>0)"); } /* end Test_CF_MemcpyToBE_Asserts_src_size_EqTo_0 */ @@ -260,16 +262,16 @@ void Test_CF_MemcpyToBE_Asserts_src_size_EqTo_0(void) void Test_CF_MemcpyToBE_Asserts_dst_size_EqTo_0(void) { - /* Arrange */ - uint8 * arg_dst; - uint8 * arg_src; - int arg_src_size = Any_int_Positive(); - int arg_dst_size = 0; + // /* Arrange */ + // uint8 * arg_dst; + // uint8 * arg_src; + // int arg_src_size = Any_int_Positive(); + // int arg_dst_size = 0; - /* Act */ - //CF_MemcpyToBE(arg_dst, arg_src, arg_src_size, arg_dst_size); + // /* Act */ + // CF_MemcpyToBE(arg_dst, arg_src, arg_src_size, arg_dst_size); - /* Assert */ + // /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - (src_size>0)&&(dst_size>0)"); } /* end Test_CF_MemcpyToBE_Asserts_dst_size_EqTo_0 */ @@ -291,16 +293,16 @@ void Test_CF_MemcpyToBE_Asserts_dst_size_EqTo_0(void) void Test_CF_MemcpyToBE_Asserts_both_src_size_And_dst_size_Are_0(void) { - /* Arrange */ - uint8 * arg_dst; - uint8 * arg_src; - int arg_src_size = 0; - int arg_dst_size = 0; + // /* Arrange */ + // uint8 * arg_dst; + // uint8 * arg_src; + // int arg_src_size = 0; + // int arg_dst_size = 0; - /* Act */ - //CF_MemcpyToBE(arg_dst, arg_src, arg_src_size, arg_dst_size); + // /* Act */ + // CF_MemcpyToBE(arg_dst, arg_src, arg_src_size, arg_dst_size); - /* Assert */ + // /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - src_size>=dst_size"); } /* end Test_CF_MemcpyToBE_Asserts_both_src_size_And_dst_size_Are_0 */ @@ -447,16 +449,16 @@ void Test_CF_MemcpyToBE_CopyAllRequisite_src_ValuesInto_dst_When_dst_size_IsEqTo void Test_CF_MemcpyFromBE_Asserts_src_size_EqTo_0(void) { - /* Arrange */ - uint8 * arg_dst; - uint8 * arg_src; - int arg_src_size = 0; - int arg_dst_size = Any_int_Positive(); + // /* Arrange */ + // uint8 * arg_dst; + // uint8 * arg_src; + // int arg_src_size = 0; + // int arg_dst_size = Any_int_Positive(); - /* Act */ - //CF_MemcpyFromBE(arg_dst, arg_src, arg_src_size, arg_dst_size); + // /* Act */ + // CF_MemcpyFromBE(arg_dst, arg_src, arg_src_size, arg_dst_size); - /* Assert */ + // /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - (src_size>0)&&(dst_size>0)"); } /* end Test_CF_MemcpyFromBE_Asserts_src_size_EqTo_0 */ @@ -479,15 +481,15 @@ void Test_CF_MemcpyFromBE_Asserts_src_size_EqTo_0(void) void Test_CF_MemcpyFromBE_Asserts_dst_size_EqTo_0(void) { /* Arrange */ - uint8 * arg_dst; - uint8 * arg_src; - int arg_src_size = Any_int_Positive(); - int arg_dst_size = 0; + // uint8 * arg_dst; + // uint8 * arg_src; + // int arg_src_size = Any_int_Positive(); + // int arg_dst_size = 0; - /* Act */ - //CF_MemcpyFromBE(arg_dst, arg_src, arg_src_size, arg_dst_size); + // /* Act */ + // CF_MemcpyFromBE(arg_dst, arg_src, arg_src_size, arg_dst_size); - /* Assert */ + // /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - (src_size>0)&&(dst_size>0)"); } /* end Test_CF_MemcpyFromBE_Asserts_dst_size_EqTo_0 */ @@ -509,16 +511,16 @@ void Test_CF_MemcpyFromBE_Asserts_dst_size_EqTo_0(void) void Test_CF_MemcpyToBE_Asserts_dst_size_IsLessThan_src_size(void) { - /* Arrange */ - uint8 * arg_dst; - uint8 * arg_src; - int arg_dst_size = Any_int_ZeroOrPositiveLessThan(INT32_MAX - 2) + 1; /* -2 then +1 for 1 to INT32_MAX - 1 */ - int arg_src_size = arg_dst_size + 1; /* TODO change to any int greater than? DNE at time of writing */ + // /* Arrange */ + // uint8 * arg_dst; + // uint8 * arg_src; + // int arg_dst_size = Any_int_ZeroOrPositiveLessThan(INT32_MAX - 2) + 1; /* -2 then +1 for 1 to INT32_MAX - 1 */ + // int arg_src_size = arg_dst_size + 1; /* TODO change to any int greater than? DNE at time of writing */ - /* Act */ - //CF_MemcpyFromBE(arg_dst, arg_src, arg_src_size, arg_dst_size); + // /* Act */ + // CF_MemcpyFromBE(arg_dst, arg_src, arg_src_size, arg_dst_size); - /* Assert */ + // /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - dst_size>=src_size"); } /* end Test_CF_MemcpyToBE_Asserts_dst_size_IsLessThan_src_size */ @@ -678,7 +680,7 @@ void Test_CF_GetTSNSize_When_ret_Is_1_LessThan_size_of_cf_transaction_seq_t_Add_ /* Assert */ UtAssert_True(local_result == expected_result, - "CF_GetTSNSize returned %d and should be %d (sizeof(cf_transaction_seq_t))", + "CF_GetTSNSize returned %d and should be %ld (sizeof(cf_transaction_seq_t))", local_result, sizeof(cf_transaction_seq_t)); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } /* end Test_CF_GetTSNSize_When_ret_Is_1_LessThan_size_of_cf_transaction_seq_t_Add_1_MakingItEqToThatSizeReturnThatValue */ @@ -698,7 +700,7 @@ void Test_CF_GetTSNSize_When_ret_Is_LessThan_size_of_cf_transaction_seq_t_Add_1_ local_result = CF_GetTSNSize(arg_ph); /* Assert */ - UtAssert_True(local_result == forced_return_FGV + 1, + UtAssert_True(local_result == expected_result, "CF_GetTSNSize returned %d and should be 1 more than %d (FGV)", local_result, forced_return_FGV); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); @@ -748,7 +750,7 @@ void Test_CF_GetEIDSize_When_ret_Is_1_LessThan_size_of_cf_entity_id_t_Add_1_Maki /* Assert */ UtAssert_True(local_result == expected_result, - "CF_GetEIDSize returned %d and should be %d (sizeof(cf_entity_id_t))", + "CF_GetEIDSize returned %d and should be %ld (sizeof(cf_entity_id_t))", local_result, sizeof(cf_entity_id_t)); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); } /* end Test_CF_GetEIDSize_When_ret_Is_1_LessThan_size_of_cf_entity_id_t_Add_1_MakingItEqToThatSizeReturnThatValue */ @@ -768,7 +770,7 @@ void Test_CF_GetEIDSize_When_ret_Is_LessThan_size_of_cf_entity_id_t_Add_1_AndRet local_result = CF_GetEIDSize(arg_ph); /* Assert */ - UtAssert_True(local_result == forced_return_FGV + 1, + UtAssert_True(local_result == expected_result, "CF_GetEIDSize returned %d and should be 1 more than %d (FGV)", local_result, forced_return_FGV); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); @@ -788,7 +790,7 @@ void Test_CF_GetVariableHeader_When_eid_l_AND_tsn_l_AreNotGreaterThan_0_DoesNotC pdu_r_msg_t dummy_ph; int local_result; - CF_AppData.engine.in.msg = &dummy_ph; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_ph; /* Arrange for CF_GetEIDSize */ uint32 forced_return_FGV_from_EID = sizeof(cf_entity_id_t); /* unstubbable code adds +1 to this value */ @@ -817,7 +819,7 @@ void Test_CF_GetVariableHeader_WhenOnly_eid_l_IsGreaterThan_0_DoesNotCallAnyMemC pdu_r_msg_t dummy_ph; int local_result; - CF_AppData.engine.in.msg = &dummy_ph; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_ph; /* Arrange for CF_GetEIDSize */ uint32 forced_return_FGV_from_EID = sizeof(cf_entity_id_t) - 1; /* unstubbable code adds +1 to this value */ @@ -846,7 +848,7 @@ void Test_CF_GetVariableHeader_WhenOnly_tsn_l_IsGreaterThan_0_DoesNotCallAnyMemC pdu_r_msg_t dummy_ph; int local_result; - CF_AppData.engine.in.msg = &dummy_ph; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_ph; /* Arrange for CF_GetEIDSize */ uint32 forced_return_FGV_from_EID = sizeof(cf_entity_id_t); /* unstubbable code adds +1 to this value */ @@ -875,7 +877,7 @@ void Test_CF_GetVariableHeader_GetsAllThreeVariableLengthItemsOutOfHeaderAndRetu pdu_r_msg_t dummy_ph; int local_result; - CF_AppData.engine.in.msg = &dummy_ph; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_ph; /* Arrange for CF_GetEIDSize */ uint32 forced_return_FGV_from_EID = Any_uint32_LessThan(sizeof(cf_entity_id_t)); /* unstubbable code adds +1 to this value */ @@ -909,12 +911,12 @@ void Test_CF_GetVariableHeader_GetsAllThreeVariableLengthItemsOutOfHeaderAndRetu void Test_CF_SetVariableHeader_Call_FSV_Twice(void) { /* Arrange */ - cf_entity_id_t arg_src_eid; - cf_entity_id_t arg_dst_eid; - cf_transaction_seq_t arg_tsn; + cf_entity_id_t arg_src_eid = 1; + cf_entity_id_t arg_dst_eid = 1; + cf_transaction_seq_t arg_tsn = 1; pdu_s_msg_t dummy_msg; - CF_AppData.engine.out.msg = &dummy_msg; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_msg; /* Act */ CF_SetVariableHeader(arg_src_eid, arg_dst_eid, arg_tsn); @@ -933,18 +935,18 @@ void Test_CF_SetVariableHeader_Call_FSV_Twice(void) void Test_CF_HeaderSize_AssertsWhen_eid_l_IsNotGreaterThan_0(void) { - /* Arrange */ - pdu_header_t dummy_ph; - pdu_header_t* arg_ph = &dummy_ph; - int32 forced_return_FGV_for_eid_l = Any_int32_Negative(); /* negative forces error */ - int32 forced_return_FGV_for_tsn_l = Any_uint8(); /* uint8 used arbitrarily for small size */ - int local_result; + // /* Arrange */ + // pdu_header_t dummy_ph; + // pdu_header_t* arg_ph = &dummy_ph; + // int32 forced_return_FGV_for_eid_l = Any_int32_Negative(); /* negative forces error */ + // int32 forced_return_FGV_for_tsn_l = Any_uint8(); /* uint8 used arbitrarily for small size */ + // int local_result; - UT_SetDeferredRetcode(UT_KEY(FGV), 1, forced_return_FGV_for_eid_l); - UT_SetDeferredRetcode(UT_KEY(FGV), 1, forced_return_FGV_for_tsn_l); + // UT_SetDeferredRetcode(UT_KEY(FGV), 1, forced_return_FGV_for_eid_l); + // UT_SetDeferredRetcode(UT_KEY(FGV), 1, forced_return_FGV_for_tsn_l); - /* Act */ - //local_result = CF_HeaderSize(arg_ph); + // /* Act */ + // local_result = CF_HeaderSize(arg_ph); /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - (eid_l>0)&&(tsn_l>0)"); @@ -952,18 +954,18 @@ void Test_CF_HeaderSize_AssertsWhen_eid_l_IsNotGreaterThan_0(void) void Test_CF_HeaderSize_AssertsWhen_tsn_l_IsNotGreaterThan_0(void) { - /* Arrange */ - pdu_header_t dummy_ph; - pdu_header_t* arg_ph = &dummy_ph; - int32 forced_return_FGV_for_eid_l = Any_uint8(); /* uint8 used arbitrarily for small size */ - int32 forced_return_FGV_for_tsn_l = Any_int32_Negative(); /* negative forces error */ - int local_result; + // /* Arrange */ + // pdu_header_t dummy_ph; + // pdu_header_t* arg_ph = &dummy_ph; + // int32 forced_return_FGV_for_eid_l = Any_uint8(); /* uint8 used arbitrarily for small size */ + // int32 forced_return_FGV_for_tsn_l = Any_int32_Negative(); /* negative forces error */ + // int local_result; - UT_SetDeferredRetcode(UT_KEY(FGV), 1, forced_return_FGV_for_eid_l); - UT_SetDeferredRetcode(UT_KEY(FGV), 1, forced_return_FGV_for_tsn_l); + // UT_SetDeferredRetcode(UT_KEY(FGV), 1, forced_return_FGV_for_eid_l); + // UT_SetDeferredRetcode(UT_KEY(FGV), 1, forced_return_FGV_for_tsn_l); - /* Act */ - //local_result = CF_HeaderSize(arg_ph); + // /* Act */ + // local_result = CF_HeaderSize(arg_ph); /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - (eid_l>0)&&(tsn_l>0)"); @@ -1018,9 +1020,7 @@ void Test_CF_EndOfHeaderPtr_Return_ph_PointerPlus_CF_HeaderSize_ph(void) local_result = CF_EndOfHeaderPtr(arg_ph); /* Assert */ - UtAssert_True(local_result == expected_result, - "CF_GetVariableHeader returned %p and should be %p ((void*)(((uint8*)ph)+CF_HeaderSize(ph)))", - local_result, expected_result); + UtAssert_ADDRESS_EQ(local_result, expected_result); /* Assert for CF_HeaderSize */ UtAssert_STUB_COUNT(FGV, 2); } /* end Test_CF_EndOfHeaderPtr_Return_ph_PointerPlus_CF_HeaderSize_ph */ diff --git a/unit-test/cf_cfdp_r_tests.c b/unit-test/cf_cfdp_r_tests.c index fce7593d..5ea88cf4 100644 --- a/unit-test/cf_cfdp_r_tests.c +++ b/unit-test/cf_cfdp_r_tests.c @@ -37,6 +37,14 @@ static void Dummy_fns(transaction_t *t, const pdu_header_t *pdu) UT_DEFAULT_IMPL(Dummy_fns); } +void Handler_CF_CRC_Finalize_SetResult(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context) +{ + cf_crc_t* c = UT_Hook_GetArgValueByName(Context, "c", cf_crc_t*); + cf_crc_t* c_with_result = (cf_crc_t*)UserObj; + + c->result = c_with_result->result; +} + /******************************************************************************* ** ** cf_cfdp_r_tests local stub functions for overrides @@ -46,8 +54,8 @@ static void Dummy_fns(transaction_t *t, const pdu_header_t *pdu) /* uint8 chosen for ease of Stub use, may need increased if larger values use this */ uint8 Stub_FGV(uint8 source, CF_FIELD_FIELD name) { - UT_Stub_CopyFromLocal(UT_KEY(Stub_FGV), &source, sizeof(source)); - UT_Stub_CopyFromLocal(UT_KEY(Stub_FGV), &name, sizeof(name)); + UT_Stub_CopyFromLocal(UT_KEY(FGV), &source, sizeof(source)); + UT_Stub_CopyFromLocal(UT_KEY(FGV), &name, sizeof(name)); return UT_DEFAULT_IMPL(Stub_FGV); } @@ -123,8 +131,7 @@ void Test_CFDP_R1_Reset_Call_CF_CFDP_ResetTransaction_With_1_For_keep_history(vo /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 1); - UtAssert_True(received_args.t == &arg_t, - "Address of t sent is %p and should be %p", received_args.t, &arg_t); + UtAssert_ADDRESS_EQ(received_args.t, &arg_t); UtAssert_True(received_args.keep_history == 1, "CF_CFDP_ResetTransaction was sent %d and should be 1", received_args.keep_history); @@ -311,9 +318,7 @@ void Test_CF_CFDP_R_CheckCrc_When_crc_NotEq_expected_crc_SendEventAndCountMismat local_result = CF_CFDP_R_CheckCrc(&arg_t, arg_expected_crc); /* Assert */ - UtAssert_True(received_crc == &arg_t.crc, - "CF_CRC_Finalize received transaction crc at address %p and should be %p", - received_crc, &arg_t.crc); + UtAssert_ADDRESS_EQ(received_crc, &arg_t.crc); UtAssert_True(local_result == expected_result, "CF_CFDP_R_CheckCrc returned %d and should be fail value of %d", local_result, expected_result); @@ -346,9 +351,7 @@ void Test_CF_CFDP_R_CheckCrc_When_crc_calculated_IsEqTo_expected_crc_Return_0(vo local_result = CF_CFDP_R_CheckCrc(&arg_t, arg_expected_crc); /* Assert */ - UtAssert_True(received_crc == &arg_t.crc, - "CF_CRC_Finalize received transaction crc at address %p and should be %p", - received_crc, &arg_t.crc); + UtAssert_ADDRESS_EQ(received_crc, &arg_t.crc); UtAssert_True(local_result == expected_result, "CF_CFDP_R_CheckCrc returned %d and should be fail value of %d", local_result, expected_result); @@ -368,7 +371,7 @@ void Test_CF_CFDP_R2_Complete_Given_t_history_cc_IsNotEqTo_CC_NO_ERROR_DoNothing history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_ok_to_send_nak; + int arg_ok_to_send_nak = Any_int(); uint8 initial_sub_state = Any_uint8_Except(RECV_FILEDATA); /* uint8 used for rx_sub_state because it is a small valuation right now, TODO: create any_cf_rx_sub_state */ arg_t->history = &dummy_history; @@ -607,19 +610,22 @@ void Test_CF_CFDP_R2_Complete_Calls_CF_Chunks_ComputeGaps_Returns_non0_Set_send_ void Test_CF_CFDP_R_ProcessFd_NoCrcWhen_bytes_received_IsLessThan_size_of_pdu_file_data_header_t_Return_neg1(void) { /* Arrange */ - pdu_header_t dummy_ph; - transaction_t* arg_t; + pdu_header_t dummy_ph; + transaction_t dummy_t; + transaction_t* arg_t = &dummy_t; CFE_MSG_Size_t dummy_bytes_received; CFE_MSG_Size_t* arg_bytes_received = &dummy_bytes_received; CFE_MSG_Size_t initial_bytes_received = Any_uint32_LessThan(sizeof(pdu_file_data_header_t)); int local_result; - CF_AppData.engine.in.msg = &dummy_ph; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_ph; CF_AppData.engine.in.bytes_received = initial_bytes_received; UT_SetDefaultReturnValue(UT_KEY(CF_HeaderSize), 0); - UT_SetDefaultReturnValue(UT_KEY(Stub_FGV), 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); + + arg_t->chan_num = Any_cf_chan_num(); /* Act */ local_result = CF_CFDP_R_ProcessFd(arg_t, arg_bytes_received); @@ -637,19 +643,22 @@ void Test_CF_CFDP_R_ProcessFd_NoCrcWhen_bytes_received_IsLessThan_size_of_pdu_fi void Test_CF_CFDP_R_ProcessFd_HasCrcBut_bytes_received_Minus_4_IsLessThan_size_of_pdu_file_data_header_t_Return_neg1(void) { /* Arrange */ - pdu_header_t dummy_ph; - transaction_t* arg_t; + pdu_header_t dummy_ph; + transaction_t dummy_t; + transaction_t* arg_t = &dummy_t; CFE_MSG_Size_t dummy_bytes_received; CFE_MSG_Size_t* arg_bytes_received = &dummy_bytes_received; CFE_MSG_Size_t initial_bytes_received = Any_uint32_LessThan(sizeof(pdu_file_data_header_t)) + 4; int local_result; - CF_AppData.engine.in.msg = &dummy_ph; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_ph; UT_SetDefaultReturnValue(UT_KEY(CF_HeaderSize), 0); - UT_SetDefaultReturnValue(UT_KEY(Stub_FGV), 1); + UT_SetDefaultReturnValue(UT_KEY(FGV), 1); CF_AppData.engine.in.bytes_received = initial_bytes_received; + arg_t->chan_num = Any_cf_chan_num(); + /* Act */ local_result = CF_CFDP_R_ProcessFd(arg_t, arg_bytes_received); @@ -659,15 +668,14 @@ void Test_CF_CFDP_R_ProcessFd_HasCrcBut_bytes_received_Minus_4_IsLessThan_size_o local_result); UtAssert_STUB_COUNT(CF_HeaderSize, 1); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); - } /* end Test_CF_CFDP_R_ProcessFd_HasCrcBut_bytes_received_Minus_4_IsLessThan_size_of_pdu_file_data_header_t_Return_neg1 */ void Test_CF_CFDP_R_ProcessFd_NoCrc_cached_pos_NotEqTo_offset_And_fret_NotEqTo_offset_SendEventSetAndCountErrorReturn_neg1(void) { /* Arrange */ uint32 dummy_offset = Any_uint32(); - pdu_header_t* dummy_ph; - pdu_fd_t* dummy_fd; + pdu_header_t* dummy_ph = NULL; + pdu_fd_t* dummy_fd = NULL; history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; @@ -680,7 +688,7 @@ void Test_CF_CFDP_R_ProcessFd_NoCrc_cached_pos_NotEqTo_offset_And_fret_NotEqTo_o CF_AppData.engine.in.bytes_received = initial_bytes_received; UT_SetDefaultReturnValue(UT_KEY(CF_HeaderSize), 0); - UT_SetDefaultReturnValue(UT_KEY(Stub_FGV), 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; dummy_fd = (pdu_fd_t*)dummy_ph; @@ -713,8 +721,8 @@ void Test_CF_CFDP_R_ProcessFd_NoCrc_fret_NotEqTo_bytes_received_Value_SendEventS { /* Arrange */ uint32 dummy_offset = Any_uint32(); - pdu_header_t* dummy_ph; - pdu_fd_t* dummy_fd; + pdu_header_t* dummy_ph = NULL; + pdu_fd_t* dummy_fd = NULL; history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; @@ -727,7 +735,7 @@ void Test_CF_CFDP_R_ProcessFd_NoCrc_fret_NotEqTo_bytes_received_Value_SendEventS CF_AppData.engine.in.bytes_received = initial_bytes_received; UT_SetDefaultReturnValue(UT_KEY(CF_HeaderSize), 0); - UT_SetDefaultReturnValue(UT_KEY(Stub_FGV), 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; dummy_fd = (pdu_fd_t*)dummy_ph; @@ -761,8 +769,8 @@ void Test_CF_CFDP_R_ProcessFd_NoCrc_cached_pos_Gets_bytes_received_Plus_offset_A { /* Arrange */ uint32 dummy_offset = Any_uint32(); - pdu_header_t* dummy_ph; - pdu_fd_t* dummy_fd; + pdu_header_t* dummy_ph = NULL; + pdu_fd_t* dummy_fd = NULL; history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; @@ -777,7 +785,7 @@ void Test_CF_CFDP_R_ProcessFd_NoCrc_cached_pos_Gets_bytes_received_Plus_offset_A CF_AppData.engine.in.bytes_received = initial_bytes_received; UT_SetDefaultReturnValue(UT_KEY(CF_HeaderSize), 0); - UT_SetDefaultReturnValue(UT_KEY(Stub_FGV), 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; dummy_fd = (pdu_fd_t*)dummy_ph; @@ -804,7 +812,7 @@ void Test_CF_CFDP_R_ProcessFd_NoCrc_cached_pos_Gets_bytes_received_Plus_offset_A UtAssert_STUB_COUNT(CF_WrappedWrite, 1); UtAssert_UINT32_EQ(arg_t->state_data.r.cached_pos, updated_bytes_received + dummy_offset); UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.file_data_bytes == (uint64)((uint64)updated_bytes_received + (uint64)initial_file_data_bytes), - "CF_AppData recv.file_data_bytes is %u and should be %u (*bytes_received) more than %u (value before call)", + "CF_AppData recv.file_data_bytes is %lu and should be %lu (*bytes_received) more than %lu (value before call)", CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.file_data_bytes, updated_bytes_received, initial_file_data_bytes); } /* end Test_CF_CFDP_R_ProcessFd_NoCrc_cached_pos_Gets_bytes_received_Plus_offset_And_data_bytes_IncreasesBy_bytes_received_Return_0 */ @@ -812,8 +820,8 @@ void Test_CF_CFDP_R_ProcessFd_NoCrc_cached_pos_NotEqTo_offset_But_fret_IsEqTo_of { /* Arrange */ uint32 dummy_offset = Any_uint32(); - pdu_header_t* dummy_ph; - pdu_fd_t* dummy_fd; + pdu_header_t* dummy_ph = NULL; + pdu_fd_t* dummy_fd = NULL; history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; @@ -828,7 +836,7 @@ void Test_CF_CFDP_R_ProcessFd_NoCrc_cached_pos_NotEqTo_offset_But_fret_IsEqTo_of CF_AppData.engine.in.bytes_received = initial_bytes_received; UT_SetDefaultReturnValue(UT_KEY(CF_HeaderSize), 0); - UT_SetDefaultReturnValue(UT_KEY(Stub_FGV), 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; dummy_fd = (pdu_fd_t*)dummy_ph; @@ -857,7 +865,7 @@ void Test_CF_CFDP_R_ProcessFd_NoCrc_cached_pos_NotEqTo_offset_But_fret_IsEqTo_of UtAssert_STUB_COUNT(CF_WrappedWrite, 1); UtAssert_UINT32_EQ(arg_t->state_data.r.cached_pos, updated_bytes_received + dummy_offset); UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.file_data_bytes == (uint64)((uint64)updated_bytes_received + (uint64)initial_file_data_bytes), - "CF_AppData recv.file_data_bytes is %u and should be %u (*bytes_received) more than %u (value before call)", + "CF_AppData recv.file_data_bytes is %lu and should be %lu (*bytes_received) more than %lu (value before call)", CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.file_data_bytes, updated_bytes_received, initial_file_data_bytes); } /* end Test_CF_CFDP_R_ProcessFd_NoCrc_cached_pos_NotEqTo_offset_But_fret_IsEqTo_offset_cached_pos_Gets_bytes_received_Plus_offset_And_data_bytes_IncreasesBy_bytes_received_Return_0 */ @@ -875,7 +883,7 @@ void Test_CF_CFDP_R_SubstateRecvEof_CallTo_CF_CFDP_RecvEof_Returns_non0_SendEven history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* arg_ph; + pdu_header_t* arg_ph = NULL; uint32 initial_recv_error = Any_uint32(); int local_result; @@ -905,7 +913,7 @@ void Test_CF_CFDP_R_SubstateRecvEof_md_recv_IsEqTo_1_And_ph_size_IsNotEqTo_t_fsi transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_eof_t dummy_ph; - pdu_header_t* arg_ph = &dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint16 initial_file_size_mismatch = Any_uint16(); int local_result; @@ -938,7 +946,7 @@ void Test_CF_CFDP_R_SubstateRecvEof_md_recv_IsEqTo_0_And_ph_size_IsNotEqTo_t_fsi transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_eof_t dummy_ph; - pdu_header_t* arg_ph = &dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint16 initial_file_size_mismatch = Any_uint16(); int local_result; @@ -970,7 +978,7 @@ void Test_CF_CFDP_R_SubstateRecvEof_md_recv_IsEqTo_1_And_ph_size_IsEqTo_t_fsize_ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_eof_t dummy_ph; - pdu_header_t* arg_ph = &dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint16 initial_file_size_mismatch = Any_uint16(); int local_result; @@ -1008,8 +1016,8 @@ void Test_CF_CFDP_R1_SubstateRecvEof_CallTo_CF_CFDP_R_SubstateRecvEof_NotEqTo_R_ /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_eof_t dummy_pdu; - pdu_header_t* arg_ph = &dummy_pdu; + pdu_eof_t dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint32 initial_keep = Any_uint8_Except(1); arg_t->keep = initial_keep; @@ -1038,16 +1046,16 @@ void Test_CF_CFDP_R1_SubstateRecvEof_CallTo_CF_CFDP_R_CheckCrc_Returns_non0_DoNo /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_eof_t dummy_pdu; - pdu_header_t* arg_ph = &dummy_pdu; + pdu_eof_t dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint32 initial_keep = Any_uint8_Except(1); - dummy_pdu.crc = Any_uint32(); + dummy_ph.crc = Any_uint32(); arg_t->keep = initial_keep; /* Arrange for CF_CFDP_R_CheckCrc */ - arg_t->crc.result = Any_uint32_Except(dummy_pdu.crc); + arg_t->crc.result = Any_uint32_Except(dummy_ph.crc); /* Arrange for CF_CFDP_R_SubstateRecvEof */ history_t dummy_history; @@ -1059,7 +1067,7 @@ void Test_CF_CFDP_R1_SubstateRecvEof_CallTo_CF_CFDP_R_CheckCrc_Returns_non0_DoNo arg_t->history = &dummy_history; arg_t->flags.rx.md_recv = 0; arg_t->fsize = Any_uint32(); - dummy_pdu.size = Any_uint32_Except(arg_t->fsize); + dummy_ph.size = Any_uint32_Except(arg_t->fsize); CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.file_size_mismatch = initial_file_size_mismatch; @@ -1081,16 +1089,16 @@ void Test_CF_CFDP_R1_SubstateRecvEof_SetGiven_t_keep_To_1(void) /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_eof_t dummy_pdu; - pdu_header_t* arg_ph = &dummy_pdu; + pdu_eof_t dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint32 initial_keep = Any_uint8_Except(1); - dummy_pdu.crc = Any_uint32(); + dummy_ph.crc = Any_uint32(); arg_t->keep = initial_keep; /* Arrange for CF_CFDP_R_CheckCrc */ - arg_t->crc.result = dummy_pdu.crc; + arg_t->crc.result = dummy_ph.crc; /* Arrange for CF_CFDP_R_SubstateRecvEof */ history_t dummy_history; @@ -1102,7 +1110,7 @@ void Test_CF_CFDP_R1_SubstateRecvEof_SetGiven_t_keep_To_1(void) arg_t->history = &dummy_history; arg_t->flags.rx.md_recv = 0; arg_t->fsize = Any_uint32(); - dummy_pdu.size = Any_uint32_Except(arg_t->fsize); + dummy_ph.size = Any_uint32_Except(arg_t->fsize); CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.file_size_mismatch = initial_file_size_mismatch; @@ -1132,7 +1140,7 @@ void Test_CF_CFDP_R2_SubstateRecvEof_Given_t_flags_rx_eof_recv_Is_1_DoNothing(vo /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* arg_ph; + pdu_header_t* arg_ph = NULL; arg_t->flags.rx.eof_recv = 1; @@ -1149,7 +1157,7 @@ void Test_CF_CFDP_R2_SubstateRecvEof_CallTo_CF_CFDP_R_SubstateRecvEof_ReturnsAny /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* arg_ph; + pdu_header_t* arg_ph = NULL; arg_t->flags.rx.eof_recv = 0; @@ -1178,8 +1186,8 @@ void Test_CF_CFDP_R2_SubstateRecvEof_CallTo_CF_CFDP_R_SubstateRecvEof_Returns_R_ /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_eof_t dummy_pdu; - pdu_header_t* arg_ph = &dummy_pdu; + pdu_eof_t dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; arg_t->flags.rx.eof_recv = 0; @@ -1214,8 +1222,8 @@ void Test_CF_CFDP_R2_SubstateRecvEof_CallTo_CF_CFDP_R_SubstateRecvEof_Returns_R_ /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_eof_t dummy_pdu; - pdu_header_t* arg_ph = &dummy_pdu; + pdu_eof_t dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; arg_t->flags.rx.eof_recv = 0; @@ -1257,8 +1265,8 @@ void Test_CF_CFDP_R2_SubstateRecvEof_CallTo_CF_CFDP_R_SubstateRecvEof_Returns_R_ /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_eof_t dummy_pdu; - pdu_header_t* arg_ph = &dummy_pdu; + pdu_eof_t dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; arg_t->flags.rx.eof_recv = 0; @@ -1290,8 +1298,8 @@ void Test_CF_CFDP_R2_SubstateRecvEof_CallTo_CF_CFDP_R_SubstateRecvEof_Returns_R_ void Test_CF_CFDP_R1_SubstateRecvFileData_CallTo_CF_CFDP_RecvFd_Returns_non0_Call_CF_CFDP_R1_Reset(void) { /* Arrange */ - transaction_t* arg_t; - pdu_header_t* arg_ph; + transaction_t* arg_t = NULL; + pdu_header_t* arg_ph = NULL; int forced_return_CF_CFDP_RecvFd = Any_int_Except(0); UT_SetHandlerFunction(UT_KEY(CF_CFDP_RecvFd), Handler_int_ForcedReturnOnly, &forced_return_CF_CFDP_RecvFd); @@ -1310,8 +1318,8 @@ void Test_CF_CFDP_R1_SubstateRecvFileData_CallTo_CF_CFDP_RecvFd_Returns_non0_Cal void Test_CF_CFDP_R1_SubstateRecvFileData_CallTo_CF_CFDP_RecvFd_Returns_0_CallTo_CF_CFDP_R_ProcessFd_Returns_0_Call_CF_CFDP_R1_Reset(void) { /* Arrange */ - transaction_t* arg_t; - pdu_header_t* arg_ph; + transaction_t* arg_t = NULL; + pdu_header_t* arg_ph = NULL; int forced_return_CF_CFDP_RecvFd = 0; UT_SetHandlerFunction(UT_KEY(CF_CFDP_RecvFd), Handler_int_ForcedReturnOnly, &forced_return_CF_CFDP_RecvFd); @@ -1339,8 +1347,8 @@ void Test_CF_CFDP_R1_SubstateRecvFileData_CallTo_CF_CFDP_RecvFd_Returns_0_CallTo void Test_CF_CFDP_R1_SubstateRecvFileData_CallTo_CF_CFDP_RecvFd_Returns_0_CallTo_CF_CFDP_R_ProcessFd_Returns_non0_Call_CF_CRC_Digest(void) { /* Arrange */ - transaction_t* arg_t; - pdu_header_t* arg_ph; + transaction_t* arg_t = NULL; + pdu_header_t* arg_ph = NULL; int forced_return_CF_CFDP_RecvFd = 0; UT_SetHandlerFunction(UT_KEY(CF_CFDP_RecvFd), Handler_int_ForcedReturnOnly, &forced_return_CF_CFDP_RecvFd); @@ -1351,21 +1359,18 @@ void Test_CF_CFDP_R1_SubstateRecvFileData_CallTo_CF_CFDP_RecvFd_Returns_0_CallTo pdu_r_msg_t dummy_msg; pdu_header_t* dummy_ph; history_t dummy_history; - CFE_MSG_Size_t dummy_bytes_received; - CFE_MSG_Size_t* arg_bytes_received = &dummy_bytes_received; uint32 fake_bytes_received = Any_uint32_BetweenExcludeMax(sizeof(pdu_file_data_header_t) + sizeof(pdu_file_data_header_t), UINT16_MAX); /*TODO Any_uint32_GreaterThan runs test fine, but should really be an unsigned long , UINT16_MAX used for size constraint testability */ CFE_MSG_Size_t initial_bytes_received = fake_bytes_received; CFE_MSG_Size_t updated_bytes_received = fake_bytes_received - sizeof(pdu_file_data_header_t); uint64 initial_file_data_bytes = Any_uint64(); - int local_result; - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; CF_AppData.engine.in.bytes_received = initial_bytes_received; UT_SetDefaultReturnValue(UT_KEY(CF_HeaderSize), 0); - UT_SetDefaultReturnValue(UT_KEY(Stub_FGV), 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); ((pdu_fd_t*)dummy_ph)->fdh.offset = dummy_offset; arg_t = &dummy_t; @@ -1400,8 +1405,8 @@ void Test_CF_CFDP_R1_SubstateRecvFileData_CallTo_CF_CFDP_RecvFd_Returns_0_CallTo void Test_CF_CFDP_R2_SubstateRecvFileData_CallTo_CF_CFDP_RecvFd_Returns_non0_Call_CF_CFDP_R2_Reset(void) { /* Arrange */ - transaction_t* arg_t; - pdu_header_t* arg_ph; + transaction_t* arg_t = NULL; + pdu_header_t* arg_ph = NULL; int forced_return_CF_CFDP_RecvFd = Any_int_Except(0); UT_SetHandlerFunction(UT_KEY(CF_CFDP_RecvFd), Handler_int_ForcedReturnOnly, &forced_return_CF_CFDP_RecvFd); @@ -1427,8 +1432,8 @@ void Test_CF_CFDP_R2_SubstateRecvFileData_CallTo_CF_CFDP_RecvFd_Returns_non0_Cal void Test_CF_CFDP_R2_SubstateRecvFileData_CallTo_CF_CFDP_RecvFd_Returns_0_CallTo_CF_CFDP_R_ProcessFd_Returns_non0_Call_CF_CFDP_R2_Reset(void) { /* Arrange */ - transaction_t* arg_t; - pdu_header_t* arg_ph; + transaction_t* arg_t = NULL; + pdu_header_t* arg_ph = NULL; int forced_return_CF_CFDP_RecvFd = 0; UT_SetHandlerFunction(UT_KEY(CF_CFDP_RecvFd), Handler_int_ForcedReturnOnly, &forced_return_CF_CFDP_RecvFd); @@ -1459,7 +1464,8 @@ void Test_CF_CFDP_R2_SubstateRecvFileData_t_flags_rx_fd_nak_sent_Is_0_And_t_flag /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* arg_ph; + pdu_header_t dummy_arg_ph; + pdu_header_t* arg_ph = &dummy_arg_ph; int forced_return_CF_CFDP_RecvFd = 0; UT_SetHandlerFunction(UT_KEY(CF_CFDP_RecvFd), Handler_int_ForcedReturnOnly, &forced_return_CF_CFDP_RecvFd); @@ -1475,21 +1481,18 @@ void Test_CF_CFDP_R2_SubstateRecvFileData_t_flags_rx_fd_nak_sent_Is_0_And_t_flag pdu_r_msg_t dummy_msg; pdu_header_t* dummy_ph; history_t dummy_history; - CFE_MSG_Size_t dummy_bytes_received; - CFE_MSG_Size_t* arg_bytes_received = &dummy_bytes_received; uint32 fake_bytes_received = Any_uint32_BetweenExcludeMax(sizeof(pdu_file_data_header_t) + sizeof(pdu_file_data_header_t), UINT16_MAX); /*TODO Any_uint32_GreaterThan runs test fine, but should really be an unsigned long , UINT16_MAX used for size constraint testability */ CFE_MSG_Size_t initial_bytes_received = fake_bytes_received; CFE_MSG_Size_t updated_bytes_received = fake_bytes_received - sizeof(pdu_file_data_header_t); uint64 initial_file_data_bytes = Any_uint64(); - int local_result; - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; CF_AppData.engine.in.bytes_received = initial_bytes_received; UT_SetDefaultReturnValue(UT_KEY(CF_HeaderSize), 0); - UT_SetDefaultReturnValue(UT_KEY(Stub_FGV), 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); ((pdu_fd_t*)dummy_ph)->fdh.offset = dummy_offset; arg_t->state_data.r.cached_pos = dummy_offset; @@ -1520,7 +1523,8 @@ void Test_CF_CFDP_R2_SubstateRecvFileData_t_flags_rx_fd_nak_sent_Is_1_Call_CF_CF /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* arg_ph; + pdu_header_t dummy_arg_ph; + pdu_header_t* arg_ph = &dummy_arg_ph; int forced_return_CF_CFDP_RecvFd = 0; UT_SetHandlerFunction(UT_KEY(CF_CFDP_RecvFd), Handler_int_ForcedReturnOnly, &forced_return_CF_CFDP_RecvFd); @@ -1536,21 +1540,18 @@ void Test_CF_CFDP_R2_SubstateRecvFileData_t_flags_rx_fd_nak_sent_Is_1_Call_CF_CF pdu_r_msg_t dummy_msg; pdu_header_t* dummy_ph; history_t dummy_history; - CFE_MSG_Size_t dummy_bytes_received; - CFE_MSG_Size_t* arg_bytes_received = &dummy_bytes_received; uint32 fake_bytes_received = Any_uint32_BetweenExcludeMax(sizeof(pdu_file_data_header_t) + sizeof(pdu_file_data_header_t), UINT16_MAX); /*TODO Any_uint32_GreaterThan runs test fine, but should really be an unsigned long , UINT16_MAX used for size constraint testability */ CFE_MSG_Size_t initial_bytes_received = fake_bytes_received; CFE_MSG_Size_t updated_bytes_received = fake_bytes_received - sizeof(pdu_file_data_header_t); uint64 initial_file_data_bytes = Any_uint64(); - int local_result; - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; CF_AppData.engine.in.bytes_received = initial_bytes_received; UT_SetDefaultReturnValue(UT_KEY(CF_HeaderSize), 0); - UT_SetDefaultReturnValue(UT_KEY(Stub_FGV), 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); ((pdu_fd_t*)dummy_ph)->fdh.offset = dummy_offset; arg_t->state_data.r.cached_pos = dummy_offset; @@ -1584,7 +1585,8 @@ void Test_CF_CFDP_R2_SubstateRecvFileData_t_flags_rx_fd_nak_sent_Is_0_And_t_flag /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* arg_ph; + pdu_header_t dummy_arg_ph; + pdu_header_t* arg_ph = &dummy_arg_ph; int forced_return_CF_CFDP_RecvFd = 0; UT_SetHandlerFunction(UT_KEY(CF_CFDP_RecvFd), Handler_int_ForcedReturnOnly, &forced_return_CF_CFDP_RecvFd); @@ -1598,23 +1600,20 @@ void Test_CF_CFDP_R2_SubstateRecvFileData_t_flags_rx_fd_nak_sent_Is_0_And_t_flag /* Arrange for CF_CFDP_R_ProcessFd */ uint32 dummy_offset = Any_uint32(); pdu_r_msg_t dummy_msg; - pdu_header_t* dummy_ph; + pdu_header_t* dummy_ph = NULL; history_t dummy_history; - CFE_MSG_Size_t dummy_bytes_received; - CFE_MSG_Size_t* arg_bytes_received = &dummy_bytes_received; uint32 fake_bytes_received = Any_uint32_BetweenExcludeMax(sizeof(pdu_file_data_header_t) + sizeof(pdu_file_data_header_t), UINT16_MAX); /*TODO Any_uint32_GreaterThan runs test fine, but should really be an unsigned long , UINT16_MAX used for size constraint testability */ CFE_MSG_Size_t initial_bytes_received = fake_bytes_received; CFE_MSG_Size_t updated_bytes_received = fake_bytes_received - sizeof(pdu_file_data_header_t); uint64 initial_file_data_bytes = Any_uint64(); - int local_result; - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; CF_AppData.engine.in.bytes_received = initial_bytes_received; UT_SetDefaultReturnValue(UT_KEY(CF_HeaderSize), 0); - UT_SetDefaultReturnValue(UT_KEY(Stub_FGV), 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); ((pdu_fd_t*)dummy_ph)->fdh.offset = dummy_offset; arg_t->state_data.r.cached_pos = dummy_offset; @@ -1651,19 +1650,19 @@ void Test_CF_CFDP_R2_SubstateRecvFileData_t_flags_rx_fd_nak_sent_Is_0_And_t_flag void Test_CF_CFDP_R2_GapCompute_AssertsWhenGiven_c_size_Is_0(void) { - /* Arrange */ - chunks_t* arg_chunks; - chunk_t dummy_c; - chunk_t* arg_c = &dummy_c; - gap_compute_args_t dummy_args; - void* arg_opaque = &dummy_args; + // /* Arrange */ + // chunks_t* arg_chunks; + // chunk_t dummy_c; + // chunk_t* arg_c = &dummy_c; + // gap_compute_args_t dummy_args; + // void* arg_opaque = &dummy_args; - arg_c->size = 0; + // arg_c->size = 0; - /* Act */ - //CF_CFDP_R2_GapCompute(arg_chunks, arg_c, arg_opaque); + // /* Act */ + // CF_CFDP_R2_GapCompute(arg_chunks, arg_c, arg_opaque); - /* Assert */ + // /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - c->size>0"); } /* end Test_CF_CFDP_R2_GapCompute_AssertsWhenGiven_c_size_Is_0 */ @@ -1677,12 +1676,12 @@ void Test_CF_CFDP_R2_GapCompute_WhenGiven_c_size_IsGreaterThan_0_Increment_gap_c pdu_nak_t dummy_nak; gap_compute_args_t dummy_args; void* arg_opaque = &dummy_args; - uint32 initial_gap_counter = Any_uint8_LessThan(5); /* TODO: 5 is arbitrary and used to allow test run, large values cause segfaulting */ + uint32 initial_gap_counter = 0; /* there is only 1 segment in the nak */ - arg_c->size = Any_uint8_GreaterThan(0); /* Any_uint8_GreaterThan(0) used to keep testing size reasonable, undelying type for arg_c->size unit32 */ + arg_c->size = 1; dummy_args.gap_counter = initial_gap_counter; - dummy_args.ph = &dummy_nak; + dummy_args.ph = (pdu_header_t*)&dummy_nak; /* Act */ CF_CFDP_R2_GapCompute(arg_chunks, arg_c, arg_opaque); @@ -1731,7 +1730,7 @@ void Test_CF_CFDP_R_SubstateSendNak_Given_t_md_recv_Is_0_SendEvent_CallTo_CF_CFD transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_nak; - pdu_header_t* dummy_ph = &dummy_nak; + pdu_header_t* dummy_ph = (pdu_header_t*)&dummy_nak; CF_CFDP_ConstructPduHeader_context_t context_CF_CFDP_ConstructPduHeader; CF_CFDP_SendNak_context_t context_CF_CFDP_SendNak; uint8 exceptions[2] = {CF_SEND_ERROR, CF_SEND_SUCCESS}; @@ -1762,31 +1761,31 @@ void Test_CF_CFDP_R_SubstateSendNak_Given_t_md_recv_Is_0_SendEvent_CallTo_CF_CFD void Test_CF_CFDP_R_SubstateSendNak_AssertsBecauseGiven_t_md_recv_Is_0_SendEvent_CallTo_CF_CFDP_SendNak_CannotReturn_CF_SEND_ERROR_ButDoesAnyway(void) { - /* Arrange */ - history_t dummy_history; - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; - pdu_nak_t dummy_nak; - pdu_header_t* dummy_ph = &dummy_nak; - CF_CFDP_ConstructPduHeader_context_t context_CF_CFDP_ConstructPduHeader; - CF_CFDP_SendNak_context_t context_CF_CFDP_SendNak; - int local_result; + // /* Arrange */ + // history_t dummy_history; + // transaction_t dummy_t; + // transaction_t* arg_t = &dummy_t; + // pdu_nak_t dummy_nak; + // pdu_header_t* dummy_ph = (pdu_header_t*)&dummy_nak; + // CF_CFDP_ConstructPduHeader_context_t context_CF_CFDP_ConstructPduHeader; + // CF_CFDP_SendNak_context_t context_CF_CFDP_SendNak; + // int local_result; - arg_t->history = &dummy_history; - arg_t->flags.rx.md_recv = 0; + // arg_t->history = &dummy_history; + // arg_t->flags.rx.md_recv = 0; - context_CF_CFDP_ConstructPduHeader.forced_return = dummy_ph; - UT_SetDataBuffer(UT_KEY(CF_CFDP_ConstructPduHeader), &context_CF_CFDP_ConstructPduHeader, - sizeof(context_CF_CFDP_ConstructPduHeader), false); + // context_CF_CFDP_ConstructPduHeader.forced_return = dummy_ph; + // UT_SetDataBuffer(UT_KEY(CF_CFDP_ConstructPduHeader), &context_CF_CFDP_ConstructPduHeader, + // sizeof(context_CF_CFDP_ConstructPduHeader), false); - context_CF_CFDP_SendNak.forced_return = CF_SEND_ERROR; - UT_SetDataBuffer(UT_KEY(CF_CFDP_SendNak), &context_CF_CFDP_SendNak, - sizeof(context_CF_CFDP_SendNak), false); + // context_CF_CFDP_SendNak.forced_return = CF_SEND_ERROR; + // UT_SetDataBuffer(UT_KEY(CF_CFDP_SendNak), &context_CF_CFDP_SendNak, + // sizeof(context_CF_CFDP_SendNak), false); - /* Act */ + // /* Act */ // local_result = CF_CFDP_R_SubstateSendNak(arg_t); - /* Assert */ + // /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - sret!=CF_SEND_ERROR"); // UtAssert_True(local_result == -1, // "CF_CFDP_R_SubstateSendNak returned %d and should be -1", @@ -1803,7 +1802,7 @@ void Test_CF_CFDP_R_SubstateSendNak_Given_t_md_recv_Is_0_SendEvent_CallTo_CF_CFD transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_nak; - pdu_header_t* dummy_ph = &dummy_nak; + pdu_header_t* dummy_ph = (pdu_header_t*)&dummy_nak; CF_CFDP_ConstructPduHeader_context_t context_CF_CFDP_ConstructPduHeader; CF_CFDP_SendNak_context_t context_CF_CFDP_SendNak; int local_result; @@ -1839,7 +1838,7 @@ void Test_CF_CFDP_R_SubstateSendNak_Given_t_md_recv_Is_1_CallTo_CF_Chunks_Comput transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_nak; - pdu_header_t* dummy_ph = &dummy_nak; + pdu_header_t* dummy_ph = (pdu_header_t*)&dummy_nak; CF_CFDP_ConstructPduHeader_context_t context_CF_CFDP_ConstructPduHeader; CF_CFDP_SendNak_context_t context_CF_CFDP_SendNak; uint8 exceptions[2] = {CF_SEND_ERROR, CF_SEND_SUCCESS}; @@ -1874,36 +1873,35 @@ void Test_CF_CFDP_R_SubstateSendNak_Given_t_md_recv_Is_1_CallTo_CF_Chunks_Comput void Test_CF_CFDP_R_SubstateSendNak_AssertsBecauseGiven_t_md_recv_Is_1_CallTo_CF_Chunks_ComputeGaps_Returns_non0_CallTo_CF_CFDP_SendNak_CannotReturn_CF_SEND_ERROR_ButDoesAnyway(void) { - /* Arrange */ - chunks_wrapper_t dummy_chunks; - history_t dummy_history; - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; - pdu_nak_t dummy_nak; - pdu_header_t* dummy_ph = &dummy_nak; - CF_CFDP_ConstructPduHeader_context_t context_CF_CFDP_ConstructPduHeader; - CF_CFDP_SendNak_context_t context_CF_CFDP_SendNak; - int local_result; + // /* Arrange */ + // chunks_wrapper_t dummy_chunks; + // history_t dummy_history; + // transaction_t dummy_t; + // transaction_t* arg_t = &dummy_t; + // pdu_nak_t dummy_nak; + // pdu_header_t* dummy_ph = (pdu_header_t*)&dummy_nak; + // CF_CFDP_ConstructPduHeader_context_t context_CF_CFDP_ConstructPduHeader; + // CF_CFDP_SendNak_context_t context_CF_CFDP_SendNak; - arg_t->history = &dummy_history; - arg_t->flags.rx.md_recv = 1; + // arg_t->history = &dummy_history; + // arg_t->flags.rx.md_recv = 1; - context_CF_CFDP_ConstructPduHeader.forced_return = dummy_ph; - UT_SetDataBuffer(UT_KEY(CF_CFDP_ConstructPduHeader), &context_CF_CFDP_ConstructPduHeader, - sizeof(context_CF_CFDP_ConstructPduHeader), false); + // context_CF_CFDP_ConstructPduHeader.forced_return = dummy_ph; + // UT_SetDataBuffer(UT_KEY(CF_CFDP_ConstructPduHeader), &context_CF_CFDP_ConstructPduHeader, + // sizeof(context_CF_CFDP_ConstructPduHeader), false); - UT_SetDefaultReturnValue(UT_KEY(CF_Chunks_ComputeGaps), Any_uint32_Except(0)); + // UT_SetDefaultReturnValue(UT_KEY(CF_Chunks_ComputeGaps), Any_uint32_Except(0)); - context_CF_CFDP_SendNak.forced_return = CF_SEND_ERROR; - UT_SetDataBuffer(UT_KEY(CF_CFDP_SendNak), &context_CF_CFDP_SendNak, - sizeof(context_CF_CFDP_SendNak), false); + // context_CF_CFDP_SendNak.forced_return = CF_SEND_ERROR; + // UT_SetDataBuffer(UT_KEY(CF_CFDP_SendNak), &context_CF_CFDP_SendNak, + // sizeof(context_CF_CFDP_SendNak), false); - arg_t->chunks = &dummy_chunks; + // arg_t->chunks = &dummy_chunks; - /* Act */ + // /* Act */ // local_result = CF_CFDP_R_SubstateSendNak(arg_t); - /* Assert */ + // /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - sret!=CF_SEND_ERROR"); // UtAssert_True(local_result == -1, // "CF_CFDP_R_SubstateSendNak returned %d and should be -1", @@ -1921,7 +1919,7 @@ void Test_CF_CFDP_R_SubstateSendNak_Given_t_md_recv_Is_1_CallTo_CF_Chunks_Comput transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_nak; - pdu_header_t* dummy_ph = &dummy_nak; + pdu_header_t* dummy_ph = (pdu_header_t*)&dummy_nak; CF_CFDP_ConstructPduHeader_context_t context_CF_CFDP_ConstructPduHeader; CF_CFDP_SendNak_context_t context_CF_CFDP_SendNak; int local_result; @@ -1961,9 +1959,8 @@ void Test_CF_CFDP_R_SubstateSendNak_Given_t_md_recv_Is_1_CallTo_CF_Chunks_Comput transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_nak; - pdu_header_t* dummy_ph = &dummy_nak; + pdu_header_t* dummy_ph = (pdu_header_t*)&dummy_nak; CF_CFDP_ConstructPduHeader_context_t context_CF_CFDP_ConstructPduHeader; - CF_CFDP_SendNak_context_t context_CF_CFDP_SendNak; int local_result; arg_t->history = &dummy_history; @@ -1999,9 +1996,8 @@ void Test_CF_CFDP_R_SubstateSendNak_Given_t_md_recv_Is_1_CallTo_CF_Chunks_Comput transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_nak; - pdu_header_t* dummy_ph = &dummy_nak; + pdu_header_t* dummy_ph = (pdu_header_t*)&dummy_nak; CF_CFDP_ConstructPduHeader_context_t context_CF_CFDP_ConstructPduHeader; - CF_CFDP_SendNak_context_t context_CF_CFDP_SendNak; int local_result; arg_t->history = &dummy_history; @@ -2037,9 +2033,8 @@ void Test_CF_CFDP_R_SubstateSendNak_Given_t_md_recv_Is_1_CallTo_CF_Chunks_Comput transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_nak; - pdu_header_t* dummy_ph = &dummy_nak; + pdu_header_t* dummy_ph = (pdu_header_t*)&dummy_nak; CF_CFDP_ConstructPduHeader_context_t context_CF_CFDP_ConstructPduHeader; - CF_CFDP_SendNak_context_t context_CF_CFDP_SendNak; int local_result; arg_t->history = &dummy_history; @@ -2261,7 +2256,6 @@ void Test_CF_CFDP_R_Init_StateIs_CFDP_R2_And_t_flags_rx_md_recv_Is_0_SendEventTh void Test_CF_CFDP_R2_CalcCrcChunk_Given_t_state_data_r_r2_rx_crc_calc_bytes_Is_Non0_And_count_bytes_IsGreaterThan_rx_crc_calc_bytes_per_wakeup_And_t_state_data_r_r2_rx_crc_calc_bytes_IsNotEqTo_t_fsize_Return_neg1(void) { /* Arrange */ - history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; cf_config_table_t dummy_config_table; @@ -2287,7 +2281,6 @@ void Test_CF_CFDP_R2_CalcCrcChunk_Given_t_state_data_r_r2_rx_crc_calc_bytes_Is_N void Test_CF_CFDP_R2_CalcCrcChunk_Given_t_state_data_r_r2_rx_crc_calc_bytes_Is_0_Call_CF_CRC_Start_And_count_bytes_IsGreaterThan_rx_crc_calc_bytes_per_wakeup_And_t_state_data_r_r2_rx_crc_calc_bytes_IsNotEqTo_t_fsize_Return_neg1(void) { /* Arrange */ - history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; cf_config_table_t dummy_config_table; @@ -2534,6 +2527,15 @@ void Test_CF_CFDP_R2_CalcCrcChunk_Given_t_state_data_r_cached_pos_IsEqTo_RXC_Cal arg_t->history = &dummy_history; arg_t->history->cc = Any_uint8_Except(CC_FILE_SIZE_ERROR); + + /* Arrange for CF_CFDP_R_CheckCrc */ + cf_crc_t dummy_crc; + cf_crc_t *received_crc = &dummy_crc; + + received_crc->result = Any_uint32_Except(arg_t->state_data.r.r2.eof_crc); + + UT_SetHandlerFunction(UT_KEY(CF_CRC_Finalize), Handler_CF_CRC_Finalize_SetResult, received_crc); + /* Act */ local_result = CF_CFDP_R2_CalcCrcChunk(arg_t); @@ -2596,22 +2598,22 @@ void Test_CF_CFDP_R2_SubstateSendFin_Given_t_history_cc_IsEqTo_CC_NO_ERROR_And_t void Test_CF_CFDP_R2_SubstateSendFin_AssertsBecauseCallTo_CF_CFDP_SendFin_Returns_CF_SEND_ERROR(void) { - /* Arrange */ - history_t dummy_history; - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; - int local_result; + // /* Arrange */ + // history_t dummy_history; + // transaction_t dummy_t; + // transaction_t* arg_t = &dummy_t; + // int local_result; - arg_t->history = &dummy_history; - arg_t->history->cc = Any_uint8_Except(CC_NO_ERROR); - arg_t->flags.rx.crc_calc = 0; + // arg_t->history = &dummy_history; + // arg_t->history->cc = Any_uint8_Except(CC_NO_ERROR); + // arg_t->flags.rx.crc_calc = 0; - UT_SetDefaultReturnValue(CF_CFDP_SendFin, CF_SEND_ERROR); + // UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_SendFin), CF_SEND_ERROR); - /* Act */ - //local_result = CF_CFDP_R2_SubstateSendFin(arg_t); + // /* Act */ + // //local_result = CF_CFDP_R2_SubstateSendFin(arg_t); - /* Assert */ + // /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - sret!=CF_SEND_ERROR"); } /* end Test_CF_CFDP_R2_SubstateSendFin_AssertsBecauseCallTo_CF_CFDP_SendFin_Returns_CF_SEND_ERROR */ @@ -2628,7 +2630,7 @@ void Test_CF_CFDP_R2_SubstateSendFin_Given_t_history_cc_IsEqTo_CC_NO_ERROR_CallT arg_t->history->cc = Any_uint8_Except(CC_NO_ERROR); arg_t->flags.rx.crc_calc = 0; - UT_SetDefaultReturnValue(CF_CFDP_SendFin, Any_uint8_ExceptThese(exceptions, 2)); + UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_SendFin), Any_uint8_ExceptThese(exceptions, 2)); arg_t->state_data.r.sub_state = Any_uint8_Except(RECV_WAIT_FOR_FIN_ACK); @@ -2657,7 +2659,7 @@ void Test_CF_CFDP_R2_SubstateSendFin_Given_t_flags_rx_crc_calc_Is_1_CallTo_CF_CF arg_t->history->cc = CC_NO_ERROR; arg_t->flags.rx.crc_calc = 1; - UT_SetDefaultReturnValue(CF_CFDP_SendFin, CF_SEND_SUCCESS); + UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_SendFin), CF_SEND_SUCCESS); arg_t->state_data.r.sub_state = Any_uint8_Except(RECV_WAIT_FOR_FIN_ACK); @@ -2686,7 +2688,7 @@ void Test_CF_CFDP_R2_SubstateSendFin_CallTo_CF_CFDP_R2_CalcCrcChunk_Returns_0_Gi arg_t->history->cc = CC_NO_ERROR; arg_t->flags.rx.crc_calc = 0; - UT_SetDefaultReturnValue(CF_CFDP_SendFin, CF_SEND_SUCCESS); + UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_SendFin), CF_SEND_SUCCESS); arg_t->state_data.r.sub_state = Any_uint8_Except(RECV_WAIT_FOR_FIN_ACK); @@ -2754,7 +2756,6 @@ void Test_CF_CFDP_R2_Recv_fin_ack_GetsInvalidFinAckFrom_CF_CFDP_RecvAck_SendEven /* Act */ CF_CFDP_R2_Recv_fin_ack(arg_t, arg_pdu); - /* Assert */ UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.error == initial_recv_error + 1, "recv error is %u and should be 1 more than %u (value before call)", @@ -2795,7 +2796,6 @@ void Test_CF_CFDP_R2_Recv_fin_ack_GetsValidFinAckFrom_CF_CFDP_RecvAck_Calls_CFDP /* Act */ CF_CFDP_R2_Recv_fin_ack(arg_t, arg_pdu); - /* Assert */ UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.error == initial_recv_error, "recv error is %u and should not have changed from %u (value before call)", @@ -2820,7 +2820,7 @@ void Test_CF_CFDP_R2_RecvMd_Given_t_flags_rx_md_recv_Is_1_DoNothing(void) /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* arg_ph; + pdu_header_t* arg_ph = NULL; arg_t->flags.rx.md_recv = 1; @@ -2837,7 +2837,7 @@ void Test_CF_CFDP_R2_RecvMd_Given_t_flags_rx_md_recv_Is_0_ButCallTo_CF_CFDP_Recv history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* arg_ph; + pdu_header_t* arg_ph = NULL; uint32 initial_recv_error = Any_uint32(); arg_t->flags.rx.md_recv = 0; @@ -2845,7 +2845,7 @@ void Test_CF_CFDP_R2_RecvMd_Given_t_flags_rx_md_recv_Is_0_ButCallTo_CF_CFDP_Recv arg_t->history = &dummy_history; AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.dst_filename, sizeof(arg_t->history->fnames.dst_filename)-1); - UT_SetDefaultReturnValue(CF_CFDP_RecvMd, Any_int32_Except(0)); /* TODO: int32 is used for ease of stub use and should be updated */ + UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_RecvMd), Any_int32_Except(0)); /* TODO: int32 is used for ease of stub use and should be updated */ UT_SetDataBuffer(UT_KEY(CFE_EVS_SendEvent), &EventID, sizeof(EventID), false); @@ -2871,7 +2871,7 @@ void Test_CF_CFDP_R2_RecvMd_Given_t_flags_rx_md_recv_Is_0_CallTo_CF_CFDP_RecvMd_ history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* arg_ph; + pdu_header_t* arg_ph = NULL; uint16 initial_file_size_mismatch = Any_uint16(); arg_t->flags.rx.md_recv = 0; @@ -2879,7 +2879,7 @@ void Test_CF_CFDP_R2_RecvMd_Given_t_flags_rx_md_recv_Is_0_CallTo_CF_CFDP_RecvMd_ arg_t->history = &dummy_history; AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.dst_filename, sizeof(arg_t->history->fnames.dst_filename)-1); - UT_SetDefaultReturnValue(CF_CFDP_RecvMd, 0); + UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_RecvMd), 0); arg_t->flags.rx.eof_recv = 1; @@ -2917,7 +2917,7 @@ void Test_CF_CFDP_R2_RecvMd_Given_t_flags_rx_md_recv_Is_0_CallTo_CF_CFDP_RecvMd_ history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* arg_ph; + pdu_header_t* arg_ph = NULL; uint16 initial_file_rename = Any_uint16(); arg_t->flags.rx.md_recv = 0; @@ -2925,14 +2925,14 @@ void Test_CF_CFDP_R2_RecvMd_Given_t_flags_rx_md_recv_Is_0_CallTo_CF_CFDP_RecvMd_ arg_t->history = &dummy_history; AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.dst_filename, sizeof(arg_t->history->fnames.dst_filename)-1); - UT_SetDefaultReturnValue(CF_CFDP_RecvMd, 0); + UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_RecvMd), 0); arg_t->flags.rx.eof_recv = 1; arg_t->fsize = Any_uint32(); arg_t->state_data.r.r2.eof_size = arg_t->fsize; - UT_SetDefaultReturnValue(OS_rename, Any_int32_Except(OS_SUCCESS)); + UT_SetDefaultReturnValue(UT_KEY(OS_rename), Any_int32_Except(OS_SUCCESS)); UT_SetDataBuffer(UT_KEY(CFE_EVS_SendEvent), &EventID, sizeof(EventID), false); @@ -2971,7 +2971,7 @@ void Test_CF_CFDP_R2_RecvMd_Given_t_flags_rx_md_recv_Is_0_CallTo_CF_CFDP_RecvMd_ history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* arg_ph; + pdu_header_t* arg_ph = NULL; uint16 initial_file_open = Any_uint16(); CF_WrappedOpenCreate_context_t context_CF_WrappedOpenCreate; @@ -2980,14 +2980,14 @@ void Test_CF_CFDP_R2_RecvMd_Given_t_flags_rx_md_recv_Is_0_CallTo_CF_CFDP_RecvMd_ arg_t->history = &dummy_history; AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.dst_filename, sizeof(arg_t->history->fnames.dst_filename)-1); - UT_SetDefaultReturnValue(CF_CFDP_RecvMd, 0); + UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_RecvMd), 0); arg_t->flags.rx.eof_recv = 1; arg_t->fsize = Any_uint32(); arg_t->state_data.r.r2.eof_size = arg_t->fsize; - UT_SetDefaultReturnValue(OS_rename, OS_SUCCESS); + UT_SetDefaultReturnValue(UT_KEY(OS_rename), OS_SUCCESS); context_CF_WrappedOpenCreate.forced_return = Any_int32_Negative(); UT_SetDataBuffer(UT_KEY(CF_WrappedOpenCreate), &context_CF_WrappedOpenCreate, @@ -3031,7 +3031,7 @@ void Test_CF_CFDP_R2_RecvMd_Given_t_flags_rx_md_recv_Is_0_CallTo_CF_CFDP_RecvMd_ history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* arg_ph; + pdu_header_t* arg_ph = NULL; CF_WrappedOpenCreate_context_t context_CF_WrappedOpenCreate; arg_t->flags.rx.md_recv = 0; @@ -3039,14 +3039,14 @@ void Test_CF_CFDP_R2_RecvMd_Given_t_flags_rx_md_recv_Is_0_CallTo_CF_CFDP_RecvMd_ arg_t->history = &dummy_history; AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.dst_filename, sizeof(arg_t->history->fnames.dst_filename)-1); - UT_SetDefaultReturnValue(CF_CFDP_RecvMd, 0); + UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_RecvMd), 0); arg_t->flags.rx.eof_recv = 0; arg_t->fsize = Any_uint32(); arg_t->state_data.r.r2.eof_size = arg_t->fsize; - UT_SetDefaultReturnValue(OS_rename, OS_SUCCESS); + UT_SetDefaultReturnValue(UT_KEY(OS_rename), OS_SUCCESS); context_CF_WrappedOpenCreate.forced_return = Any_int32_ZeroOrPositive(); UT_SetDataBuffer(UT_KEY(CF_WrappedOpenCreate), &context_CF_WrappedOpenCreate, @@ -3128,7 +3128,7 @@ void Test_CFDP_R_DispatchRecv_FlagsAreSetTo_PDU_HDR_FLAGS_TYPE_And_cc_DoesNotEq_ arg_t->state_data.r.sub_state = Any_uint8_LessThan(RECV_NUM_STATES); CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; - UT_SetDefaultReturnValue(FGV, 1); + UT_SetDefaultReturnValue(UT_KEY(FGV), 1); arg_t->history = &dummy_history; arg_t->history->cc = Any_uint8_Except(CC_NO_ERROR); @@ -3150,7 +3150,7 @@ void Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreSetTo_PDU_HDR_FLAGS_TYPE_And_cc { /* Arrange */ pdu_r_msg_t dummy_msg; - pdu_header_t* dummy_pdu = &dummy_msg.ph; + pdu_header_t* dummy_ph = &dummy_msg.ph; history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; @@ -3161,7 +3161,7 @@ void Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreSetTo_PDU_HDR_FLAGS_TYPE_And_cc arg_t->state_data.r.sub_state = Any_uint8_LessThan(RECV_NUM_STATES); CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; - UT_SetDefaultReturnValue(FGV, 1); + UT_SetDefaultReturnValue(UT_KEY(FGV), 1); arg_t->history = &dummy_history; arg_t->history->cc = CC_NO_ERROR; @@ -3175,12 +3175,8 @@ void Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreSetTo_PDU_HDR_FLAGS_TYPE_And_cc /* Assert */ UtAssert_STUB_COUNT(FGV, 1); UtAssert_STUB_COUNT(Dummy_fd_fn, 1); - UtAssert_True(context_Dummy_fd_fn.t == arg_t, - "fd_fn received t %p and should be %p (t)", - context_Dummy_fd_fn.t, arg_t); - UtAssert_True(context_Dummy_fd_fn.pdu == dummy_pdu, - "fd_fn received pdu %p and should be %p (pdu)", - context_Dummy_fd_fn.pdu, dummy_pdu); + UtAssert_True(context_Dummy_fd_fn.t == arg_t, "context_Dummy_fd_fn.t == arg_t"); + UtAssert_True(context_Dummy_fd_fn.pdu == dummy_ph, "context_Dummy_fd_fn.pdu == dummy_ph"); } /* end Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreSetTo_PDU_HDR_FLAGS_TYPE_And_cc_EqTo_CC_NO_ERROR_Calls_fd_fn_DispatchRecv_FlagsAreNotSetAnd_cc_DoesNotEq_CC_NO_ERROR_Increment_dropped */ void Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreNotSetAnd_directive_code_IsEqTo_PDU_INVALID_MAX_Increment_spurious_AndSendEvent(void) @@ -3197,7 +3193,7 @@ void Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreNotSetAnd_directive_code_IsEqTo arg_t->state_data.r.sub_state = Any_uint8_LessThan(RECV_NUM_STATES); CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; - UT_SetDefaultReturnValue(FGV, 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); ((pdu_file_directive_header_t*)&dummy_msg.ph)->directive_code = PDU_INVALID_MAX; @@ -3210,7 +3206,6 @@ void Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreNotSetAnd_directive_code_IsEqTo /* Act */ CF_CFDP_R_DispatchRecv(arg_t, arg_fns, arg_fd_fn); - /* Assert */ UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.spurious == (uint16)(initial_spurious + 1), "spurious is %u and should be 1 more than %u (value before call)", @@ -3235,7 +3230,7 @@ void Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreNotSetAnd_directive_code_IsGrea arg_t->state_data.r.sub_state = Any_uint8_LessThan(RECV_NUM_STATES); CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; - UT_SetDefaultReturnValue(FGV, 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); ((pdu_file_directive_header_t*)&dummy_msg.ph)->directive_code = Any_uint8_GreaterThan(PDU_INVALID_MAX); @@ -3249,7 +3244,6 @@ void Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreNotSetAnd_directive_code_IsGrea /* Act */ CF_CFDP_R_DispatchRecv(arg_t, arg_fns, arg_fd_fn); - /* Assert */ UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.spurious == (uint16)(initial_spurious + 1), "spurious is %u and should be 1 more than %u (value before call)", @@ -3274,7 +3268,7 @@ void Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreNotSetAnd_directive_code_IsLess arg_t->state_data.r.sub_state = Any_uint8_LessThan(RECV_NUM_STATES); CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; - UT_SetDefaultReturnValue(FGV, 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); ((pdu_file_directive_header_t*)&dummy_msg.ph)->directive_code = Any_uint8_LessThan(PDU_INVALID_MAX); @@ -3285,7 +3279,6 @@ void Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreNotSetAnd_directive_code_IsLess /* Act */ CF_CFDP_R_DispatchRecv(arg_t, arg_fns, arg_fd_fn); - /* Assert */ UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.dropped == initial_dropped, "dropped is %u and should not have changed from %u (value before call)", @@ -3306,18 +3299,18 @@ void Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreNotSetAnd_directive_code_IsLess void (*const arg_fd_fn)(transaction_t*, const pdu_header_t*) = Dummy_fd_fn; rx_sub_state dummy_state = Any_uint8_LessThan(RECV_NUM_STATES); uint8 dummy_directive_code = Any_uint8_LessThan(PDU_INVALID_MAX); - const void* fns_pointer = Dummy_fns; + void(*const fns_pointer)(transaction_t *t, const pdu_header_t *pdu) = Dummy_fns; Dummy_fns_context_t context_Dummy_fns; arg_t->state_data.r.sub_state = Any_uint8_LessThan(RECV_NUM_STATES); CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; - UT_SetDefaultReturnValue(FGV, 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); ((pdu_file_directive_header_t*)&dummy_msg.ph)->directive_code = dummy_directive_code; arg_t->state_data.r.sub_state = dummy_state; - // dummy_pdu->fdh.directive_code = dummy_directive_code; + // dummy_ph->fdh.directive_code = dummy_directive_code; memcpy((void*)&arg_fns[dummy_state][dummy_directive_code], &fns_pointer, sizeof(void*)); UT_SetDataBuffer(UT_KEY(Dummy_fns), &context_Dummy_fns, @@ -3328,9 +3321,7 @@ void Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreNotSetAnd_directive_code_IsLess /* Assert */ UtAssert_STUB_COUNT(Dummy_fns, 1); - UtAssert_True(context_Dummy_fns.t == arg_t, - "fns received t %p and should be %p (t)", - context_Dummy_fns.t, arg_t); + UtAssert_True(context_Dummy_fns.t == arg_t, "context_Dummy_fns.t == arg_t"); } /* end Test_CFDP_RTest_CFDP_R_DispatchRecv_FlagsAreNotSetAnd_directive_code_IsLessThan_PDU_INVALID_MAX_And_fns_state_directive_code_IsAFunctionCallThatFunction */ /* end CF_CFDP_R_DispatchRecv tests */ @@ -3357,7 +3348,7 @@ void Test_CF_CFDP_R1_Recv_Runs(void) dummy_msg.ph.flags = 255; arg_t->state_data.r.sub_state = Any_uint8_LessThan(RECV_NUM_STATES); /* Any_uint8_LessThan used because small size of RECV_NUM_STATES*/ - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; arg_t->history = & dummy_history; arg_t->history->cc = CC_NO_ERROR + 1; /* CC_NO_ERROR + 1 so it does not equal in method call */ @@ -3403,7 +3394,7 @@ void Test_CF_CFDP_R2_Recv_Runs(void) dummy_msg.ph.flags = 255; arg_t->state_data.r.sub_state = Any_uint8_LessThan(RECV_NUM_STATES); /* Any_uint8_LessThan used because small size of RECV_NUM_STATES*/ - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; arg_t->history = & dummy_history; arg_t->history->cc = CC_NO_ERROR + 1; /* CC_NO_ERROR + 1 so it does not equal in method call */ @@ -3479,9 +3470,7 @@ void Test_CF_CFDP_R_Cancel_When_t_state_IsNotEqTo_CFDP_R2_And_sub_state_IsLessTh arg_t->flags.rx.send_fin); /* Assert unstubbable - CF_CFDP_R1_Reset */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 1); - UtAssert_True(context_CF_CFDP_ResetTransaction.t == arg_t, - "CF_CFDP_ResetTransaction received t %p and should be %p (t)", - context_CF_CFDP_ResetTransaction.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetTransaction.t, arg_t); UtAssert_True(context_CF_CFDP_ResetTransaction.keep_history == 1, "CF_CFDP_ResetTransaction received %d and should be 1", context_CF_CFDP_ResetTransaction.keep_history); @@ -3513,9 +3502,7 @@ void Test_CF_CFDP_R_Cancel_When_t_state_IsEqTo_CFDP_R2_And_sub_state_IsEqTo_RECV arg_t->flags.rx.send_fin); /* Assert unstubbable - CF_CFDP_R1_Reset */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 1); - UtAssert_True(context_CF_CFDP_ResetTransaction.t == arg_t, - "CF_CFDP_ResetTransaction received t %p and should be %p (t)", - context_CF_CFDP_ResetTransaction.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetTransaction.t, arg_t); UtAssert_True(context_CF_CFDP_ResetTransaction.keep_history == 1, "CF_CFDP_ResetTransaction received %d and should be 1", context_CF_CFDP_ResetTransaction.keep_history); @@ -3547,9 +3534,7 @@ void Test_CF_CFDP_R_Cancel_When_t_state_IsEqTo_CFDP_R2_And_sub_state_IsGreaterTh arg_t->flags.rx.send_fin); /* Assert unstubbable - CF_CFDP_R1_Reset */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 1); - UtAssert_True(context_CF_CFDP_ResetTransaction.t == arg_t, - "CF_CFDP_ResetTransaction received t %p and should be %p (t)", - context_CF_CFDP_ResetTransaction.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetTransaction.t, arg_t); UtAssert_True(context_CF_CFDP_ResetTransaction.keep_history == 1, "CF_CFDP_ResetTransaction received %d and should be 1", context_CF_CFDP_ResetTransaction.keep_history); @@ -3581,9 +3566,7 @@ void Test_CF_CFDP_R_Cancel_When_t_state_IsNotEqTo_CFDP_R2_And_sub_state_IsGreate arg_t->flags.rx.send_fin); /* Assert unstubbable - CF_CFDP_R1_Reset */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 1); - UtAssert_True(context_CF_CFDP_ResetTransaction.t == arg_t, - "CF_CFDP_ResetTransaction received t %p and should be %p (t)", - context_CF_CFDP_ResetTransaction.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetTransaction.t, arg_t); UtAssert_True(context_CF_CFDP_ResetTransaction.keep_history == 1, "CF_CFDP_ResetTransaction received %d and should be 1", context_CF_CFDP_ResetTransaction.keep_history); @@ -3615,7 +3598,6 @@ void Test_CF_CFDP_R_SendInactivityEvent_SendEventAndIncrement_inactivity_timer(v /* Act */ CF_CFDP_R_SendInactivityEvent(arg_t); - /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(EventID == CF_EID_ERR_CFDP_R_INACT_TIMER, @@ -3640,7 +3622,8 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsNotEqTo_CFDP_R2_And_CF_Timer_Expired_Re /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = Any_uint8_Except(CFDP_R2); @@ -3660,7 +3643,8 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsNotEqTo_CFDP_R2_And_CF_Timer_Expired_Re history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = Any_uint8_Except(CFDP_R2); @@ -3693,7 +3677,8 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_But_inactivity_fired_Is_1_ /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = CFDP_R2; @@ -3722,7 +3707,8 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_0_ /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = CFDP_R2; @@ -3754,7 +3740,8 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_0_ history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = CFDP_R2; @@ -3798,7 +3785,7 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_0_ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_1_And_send_ack_Is_1_AssertsBecause_CF_CFDP_SendAck_Returns_CF_SEND_ERROR(void) { - /* Arrange */ + // /* Arrange */ // history_t dummy_history; // transaction_t dummy_t; // transaction_t* arg_t = &dummy_t; @@ -3824,10 +3811,10 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_1_ // arg_t->history = &dummy_history; // arg_t->chan_num = Any_cf_chan_num(); - /* Act */ + // /* Act */ // CF_CFDP_R_Tick(arg_t, arg_cont); - /* Assert */ + // /* Assert */ UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - sret!=CF_SEND_ERROR"); } /* end Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_1_And_send_ack_Is_1_AssertsBecause_CF_CFDP_SendAck_Returns_CF_SEND_ERROR */ @@ -3838,7 +3825,8 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_1_ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; uint8 exceptions[2] = {CF_SEND_ERROR, CF_SEND_NO_MSG}; - int arg_cont = Any_int(); + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; CF_CFDP_SendAck_context_t context_CF_CFDP_SendAck; arg_t->state = CFDP_R2; @@ -3878,7 +3866,8 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_1_ history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; CF_CFDP_SendAck_context_t context_CF_CFDP_SendAck; arg_t->state = CFDP_R2; @@ -3917,8 +3906,8 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_1_ /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); - CF_CFDP_SendAck_context_t context_CF_CFDP_SendAck; + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = CFDP_R2; @@ -3937,10 +3926,9 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_1_ chunks_wrapper_t dummy_chunks; history_t dummy_history; pdu_nak_t dummy_nak; - pdu_header_t* dummy_ph = &dummy_nak; + pdu_header_t* dummy_ph = (pdu_header_t*)&dummy_nak; CF_CFDP_ConstructPduHeader_context_t context_CF_CFDP_ConstructPduHeader; CF_CFDP_SendNak_context_t context_CF_CFDP_SendNak; - int local_result; arg_t->history = &dummy_history; CF_AppData.config_table = &dummy_config_table; @@ -3979,8 +3967,8 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_1_ /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); - CF_CFDP_SendAck_context_t context_CF_CFDP_SendAck; + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = CFDP_R2; @@ -4027,8 +4015,8 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_1_ /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); - CF_CFDP_SendAck_context_t context_CF_CFDP_SendAck; + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = CFDP_R2; @@ -4044,7 +4032,6 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_1_ /* Arrange for CF_CFDP_R2_SubstateSendFin*/ history_t dummy_history; - int local_result; arg_t->history = &dummy_history; arg_t->history->cc = CC_NO_ERROR; @@ -4081,8 +4068,8 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_1_ /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); - CF_CFDP_SendAck_context_t context_CF_CFDP_SendAck; + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = CFDP_R2; @@ -4103,7 +4090,7 @@ void Test_CF_CFDP_R_Tick_Given_t_state_IsEqTo_CFDP_R2_And_inactivity_fired_Is_1_ arg_t->history->cc = CC_NO_ERROR; arg_t->flags.rx.crc_calc = 1; - UT_SetDefaultReturnValue(CF_CFDP_SendFin, CF_SEND_SUCCESS); + UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_SendFin), CF_SEND_SUCCESS); arg_t->state_data.r.sub_state = Any_uint8_Except(RECV_WAIT_FOR_FIN_ACK); @@ -4130,8 +4117,8 @@ void Test_CF_CFDP_R_Tick_NothingElseSet_ack_timer_armed_Is_1_CAllTo_CF_Timer_Exp /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); - CF_CFDP_SendAck_context_t context_CF_CFDP_SendAck; + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = CFDP_R2; @@ -4170,8 +4157,8 @@ void Test_CF_CFDP_R_Tick_NothingElseSet_ack_timer_armed_Is_1_CAllTo_CF_Timer_Exp /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); - CF_CFDP_SendAck_context_t context_CF_CFDP_SendAck; + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = CFDP_R2; @@ -4214,8 +4201,8 @@ void Test_CF_CFDP_R_Tick_NothingElseSet_ack_timer_armed_Is_1_CAllTo_CF_Timer_Exp /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); - CF_CFDP_SendAck_context_t context_CF_CFDP_SendAck; + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = CFDP_R2; @@ -4264,8 +4251,8 @@ void Test_CF_CFDP_R_Tick_NothingElseSet_ack_timer_armed_Is_1_CAllTo_CF_Timer_Exp /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); - CF_CFDP_SendAck_context_t context_CF_CFDP_SendAck; + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; arg_t->state = CFDP_R2; @@ -4316,9 +4303,9 @@ void Test_CF_CFDP_R_Tick_NothingElseSet_ack_timer_armed_Is_1_CAllTo_CF_Timer_Exp history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - int arg_cont = Any_int(); + int dummy_cont = Any_int(); + int* arg_cont = &dummy_cont; uint16 inital_ack_limit = Any_uint16(); - CF_CFDP_SendAck_context_t context_CF_CFDP_SendAck; arg_t->state = CFDP_R2; diff --git a/unit-test/cf_cfdp_s_tests.c b/unit-test/cf_cfdp_s_tests.c index 0647468a..f988d473 100644 --- a/unit-test/cf_cfdp_s_tests.c +++ b/unit-test/cf_cfdp_s_tests.c @@ -22,7 +22,7 @@ cfdp_send_ret_t Any_cfdp_send_ret_t(void) return random_val; } -cfdp_send_ret_t Any_cfdp_send_ret_t_ExceptThese(cfdp_send_ret_t* exceptions, uint8 num_exceptions) +cfdp_send_ret_t Any_cfdp_send_ret_t_ExceptThese(cfdp_send_ret_t exceptions[], uint8 num_exceptions) { uint8 i = 0; cfdp_send_ret_t random_val = Any_uint8_LessThan(CF_SEND_FAILURE + 1); @@ -140,9 +140,7 @@ void Test_CF_CFDP_S_ResetCall_CF_CFDP_ResetTransaction_with_keep_history(void) /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 1); - UtAssert_True(received_args.t == &arg_t, - "CF_CFDP_ResetTransaction address of t sent is %p and should be %p", - received_args.t, &arg_t); + UtAssert_ADDRESS_EQ(received_args.t, &arg_t); UtAssert_True(received_args.keep_history == 1, "CF_CFDP_ResetTransaction was sent %d as keep_history and should be 1", received_args.keep_history); @@ -183,16 +181,12 @@ void Test_CFDP_S_SendEof_When_flag_tx_crc_calc_Is_0_Call_CF_CRC_Finalize_AndSet_ "CF_CFDP_S_SendEof returned %u and should be %u (value returned from CF_CFDP_SendEof)", local_result, forced_return_CF_CFDP_SendEof); UtAssert_STUB_COUNT(CF_CRC_Finalize, 1); - UtAssert_True(context_CF_CRC_Finalize == &arg_t->crc, - "CF_CRC_Finalize received %p and should be %p (&t->crc)", - context_CF_CRC_Finalize, &arg_t->crc); + UtAssert_ADDRESS_EQ(context_CF_CRC_Finalize, &arg_t->crc); UtAssert_True(arg_t->flags.tx.crc_calc == 1, "t->flags.tx.crc_calc was changed to %d and should be 1", arg_t->flags.tx.crc_calc); UtAssert_STUB_COUNT(CF_CFDP_SendEof, 1); - UtAssert_True(context_CF_CFDP_SendEof.t == arg_t, - "CF_CFDP_SendEof received t %p and should be %p (address of passed in t)", - context_CF_CFDP_SendEof.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendEof.t, arg_t); } /* end Test_CFDP_S_SendEof_When_flag_tx_crc_calc_Is_0_Call_CF_CRC_Finalize_AndSet_crc_calc_To_1_ReturnValueOfCallTo_CF_CFDP_SendEof */ void Test_CFDP_S_SendEof_When_crc_calc_Is_1_DoNotCall_CF_CRC_Finalize_ReturnValueOfCallTo_CF_CFDP_SendEof(void) @@ -222,9 +216,7 @@ void Test_CFDP_S_SendEof_When_crc_calc_Is_1_DoNotCall_CF_CRC_Finalize_ReturnValu "t->flags.tx.crc_calc is %d and should be 1 (unchanged)", arg_t->flags.tx.crc_calc); UtAssert_STUB_COUNT(CF_CFDP_SendEof, 1); - UtAssert_True(context_CF_CFDP_SendEof.t == arg_t, - "CF_CFDP_SendEof received t %p and should be %p (address of passed in t)", - context_CF_CFDP_SendEof.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendEof.t, arg_t); } /* end Test_CFDP_S_SendEof_When_crc_calc_Is_1_DoNotCall_CF_CRC_Finalize_ReturnValueOfCallTo_CF_CFDP_SendEof */ /* end CF_CFDP_S_SendEof tests */ @@ -324,7 +316,6 @@ void Test_CF_CFDP_S2_SubstateSendEof_TriggerTickProcessing(void) /* Act */ CF_CFDP_S2_SubstateSendEof(arg_t); - /* Assert */ UtAssert_True(arg_t->state_data.s.sub_state == SEND_WAIT_FOR_EOF_ACK, "sub_state is %u and should be %u (SEND_WAIT_FOR_EOF_ACK)", @@ -333,20 +324,14 @@ void Test_CF_CFDP_S2_SubstateSendEof_TriggerTickProcessing(void) "ack_timer_armed is %u and should be 1", arg_t->flags.tx.ack_timer_armed); UtAssert_STUB_COUNT(CF_InsertSortPrio , 1); - UtAssert_True(context_CF_InsertSortPrio.t == arg_t, - "CF_InsertSortPrio received t %p and should be %p (t)", - context_CF_InsertSortPrio.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_InsertSortPrio.t, arg_t); UtAssert_True(context_CF_InsertSortPrio.q == CF_Q_TXW, "CF_InsertSortPrio received q %u and should be %u (CF_Q_TXW)", context_CF_InsertSortPrio.q, CF_Q_TXW); /* Assert for cf_dequeue_transaction */ UtAssert_STUB_COUNT(CF_CList_Remove, 1); - UtAssert_True(context_CF_CList_Remove.head == &CF_AppData.engine.channels[arg_t->chan_num].qs[arg_t->flags.all.q_index], - "CF_CList_Remove received head %p and should be %p (&CF_AppData.engine.channels[t->chan_num].qs[t->flags.all.q_index])", - context_CF_CList_Remove.head, &CF_AppData.engine.channels[arg_t->chan_num].qs[arg_t->flags.all.q_index]); - UtAssert_True(context_CF_CList_Remove.node == &arg_t->cl_node, - "CF_CList_Remove received node %p and should be %p (&t->cl_node)", - context_CF_CList_Remove.node, &arg_t->cl_node); + UtAssert_ADDRESS_EQ(context_CF_CList_Remove.head, &CF_AppData.engine.channels[arg_t->chan_num].qs[arg_t->flags.all.q_index]); + UtAssert_ADDRESS_EQ(context_CF_CList_Remove.node, &arg_t->cl_node); UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].q_size[arg_t->flags.all.q_index] == initial_q_size_q_index - 1, "q_size[t->flags.all.q_index] is %u and should be 1 less than %u (value before call)", CF_AppData.hk.channel_hk[arg_t->chan_num].q_size[arg_t->flags.all.q_index], initial_q_size_q_index); @@ -508,7 +493,6 @@ void Test_CFDP_S_SendFileData_Given_bytes_to_read_GreaterThan_outgoing_file_chun uint8 arg_calc_crc = Any_uint8(); pdu_header_t dummy_ph; pdu_header_t* forced_return_CF_CFDP_ConstructPduHeader = &dummy_ph; - uint16 dummy_chunk_size = Any_uint16(); uint32 expected_bytes_to_read = arg_bytes_to_read; int32 forced_return_CF_WrappedRead = expected_bytes_to_read; const char* expected_Spec = "CF S%d(%u:%u): error reading bytes: expected 0x%08x, got 0x%08x"; @@ -561,12 +545,10 @@ void Test_CFDP_S_SendFileData_CallTo_CF_CFDP_SendFd_Returns_CF_SEND_NO_MSG_Retur uint8 arg_calc_crc = Any_uint8(); pdu_header_t dummy_ph; pdu_header_t* forced_return_CF_CFDP_ConstructPduHeader = &dummy_ph; - uint16 dummy_chunk_size = Any_uint16(); uint32 expected_bytes_to_read = arg_bytes_to_read; int32 forced_return_CF_WrappedRead = expected_bytes_to_read; CF_CFDP_SendFd_context_t context_CF_CFDP_SendFd; - const char* expected_Spec = "CF S%d(%u:%u): error reading bytes: expected 0x%08x, got 0x%08x"; - + dummy_config_table.outgoing_file_chunk_size = arg_bytes_to_read; /* forces bytes_to_read to be greater than CF_AppData.config_table->outgoing_file_chunk_size (run if block) */ CF_AppData.config_table = &dummy_config_table; @@ -609,11 +591,10 @@ void Test_CFDP_S_SendFileData_CallTo_CF_CFDP_SendFd_Returns_CF_SEND_ERROR_SendEv uint8 arg_calc_crc = Any_uint8(); pdu_header_t dummy_ph; pdu_header_t* forced_return_CF_CFDP_ConstructPduHeader = &dummy_ph; - uint16 dummy_chunk_size = Any_uint16(); uint32 expected_bytes_to_read = arg_bytes_to_read; int32 forced_return_CF_WrappedRead = expected_bytes_to_read; - CF_CFDP_SendFd_context_t context_CF_CFDP_SendFd; const char* expected_Spec = "CF S%d(%u:%u): error sending fd"; + CF_CFDP_SendFd_context_t context_CF_CFDP_SendFd; dummy_config_table.outgoing_file_chunk_size = arg_bytes_to_read; /* forces bytes_to_read to be greater than CF_AppData.config_table->outgoing_file_chunk_size (run if block) */ CF_AppData.config_table = &dummy_config_table; @@ -668,11 +649,9 @@ void Test_CFDP_S_SendFileData_AssertsWhen_foffs_Plus_bytes_to_read_IsLessThanOrE // uint8 arg_calc_crc = Any_uint8(); // pdu_header_t dummy_ph; // pdu_header_t* forced_return_CF_CFDP_ConstructPduHeader = &dummy_ph; - // uint16 dummy_chunk_size = Any_uint16(); // uint32 expected_bytes_to_read = arg_bytes_to_read; // int32 forced_return_CF_WrappedRead = expected_bytes_to_read; // CF_CFDP_SendFd_context_t context_CF_CFDP_SendFd; - // const char* expected_Spec = "CF S%d(%u:%u): error sending fd"; // dummy_config_table.outgoing_file_chunk_size = arg_bytes_to_read; /* forces bytes_to_read to be greater than CF_AppData.config_table->outgoing_file_chunk_size (run if block) */ // CF_AppData.config_table = &dummy_config_table; @@ -697,7 +676,7 @@ void Test_CFDP_S_SendFileData_AssertsWhen_foffs_Plus_bytes_to_read_IsLessThanOrE // result = CF_CFDP_S_SendFileData(arg_t, arg_foffs, arg_bytes_to_read, arg_calc_crc); /* Assert */ - UtAssert_MIR("JIRA: GSFCCFS-1733 issue - CF_Assert((foffs+bytes_to_read)<=t->fsize); /* sanity check */"); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - CF_Assert((foffs+bytes_to_read)<=t->fsize); /* sanity check */"); // UtAssert_True(result == -1, // "CFDP_S_SendFileData returned %d and should be -1 (fail)", // result); @@ -731,13 +710,11 @@ void Test_CFDP_S_SendFileData_CallTo_CF_CFDP_SendFd_ReturnsDontCareNoCallTo_CF_C uint8 arg_calc_crc = 0; /* 0 means no calc */ pdu_header_t dummy_ph; pdu_header_t* forced_return_CF_CFDP_ConstructPduHeader = &dummy_ph; - uint16 dummy_chunk_size = Any_uint16(); uint32 expected_bytes_to_read = arg_bytes_to_read; int32 forced_return_CF_WrappedRead = expected_bytes_to_read; cfdp_send_ret_t exceptions[2] = {CF_SEND_NO_MSG, CF_SEND_ERROR}; - CF_CFDP_SendFd_context_t context_CF_CFDP_SendFd; - const char* expected_Spec = "CF S%d(%u:%u): error reading bytes: expected 0x%08x, got 0x%08x"; uint64 initial_file_data_bytes = Any_uint64(); + CF_CFDP_SendFd_context_t context_CF_CFDP_SendFd; dummy_config_table.outgoing_file_chunk_size = arg_bytes_to_read; /* forces bytes_to_read to be greater than CF_AppData.config_table->outgoing_file_chunk_size (run if block) */ CF_AppData.config_table = &dummy_config_table; @@ -787,13 +764,11 @@ void Test_CFDP_S_SendFileData_CallTo_CF_CFDP_SendFd_ReturnsDontCareWithCallTo_CF uint8 arg_calc_crc = Any_uint8_Except(0); /* any but 0 means calc */ pdu_header_t dummy_ph; pdu_header_t* forced_return_CF_CFDP_ConstructPduHeader = &dummy_ph; - uint16 dummy_chunk_size = Any_uint16(); uint32 expected_bytes_to_read = arg_bytes_to_read; int32 forced_return_CF_WrappedRead = expected_bytes_to_read; cfdp_send_ret_t exceptions[2] = {CF_SEND_NO_MSG, CF_SEND_ERROR}; - CF_CFDP_SendFd_context_t context_CF_CFDP_SendFd; - const char* expected_Spec = "CF S%d(%u:%u): error reading bytes: expected 0x%08x, got 0x%08x"; uint64 initial_file_data_bytes = Any_uint64(); + CF_CFDP_SendFd_context_t context_CF_CFDP_SendFd; dummy_config_table.outgoing_file_chunk_size = arg_bytes_to_read; /* forces bytes_to_read to be greater than CF_AppData.config_table->outgoing_file_chunk_size (run if block) */ CF_AppData.config_table = &dummy_config_table; @@ -906,8 +881,6 @@ void Test_CF_CFDP_S_SubstateSendFileData_CallTo_CFDP_S_SendFileData_ReturnsGreat cf_config_table_t dummy_config_table; pdu_header_t dummy_ph; pdu_header_t* forced_return_CF_CFDP_ConstructPduHeader = &dummy_ph; - int32 forced_return_CF_WrappedLseek = Any_uint32_Except(arg_t->foffs); - uint16 dummy_chunk_size = Any_uint16(); int32 forced_return_CF_WrappedRead = 1; cfdp_send_ret_t exceptions[2] = {CF_SEND_NO_MSG, CF_SEND_ERROR}; uint64 initial_file_data_bytes = Any_uint64(); @@ -972,8 +945,6 @@ void Test_CF_CFDP_S_SubstateSendFileData_CallTo_CFDP_S_SendFileData_ReturnsGreat cf_config_table_t dummy_config_table; pdu_header_t dummy_ph; pdu_header_t* forced_return_CF_CFDP_ConstructPduHeader = &dummy_ph; - int32 forced_return_CF_WrappedLseek = Any_uint32_Except(arg_t->foffs); - uint16 dummy_chunk_size = Any_uint16(); int32 forced_return_CF_WrappedRead = arg_t->fsize - arg_t->foffs; cfdp_send_ret_t exceptions[2] = {CF_SEND_NO_MSG, CF_SEND_ERROR}; uint64 initial_file_data_bytes = Any_uint64(); @@ -1112,15 +1083,12 @@ void Test_CF_CFDP_S_CheckAndRespondNak_SuccessBecause_CF_CFDP_SendMd_Returns_CF_ /* Act */ local_result = CF_CFDP_S_CheckAndRespondNak(arg_t); - /* Assert */ UtAssert_True(local_result == 1, "CF_CFDP_S_CheckAndRespondNak returned %d and should be 1", local_result); UtAssert_STUB_COUNT(CF_CFDP_SendMd, 1); - UtAssert_True(context_CF_CFDP_SendMd == arg_t, - "CF_CFDP_SendMd received t %p and should be %p (t)", - context_CF_CFDP_SendMd, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendMd, arg_t); UtAssert_True(arg_t->flags.tx.md_need_send == 0, "CF_CFDP_S_CheckAndRespondNak set t->flags.tx.md_need_send to %d and should be 0", arg_t->flags.tx.md_need_send); @@ -1144,15 +1112,12 @@ void Test_CF_CFDP_S_CheckAndRespondNak_DoesNothingBecause_CF_CFDP_SendMd_DoesNot /* Act */ local_result = CF_CFDP_S_CheckAndRespondNak(arg_t); - /* Assert */ UtAssert_True(local_result == 1, "CF_CFDP_S_CheckAndRespondNak returned %d and should be 1", local_result); UtAssert_STUB_COUNT(CF_CFDP_SendMd, 1); - UtAssert_True(context_CF_CFDP_SendMd == arg_t, - "CF_CFDP_SendMd received t %p and should be %p (t)", - context_CF_CFDP_SendMd, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendMd, arg_t); UtAssert_True(arg_t->flags.tx.md_need_send == 1, "CF_CFDP_S_CheckAndRespondNak did not set t->flags.tx.md_need_send %d and should be 1", arg_t->flags.tx.md_need_send); @@ -1177,7 +1142,6 @@ void Test_CF_CFDP_S_CheckAndRespondNak_DoesNothingBecause_CF_Chunks_GetFirstChun /* Act */ local_result = CF_CFDP_S_CheckAndRespondNak(arg_t); - /* Assert */ UtAssert_True(local_result == 0, "CF_CFDP_S_SendEof returned %d and should be 0", @@ -1187,9 +1151,7 @@ void Test_CF_CFDP_S_CheckAndRespondNak_DoesNothingBecause_CF_Chunks_GetFirstChun "CF_CFDP_S_CheckAndRespondNak did not set t->flags.tx.md_need_send %d and should be 0", arg_t->flags.tx.md_need_send); UtAssert_STUB_COUNT(CF_Chunks_GetFirstChunk, 1); - UtAssert_True(context_CF_Chunks_GetFirstChunk.chunks == &arg_t->chunks->chunks, - "CF_Chunks_GetFirstChunk received t %p and should be %p (&t->chunks->chunks)", - context_CF_Chunks_GetFirstChunk.chunks, &arg_t->chunks->chunks); + UtAssert_ADDRESS_EQ(context_CF_Chunks_GetFirstChunk.chunks, &arg_t->chunks->chunks); } /* end Test_CF_CFDP_S_CheckAndRespondNak_DoesNothingBecause_CF_Chunks_GetFirstChunk_Returns_NULL_Return_0 */ void Test_CF_CFDP_S_CheckAndRespondNak_CallTo_CF_Chunks_GetFirstChunkReturns_nonNULL_CallTo_CFDP_S_SendFileData_Returns_0_ThenReturn_0(void) @@ -1214,7 +1176,6 @@ void Test_CF_CFDP_S_CheckAndRespondNak_CallTo_CF_Chunks_GetFirstChunkReturns_non cf_config_table_t dummy_config_table; history_t dummy_history; pdu_header_t* forced_return_CF_CFDP_ConstructPduHeader = NULL; - int32 forced_return_CF_WrappedLseek = Any_uint32_Except(arg_t->foffs); CF_AppData.config_table = &dummy_config_table; arg_t->history = &dummy_history; @@ -1230,9 +1191,7 @@ void Test_CF_CFDP_S_CheckAndRespondNak_CallTo_CF_Chunks_GetFirstChunkReturns_non local_result); UtAssert_STUB_COUNT(CF_CFDP_SendMd, 0); UtAssert_STUB_COUNT(CF_Chunks_GetFirstChunk, 1); - UtAssert_True(context_CF_Chunks_GetFirstChunk.chunks == &arg_t->chunks->chunks, - "CF_Chunks_GetFirstChunk received t %p and should be %p (&t->chunks->chunks)", - context_CF_Chunks_GetFirstChunk.chunks, &arg_t->chunks->chunks); + UtAssert_ADDRESS_EQ(context_CF_Chunks_GetFirstChunk.chunks, &arg_t->chunks->chunks); /* Assert unstubbable:CF_CFDP_S_SendFileData */ UtAssert_STUB_COUNT(CF_CFDP_ConstructPduHeader, 1); } /* end Test_CF_CFDP_S_CheckAndRespondNak_CallTo_CF_Chunks_GetFirstChunkReturns_nonNULL_CallTo_CFDP_S_SendFileData_Returns_0_ThenReturn_0 */ @@ -1280,9 +1239,7 @@ void Test_CF_CFDP_S_CheckAndRespondNak_CallTo_CF_Chunks_GetFirstChunkReturns_non local_result); UtAssert_STUB_COUNT(CF_CFDP_SendMd, 0); UtAssert_STUB_COUNT(CF_Chunks_GetFirstChunk, 1); - UtAssert_True(context_CF_Chunks_GetFirstChunk.chunks == &arg_t->chunks->chunks, - "CF_Chunks_GetFirstChunk received t %p and should be %p (&t->chunks->chunks)", - context_CF_Chunks_GetFirstChunk.chunks, &arg_t->chunks->chunks); + UtAssert_ADDRESS_EQ(context_CF_Chunks_GetFirstChunk.chunks, &arg_t->chunks->chunks); /* Assert unstubbable:CF_CFDP_S_SendFileData */ UtAssert_STUB_COUNT(CF_CFDP_ConstructPduHeader, 1); UtAssert_STUB_COUNT(CF_WrappedLseek, 1); @@ -1317,6 +1274,8 @@ void Test_CF_CFDP_S_CheckAndRespondNak_CallTo_CF_Chunks_GetFirstChunkReturned_no cfdp_send_ret_t exceptions[2] = {CF_SEND_NO_MSG, CF_SEND_ERROR}; CF_CFDP_SendFd_context_t context_CF_CFDP_SendFd; + dummy_c->offset = 0; /* dummy_c->offset = 0 used so that (foffs+bytes_to_read)<=t->fsize is never false */ + dummy_config_table.outgoing_file_chunk_size = arg_t->foffs; CF_AppData.config_table = &dummy_config_table; arg_t->history = &dummy_history; @@ -1340,9 +1299,7 @@ void Test_CF_CFDP_S_CheckAndRespondNak_CallTo_CF_Chunks_GetFirstChunkReturned_no local_result); UtAssert_STUB_COUNT(CF_CFDP_SendMd, 0); UtAssert_STUB_COUNT(CF_Chunks_GetFirstChunk, 1); - UtAssert_True(context_CF_Chunks_GetFirstChunk.chunks == &arg_t->chunks->chunks, - "CF_Chunks_GetFirstChunk received t %p and should be %p (&t->chunks->chunks)", - context_CF_Chunks_GetFirstChunk.chunks, &arg_t->chunks->chunks); + UtAssert_ADDRESS_EQ(context_CF_Chunks_GetFirstChunk.chunks, &arg_t->chunks->chunks); UtAssert_STUB_COUNT(CF_Chunks_RemoveFromFirst, 1); /* Assert unstubbable:CF_CFDP_S_SendFileData */ UtAssert_STUB_COUNT(CF_CFDP_ConstructPduHeader, 1); @@ -1360,22 +1317,22 @@ void Test_CF_CFDP_S_CheckAndRespondNak_CallTo_CF_Chunks_GetFirstChunkReturned_no *******************************************************************************/ /* NOTE: EXAMPLE: Here is the example of what the next test would look like IFF we could stub. -** compare it to the test that had items that could not be stubbed. -void Test_CF_CFDP_S2_SubstateSendFileData_CallTo_CF_CFDP_S_CheckAndRespondNak_Returns_0_Call_CF_CFDP_S_SubstateSendFileData(void) -{ - //Arrange - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; +** compare it to the test that had items that could not be stubbed. */ +// void Test_CF_CFDP_S2_SubstateSendFileData_CallTo_CF_CFDP_S_CheckAndRespondNak_Returns_0_Call_CF_CFDP_S_SubstateSendFileData(void) +// { +// //Arrange +// transaction_t dummy_t; +// transaction_t* arg_t = &dummy_t; - UT_SetDefaultReturnValue(CF_CFDP_S_CheckAndRespondNak, 0); +// UT_SetDefaultReturnValue(CF_CFDP_S_CheckAndRespondNak, 0); - //Act - CF_CFDP_S2_SubstateSendFileData(arg_t); +// //Act +// CF_CFDP_S2_SubstateSendFileData(arg_t); - //Assert - UtAssert_STUB_COUNT(CF_CFDP_S_SubstateSendFileData, 1); - UtAssert_STUB_COUNT(CF_CFDP_S_Reset, 0); -} /* end Test_CF_CFDP_S2_SubstateSendFileData_CallTo_CF_CFDP_S_CheckAndRespondNak_Returns_0_Call_CF_CFDP_S_SubstateSendFileData */ +// //Assert +// UtAssert_STUB_COUNT(CF_CFDP_S_SubstateSendFileData, 1); +// UtAssert_STUB_COUNT(CF_CFDP_S_Reset, 0); +// } /* end Test_CF_CFDP_S2_SubstateSendFileData_CallTo_CF_CFDP_S_CheckAndRespondNak_Returns_0_Call_CF_CFDP_S_SubstateSendFileData */ void Test_CF_CFDP_S2_SubstateSendFileData_CallTo_CF_CFDP_S_CheckAndRespondNak_Returns_0_Call_CF_CFDP_S_SubstateSendFileData(void) { @@ -1419,22 +1376,22 @@ void Test_CF_CFDP_S2_SubstateSendFileData_CallTo_CF_CFDP_S_CheckAndRespondNak_Re } /* end Test_CF_CFDP_S2_SubstateSendFileData_CallTo_CF_CFDP_S_CheckAndRespondNak_Returns_0_Call_CF_CFDP_S_SubstateSendFileData */ /* NOTE: EXAMPLE: Here is the example of what the next test would look like IFF we could stub. -** compare it to the test that had items that could not be stubbed. -void Test_CF_CFDP_S2_SubstateSendFileData_CF_CFDP_S_CheckAndRespondNak_ReturnsNegativeValue_Call_CF_CFDP_S_Reset(void) -{ - //Arrange - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; +** compare it to the test that had items that could not be stubbed. */ +// void Test_CF_CFDP_S2_SubstateSendFileData_CF_CFDP_S_CheckAndRespondNak_ReturnsNegativeValue_Call_CF_CFDP_S_Reset(void) +// { +// //Arrange +// transaction_t dummy_t; +// transaction_t* arg_t = &dummy_t; - UT_SetDefaultReturnValue(CF_CFDP_S_CheckAndRespondNak, Any_int_Negative()); +// UT_SetDefaultReturnValue(CF_CFDP_S_CheckAndRespondNak, Any_int_Negative()); - //Act - CF_CFDP_S2_SubstateSendFileData(arg_t); +// //Act +// CF_CFDP_S2_SubstateSendFileData(arg_t); - //Assert - UtAssert_STUB_COUNT(CF_CFDP_S_SubstateSendFileData, 0); - UtAssert_STUB_COUNT(CF_CFDP_S_Reset, 1); -} /* end Test_CF_CFDP_S2_SubstateSendFileData_CF_CFDP_S_CheckAndRespondNak_ReturnsNegativeValue_Call_CF_CFDP_S_Reset */ +// //Assert +// UtAssert_STUB_COUNT(CF_CFDP_S_SubstateSendFileData, 0); +// UtAssert_STUB_COUNT(CF_CFDP_S_Reset, 1); +// } /* end Test_CF_CFDP_S2_SubstateSendFileData_CF_CFDP_S_CheckAndRespondNak_ReturnsNegativeValue_Call_CF_CFDP_S_Reset */ void Test_CF_CFDP_S2_SubstateSendFileData_CF_CFDP_S_CheckAndRespondNak_ReturnsNegativeValue_Call_CF_CFDP_S_Reset(void) { @@ -1443,8 +1400,6 @@ void Test_CF_CFDP_S2_SubstateSendFileData_CF_CFDP_S_CheckAndRespondNak_ReturnsNe transaction_t* arg_t = &dummy_t; /* Arrange for CF_CFDP_S_CheckAndRespondNak (get it to return a negative value)*/ - CF_Chunks_GetFirstChunk_context_t context_CF_Chunks_GetFirstChunk; - arg_t->flags.tx.md_need_send = 1; /* 1 = true */ UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_SendMd), CF_SEND_ERROR); @@ -1462,22 +1417,22 @@ void Test_CF_CFDP_S2_SubstateSendFileData_CF_CFDP_S_CheckAndRespondNak_ReturnsNe } /* end Test_CF_CFDP_S2_SubstateSendFileData_CF_CFDP_S_CheckAndRespondNak_ReturnsNegativeValue_Call_CF_CFDP_S_Reset */ /* NOTE: EXAMPLE: Here is the example of what the next test would look like IFF we could stub. -** compare it to the test that had items that could not be stubbed. -void Test_CF_CFDP_S2_SubstateSendFileData_CallTo_CF_CFDP_S_CheckAndRespondNak_ReturnsPositiveValueDoNothing(void) -{ - //Arrange - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; +** compare it to the test that had items that could not be stubbed. */ +// void Test_CF_CFDP_S2_SubstateSendFileData_CallTo_CF_CFDP_S_CheckAndRespondNak_ReturnsPositiveValueDoNothing(void) +// { +// //Arrange +// transaction_t dummy_t; +// transaction_t* arg_t = &dummy_t; - UT_SetDefaultReturnValue(CF_CFDP_S_CheckAndRespondNak, Any_int_Positive()); +// UT_SetDefaultReturnValue(CF_CFDP_S_CheckAndRespondNak, Any_int_Positive()); - //Act - CF_CFDP_S2_SubstateSendFileData(arg_t); +// //Act +// CF_CFDP_S2_SubstateSendFileData(arg_t); - //Assert - UtAssert_STUB_COUNT(CF_CFDP_S_SubstateSendFileData, 0); - UtAssert_STUB_COUNT(CF_CFDP_S_Reset, 0); -} /* end Test_CF_CFDP_S2_SubstateSendFileData_CallTo_CF_CFDP_S_CheckAndRespondNak_ReturnsPositiveValueDoNothing */ +// //Assert +// UtAssert_STUB_COUNT(CF_CFDP_S_SubstateSendFileData, 0); +// UtAssert_STUB_COUNT(CF_CFDP_S_Reset, 0); +// } /* end Test_CF_CFDP_S2_SubstateSendFileData_CallTo_CF_CFDP_S_CheckAndRespondNak_ReturnsPositiveValueDoNothing */ void Test_CF_CFDP_S2_SubstateSendFileData_CallTo_CF_CFDP_S_CheckAndRespondNak_ReturnsPositiveValueDoNothing(void) { @@ -1622,9 +1577,7 @@ void Test_CF_CFDP_S_SubstateSendMetadata_CallTo_CF_WrappedOpen_Makes_fd_LessThan // /* Assert */ UtAssert_STUB_COUNT(OS_FileOpenCheck, 1); /* TODO stub issue: check filename sent to OS_FileOpenCheck, stub does not allow this */ - UtAssert_True(context_CF_WrappedOpenCreate.fname == arg_t->history->fnames.src_filename, - "CF_WrappedOpen received fname %p and should be %p (t->history->fnames.src_filename)", - context_CF_WrappedOpenCreate.fname, arg_t->history->fnames.src_filename); + UtAssert_ADDRESS_EQ(context_CF_WrappedOpenCreate.fname, arg_t->history->fnames.src_filename); UtAssert_STUB_COUNT(CF_WrappedOpenCreate, 1); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(context_CFE_EVS_SendEvent.EventID == CF_EID_ERR_CFDP_S_OPEN, @@ -1682,9 +1635,7 @@ void Test_CF_CFDP_S_SubstateSendMetadata_FirstCallTo_CF_WrappedLseek_Sets_status /* Assert */ UtAssert_STUB_COUNT(OS_FileOpenCheck, 1); /* TODO stub issue: check filename sent to OS_FileOpenCheck, stub does not allow this */ - UtAssert_True(context_CF_WrappedOpenCreate.fname == arg_t->history->fnames.src_filename, - "CF_WrappedOpen received fname %p and should be %p (t->history->fnames.src_filename)", - context_CF_WrappedOpenCreate.fname, arg_t->history->fnames.src_filename); + UtAssert_ADDRESS_EQ(context_CF_WrappedOpenCreate.fname, arg_t->history->fnames.src_filename); UtAssert_STUB_COUNT(CF_WrappedOpenCreate, 1); UtAssert_STUB_COUNT(CF_WrappedLseek, 1); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); @@ -1742,9 +1693,7 @@ void Test_CF_CFDP_S_SubstateSendMetadata_SecondCallTo_CF_WrappedLseek_Sets_statu /* Assert */ UtAssert_STUB_COUNT(OS_FileOpenCheck, 1); /* TODO stub issue: check filename sent to OS_FileOpenCheck, stub does not allow this */ - UtAssert_True(context_CF_WrappedOpenCreate.fname == arg_t->history->fnames.src_filename, - "CF_WrappedOpen received fname %p and should be %p (t->history->fnames.src_filename)", - context_CF_WrappedOpenCreate.fname, arg_t->history->fnames.src_filename); + UtAssert_ADDRESS_EQ(context_CF_WrappedOpenCreate.fname, arg_t->history->fnames.src_filename); UtAssert_STUB_COUNT(CF_WrappedOpenCreate, 1); UtAssert_STUB_COUNT(CF_WrappedLseek, 2); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); @@ -1802,15 +1751,11 @@ void Test_CF_CFDP_S_SubstateSendMetadata_AllFileChecksPassCallTo_CF_CFDP_SendMd_ /* Assert */ UtAssert_STUB_COUNT(OS_FileOpenCheck, 1); /* TODO stub issue: check filename sent to OS_FileOpenCheck, stub does not allow this */ - UtAssert_True(context_CF_WrappedOpenCreate.fname == arg_t->history->fnames.src_filename, - "CF_WrappedOpen received fname %p and should be %p (t->history->fnames.src_filename)", - context_CF_WrappedOpenCreate.fname, arg_t->history->fnames.src_filename); + UtAssert_ADDRESS_EQ(context_CF_WrappedOpenCreate.fname, arg_t->history->fnames.src_filename); UtAssert_STUB_COUNT(CF_WrappedOpenCreate, 1); UtAssert_STUB_COUNT(CF_WrappedLseek, 2); UtAssert_STUB_COUNT(CF_CFDP_SendMd, 1); - UtAssert_True(context_CF_CFDP_SendMd == arg_t, - "CF_CFDP_SendMd received t %p and should be %p (t)", - context_CF_CFDP_SendMd, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendMd, arg_t); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(context_CFE_EVS_SendEvent.EventID == CF_EID_ERR_CFDP_S_SEND_MD, "CFE_EVS_SendEvent received EventID %u and should have received %u (CF_EID_ERR_CFDP_S_SEND_MD)", @@ -1856,9 +1801,7 @@ void Test_CF_CFDP_S_SubstateSendMetadata_BypassedFileChecks_t_fd_IsNot_0_CallTo_ UtAssert_STUB_COUNT(CF_WrappedOpenCreate, 0); UtAssert_STUB_COUNT(CF_WrappedLseek, 0); UtAssert_STUB_COUNT(CF_CFDP_SendMd, 1); - UtAssert_True(context_CF_CFDP_SendMd == arg_t, - "CF_CFDP_SendMd received t %p and should be %p (t)", - context_CF_CFDP_SendMd, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendMd, arg_t); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(context_CFE_EVS_SendEvent.EventID == CF_EID_ERR_CFDP_S_SEND_MD, "CFE_EVS_SendEvent received EventID %u and should have received %u (CF_EID_ERR_CFDP_S_SEND_MD)", @@ -1895,9 +1838,7 @@ void Test_CF_CFDP_S_SubstateSendMetadata_BypassedFileChecks_t_fd_IsNot_0_CallTo_ /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_SendMd, 1); - UtAssert_True(context_CF_CFDP_SendMd == arg_t, - "CF_CFDP_SendMd received t %p and should be %p (t)", - context_CF_CFDP_SendMd, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendMd, arg_t); UtAssert_True(arg_t->state_data.s.sub_state == SEND_FILEDATA, "sub_state set to %u and should be %u (SEND_FILEDATA)", arg_t->state_data.s.sub_state, SEND_FILEDATA); @@ -1922,12 +1863,9 @@ void Test_CF_CFDP_S_SubstateSendMetadata_BypassedFileChecks_t_fd_IsNot_0_CallTo_ /* Act */ CF_CFDP_S_SubstateSendMetadata(arg_t); - /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_SendMd, 1); - UtAssert_True(context_CF_CFDP_SendMd == arg_t, - "CF_CFDP_SendMd received t %p and should be %p (t)", - context_CF_CFDP_SendMd, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendMd, arg_t); UtAssert_True(arg_t->state_data.s.sub_state == initial_sub_state, "sub_state set to %u and should be %u (value before call)", arg_t->state_data.s.sub_state, initial_sub_state); @@ -1968,12 +1906,9 @@ void Test_CF_CFDP_S_SubstateSendFinAck_WhenCallTo_CF_CFDP_SendAck_Returns_CF_SEN /* Act */ CF_CFDP_S_SubstateSendFinAck(arg_t); - /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_SendAck, 1); - UtAssert_True(context_CF_CFDP_SendAck.t == arg_t, - "CF_CFDP_SendAck received t %p and should be %p (t)", - context_CF_CFDP_SendAck.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendAck.t, arg_t); UtAssert_True(context_CF_CFDP_SendAck.ts == ACK_TS_ACTIVE, "CF_CFDP_SendAck received ts %u and should be %u (ACK_TS_ACTIVE)", context_CF_CFDP_SendAck.ts, ACK_TS_ACTIVE); @@ -2021,12 +1956,9 @@ void Test_CF_CFDP_S_SubstateSendFinAck_WhenCallTo_CF_CFDP_SendAck_DoesNotReturn_ /* Act */ CF_CFDP_S_SubstateSendFinAck(arg_t); - /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_SendAck, 1); - UtAssert_True(context_CF_CFDP_SendAck.t == arg_t, - "CF_CFDP_SendAck received t %p and should be %p (t)", - context_CF_CFDP_SendAck.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendAck.t, arg_t); UtAssert_True(context_CF_CFDP_SendAck.ts == ACK_TS_ACTIVE, "CF_CFDP_SendAck received ts %u and should be %u (ACK_TS_ACTIVE)", context_CF_CFDP_SendAck.ts, ACK_TS_ACTIVE); @@ -2044,9 +1976,7 @@ void Test_CF_CFDP_S_SubstateSendFinAck_WhenCallTo_CF_CFDP_SendAck_DoesNotReturn_ context_CF_CFDP_SendAck.tsn, arg_t->history->seq_num); /* Assert CF_CFDP_S_Reset */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 1); - UtAssert_True(context_CF_CFDP_ResetTransaction.t == arg_t, - "CF_CFDP_ResetTransaction received t %p and should be %p (t)", - context_CF_CFDP_ResetTransaction.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetTransaction.t, arg_t); UtAssert_True(context_CF_CFDP_ResetTransaction.keep_history == 1, "CF_CFDP_ResetTransaction received keep_history %d and should be 1", context_CF_CFDP_ResetTransaction.keep_history == 1); @@ -2067,8 +1997,8 @@ void Test_CF_CFDP_S2_EarlyFin_SendEventAndCallReset(void) history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - const pdu_header_t dummy_pdu; - const pdu_header_t* arg_pdu = &dummy_pdu; + const pdu_header_t dummy_ph; + const pdu_header_t* arg_ph = &dummy_ph; const char* expected_Spec = "CF S%d(%u:%u): got early fin -- cancelling"; CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; @@ -2083,8 +2013,7 @@ void Test_CF_CFDP_S2_EarlyFin_SendEventAndCallReset(void) sizeof(context_CF_CFDP_ResetTransaction), false); /* Act */ - CF_CFDP_S2_EarlyFin(arg_t, arg_pdu); - + CF_CFDP_S2_EarlyFin(arg_t, arg_ph); /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); @@ -2099,9 +2028,7 @@ void Test_CF_CFDP_S2_EarlyFin_SendEventAndCallReset(void) context_CFE_EVS_SendEvent.Spec, expected_Spec); /* Assert CF_CFDP_S_Reset */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 1); - UtAssert_True(context_CF_CFDP_ResetTransaction.t == arg_t, - "CF_CFDP_ResetTransaction received t %p and should be %p (t)", - context_CF_CFDP_ResetTransaction.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetTransaction.t, arg_t); UtAssert_True(context_CF_CFDP_ResetTransaction.keep_history == 1, "CF_CFDP_ResetTransaction received keep_history %d and should be 1", context_CF_CFDP_ResetTransaction.keep_history == 1); @@ -2121,18 +2048,17 @@ void Test_CF_CFDP_S2_Fin_When_CF_CFDP_RecvFin_Returns_0_Set_fin_cc_And_sub_state transaction_t dummy_t; transaction_t* arg_t = &dummy_t; uint8 dummy_flags = Any_uint8(); - const pdu_header_t dummy_pdu; - const pdu_header_t* arg_pdu; + const pdu_header_t dummy_ph; + const pdu_header_t* arg_ph; uint8 expected_fin_cc = FGV(dummy_flags, PDU_FLAGS_CC); - memcpy((void*)&dummy_pdu.flags, &dummy_flags, 1); - arg_pdu = &dummy_pdu; + memcpy((void*)&dummy_ph.flags, &dummy_flags, 1); + arg_ph = &dummy_ph; UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_RecvFin), 0); /* Act */ - CF_CFDP_S2_Fin(arg_t, arg_pdu); - + CF_CFDP_S2_Fin(arg_t, arg_ph); /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_RecvFin, 1); @@ -2152,8 +2078,8 @@ void Test_CF_CFDP_S2_Fin_When_CF_CFDP_RecvFin_DoesNotReturn_0_SendEventAndCountR history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - const pdu_header_t dummy_pdu; - const pdu_header_t* arg_pdu = &dummy_pdu; + const pdu_header_t dummy_ph; + const pdu_header_t* arg_ph = &dummy_ph; uint32 initial_recv_error = Any_uint32(); const char* expected_Spec = "CF S%d(%u:%u): received invalid fin pdu"; CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; @@ -2168,8 +2094,7 @@ void Test_CF_CFDP_S2_Fin_When_CF_CFDP_RecvFin_DoesNotReturn_0_SendEventAndCountR UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); /* Act */ - CF_CFDP_S2_Fin(arg_t, arg_pdu); - + CF_CFDP_S2_Fin(arg_t, arg_ph); /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_RecvFin, 1); @@ -2204,7 +2129,7 @@ void Test_CF_CFDP_S2_Nak_CallTo_CF_CFDP_RecvNak_Returns_neg1_SendEventAndIncreme transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_ph; - const pdu_header_t* arg_ph = &dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint32 initial_recv_error = Any_uint32(); const char* expected_Spec = "CF S%d(%u:%u): received invalid nak pdu"; CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; @@ -2248,7 +2173,7 @@ void Test_CF_CFDP_S2_Nak_CallTo_CF_CFDP_RecvNak_Returns_0_Set_num_sr_to_0_SendEv transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_ph; - const pdu_header_t* arg_ph = &dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint32 initial_recv_error = Any_uint32(); const char* expected_Spec = "CF S%d(%u:%u): received invalid nak pdu"; CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; @@ -2301,7 +2226,7 @@ void Test_CF_CFDP_S2_Nak_CallTo_CF_CFDP_Sets_md_need_send_To_1_When_offset_start transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_ph; - const pdu_header_t* arg_pdu = &dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint32 initial_nak_segment_requests = Any_uint32(); int context_CF_CFDP_RecvNak_forced_num_sr = 1; @@ -2320,7 +2245,7 @@ void Test_CF_CFDP_S2_Nak_CallTo_CF_CFDP_Sets_md_need_send_To_1_When_offset_start arg_t->flags.tx.md_need_send = 0; /* setting md_need_send is not required, but assists in verification */ /* Act */ - CF_CFDP_S2_Nak(arg_t, arg_pdu); + CF_CFDP_S2_Nak(arg_t, arg_ph); /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_RecvNak, 1); @@ -2340,7 +2265,7 @@ void Test_CF_CFDP_S2_Nak_SendsEventBecause_offset_end_IsLessThan_offset_start(vo transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_ph; - const pdu_header_t* arg_ph = &dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint32 dummy_offset_start; uint32 dummy_offset_end; uint32 initial_nak_segment_requests = Any_uint32(); @@ -2398,7 +2323,7 @@ void Test_CF_CFDP_S2_Nak_SendsEventBecause_start_Plus_size_IsGreaterThanTransact transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_ph; - const pdu_header_t* arg_ph = &dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint32 dummy_offset_start; uint32 dummy_offset_end; uint32 initial_nak_segment_requests = Any_uint32(); @@ -2456,7 +2381,7 @@ void Test_CF_CFDP_S2_Nak_Calls_CF_Chunks_Add_Because_start_Plus_size_IsEqualToTr transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_ph; - const pdu_header_t* arg_ph = &dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint32 dummy_offset_start; uint32 dummy_offset_end; uint32 initial_nak_segment_requests = Any_uint32(); @@ -2496,9 +2421,7 @@ void Test_CF_CFDP_S2_Nak_Calls_CF_Chunks_Add_Because_start_Plus_size_IsEqualToTr "md_need_send is %u and should not have changed from 0", arg_t->flags.tx.md_need_send); UtAssert_STUB_COUNT(CF_Chunks_Add, 1); - UtAssert_True(context_CF_Chunks_Add.chunks == &arg_t->chunks->chunks, - "CF_Chunks_Add received chunks %p and should be %p (&t->chunks->chunks)", - context_CF_Chunks_Add.chunks, &arg_t->chunks->chunks); + UtAssert_ADDRESS_EQ(context_CF_Chunks_Add.chunks, &arg_t->chunks->chunks); UtAssert_True(context_CF_Chunks_Add.offset == dummy_offset_start, "CF_Chunks_Add received offset %u and should be %u (start)", context_CF_Chunks_Add.offset, dummy_offset_start); @@ -2515,7 +2438,7 @@ void Test_CF_CFDP_S2_Nak_Calls_CF_Chunks_Add_Because_start_Plus_size_IsLessThanT transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_nak_t dummy_ph; - const pdu_header_t* arg_ph = &dummy_ph; + pdu_header_t* arg_ph = (pdu_header_t*)&dummy_ph; uint32 dummy_offset_start; uint32 dummy_offset_end; uint32 initial_nak_segment_requests = Any_uint32(); @@ -2555,9 +2478,7 @@ void Test_CF_CFDP_S2_Nak_Calls_CF_Chunks_Add_Because_start_Plus_size_IsLessThanT "md_need_send is %u and should not have changed from 0", arg_t->flags.tx.md_need_send); UtAssert_STUB_COUNT(CF_Chunks_Add, 1); - UtAssert_True(context_CF_Chunks_Add.chunks == &arg_t->chunks->chunks, - "CF_Chunks_Add received chunks %p and should be %p (&t->chunks->chunks)", - context_CF_Chunks_Add.chunks, &arg_t->chunks->chunks); + UtAssert_ADDRESS_EQ(context_CF_Chunks_Add.chunks, &arg_t->chunks->chunks); UtAssert_True(context_CF_Chunks_Add.offset == dummy_offset_start, "CF_Chunks_Add received offset %u and should be %u (start)", context_CF_Chunks_Add.offset, dummy_offset_start); @@ -2581,8 +2502,8 @@ void Test_CF_CFDP_S2_Nak_Arm_Call_CF_CFDP_ArmAckTimer_And_CF_CFDP_S2_Nak(void) history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - const pdu_header_t dummy_pdu; - const pdu_header_t* arg_pdu = &dummy_pdu; + const pdu_header_t dummy_ph; + const pdu_header_t* arg_ph = &dummy_ph; uint32 initial_recv_error = Any_uint32(); int context_CF_CFDP_RecvNak_forced_num_sr = Any_int(); transaction_t* context_CF_CFDP_ArmAckTimer; @@ -2605,14 +2526,11 @@ void Test_CF_CFDP_S2_Nak_Arm_Call_CF_CFDP_ArmAckTimer_And_CF_CFDP_S2_Nak(void) /* Act */ - CF_CFDP_S2_Nak_Arm(arg_t, arg_pdu); - + CF_CFDP_S2_Nak_Arm(arg_t, arg_ph); /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_ArmAckTimer, 1); - UtAssert_True(context_CF_CFDP_ArmAckTimer == arg_t, - "CF_CFDP_ArmAckTimer received t %p and should be %p (t)", - context_CF_CFDP_ArmAckTimer, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ArmAckTimer, arg_t); /* Assert for CF_CFDP_S2_Nak */ UtAssert_STUB_COUNT(CF_CFDP_RecvNak, 1); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); @@ -2638,8 +2556,8 @@ void Test_CF_CFDP_S2_WaitForEofAck_CallTo_CF_CFDP_RecvAck_Returns_neg1_SendEvent history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - const pdu_header_t dummy_pdu; - const pdu_header_t* arg_pdu = &dummy_pdu; + const pdu_header_t dummy_ph; + const pdu_header_t* arg_ph = &dummy_ph; uint32 initial_recv_error = Any_uint32(); const char* expected_Spec = "CF S%d(%u:%u): received invalid eof pdu"; CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; @@ -2653,7 +2571,7 @@ void Test_CF_CFDP_S2_WaitForEofAck_CallTo_CF_CFDP_RecvAck_Returns_neg1_SendEvent CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.error = initial_recv_error; /* Act */ - CF_CFDP_S2_WaitForEofAck(arg_t, arg_pdu); + CF_CFDP_S2_WaitForEofAck(arg_t, arg_ph); /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); @@ -2678,8 +2596,8 @@ void Test_CF_CFDP_S2_WaitForEofAck_CallTo_CF_CFDP_RecvAck_Returns_0_And_t_histor history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - const pdu_header_t dummy_pdu; - const pdu_header_t* arg_pdu = &dummy_pdu; + const pdu_header_t dummy_ph; + const pdu_header_t* arg_ph = &dummy_ph; arg_t->history = &dummy_history; arg_t->history->cc = CC_NO_ERROR; @@ -2690,8 +2608,7 @@ void Test_CF_CFDP_S2_WaitForEofAck_CallTo_CF_CFDP_RecvAck_Returns_0_And_t_histor arg_t->flags.tx.ack_timer_armed = 1; /* setting ack_timer_armed not required, but helps verification */ /* Act */ - CF_CFDP_S2_WaitForEofAck(arg_t, arg_pdu); - + CF_CFDP_S2_WaitForEofAck(arg_t, arg_ph); /* Assert */ UtAssert_True(arg_t->state_data.s.sub_state == SEND_WAIT_FOR_FIN, @@ -2709,8 +2626,8 @@ void Test_CF_CFDP_S2_WaitForEofAck_CallTo_CF_CFDP_RecvAck_Returns_0_And_t_histor history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - const pdu_header_t dummy_pdu; - const pdu_header_t* arg_pdu = &dummy_pdu; + const pdu_header_t dummy_ph; + const pdu_header_t* arg_ph = &dummy_ph; arg_t->history = &dummy_history; arg_t->history->cc = Any_uint8_Except(CC_NO_ERROR); @@ -2718,7 +2635,7 @@ void Test_CF_CFDP_S2_WaitForEofAck_CallTo_CF_CFDP_RecvAck_Returns_0_And_t_histor UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_RecvAck), 0); /* 0 is pass */ /* Act */ - CF_CFDP_S2_WaitForEofAck(arg_t, arg_pdu); + CF_CFDP_S2_WaitForEofAck(arg_t, arg_ph); /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); @@ -2764,13 +2681,12 @@ void Test_CF_CFDP_S_DispatchRecv_AlreadyHas_pdu_ph_flags_SetSoSendEvent(void) { /* Arrange */ history_t dummy_history; - channel_t dummy_chan_num; pdu_r_msg_t dummy_msg; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; const char* expected_Spec = "CF S%d(%u:%u): received non-file directive pdu"; - CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; void * arg_fns = NULL; + CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; arg_t->state_data.s.sub_state = Any_uint8_LessThan(SEND_NUM_STATES); @@ -2808,8 +2724,8 @@ void Test_CF_CFDP_S_DispatchRecv_DidNotHaveFlagsSetBut_fdh_directive_code_IsEqTo uint8 dummy_flags = PDU_INVALID_MAX; uint16 initial_recv_spurious = Any_uint16(); const char* expected_Spec = "CF S%d(%u:%u): received pdu with invalid directive code %d for sub-state %d"; - CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; void * arg_fns = NULL; + CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; arg_t->state_data.s.sub_state = Any_uint8_LessThan(SEND_NUM_STATES); @@ -2855,8 +2771,8 @@ void Test_CF_CFDP_S_DispatchRecv_DidNotHaveFlagsSetBut_fdh_directive_code_IsGrea uint8 dummy_flags = Any_uint8_GreaterThan(PDU_INVALID_MAX); uint16 initial_recv_spurious = Any_uint16(); const char* expected_Spec = "CF S%d(%u:%u): received pdu with invalid directive code %d for sub-state %d"; - CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; void * arg_fns = NULL; + CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; arg_t->state_data.s.sub_state = Any_uint8_LessThan(SEND_NUM_STATES); @@ -2898,10 +2814,17 @@ void Test_CF_CFDP_S_DispatchRecv_Received_msg_ph_As_fdh_Has_flags_LessThan_PDU_I transaction_t dummy_t; transaction_t* arg_t = &dummy_t; uint8 dummy_chan_num = Any_cf_chan_num(); - uint8 dummy_sub_state = Any_uint8_LessThan(SEND_NUM_STATES); - uint8 dummy_flags = Any_uint8_LessThan(PDU_INVALID_MAX); + uint8 dummy_sub_state = 0; /* 0 = always choose Dummy_fns_CF_CFDP_S_DispatchRecv */ + uint8 dummy_flags = 0; /* 0 = always choose Dummy_fns_CF_CFDP_S_DispatchRecv */ uint16 initial_recv_spurious = Any_uint16(); - void (* arg_fns[SEND_NUM_STATES][PDU_INVALID_MAX])(transaction_t*, const pdu_header_t*); + void (* const arg_fns[SEND_NUM_STATES][PDU_INVALID_MAX])(transaction_t*, const pdu_header_t*)= { + { Dummy_fns_CF_CFDP_S_DispatchRecv, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, /* SEND_METADATA */ + { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, /* SEND_FILEDATA */ + { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, /* SEND_EOF */ + { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, /* SEND_WAIT_FOR_EOF_ACK */ + { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, /* SEND_WAIT_FOR_FIN */ + { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, /* SEND_SEND_FIN_ACK */ + }; arg_t->state_data.s.sub_state = dummy_sub_state; @@ -2914,8 +2837,6 @@ void Test_CF_CFDP_S_DispatchRecv_Received_msg_ph_As_fdh_Has_flags_LessThan_PDU_I arg_t->chan_num = dummy_chan_num; CF_AppData.hk.channel_hk[dummy_chan_num].counters.recv.spurious = initial_recv_spurious; - arg_fns[dummy_sub_state][dummy_flags] = Dummy_fns_CF_CFDP_S_DispatchRecv; - /* Act */ CF_CFDP_S_DispatchRecv(arg_t, arg_fns); @@ -2937,7 +2858,7 @@ void Test_CF_CFDP_S_DispatchRecv_Received_msg_ph_As_fdh_Has_flags_LessThan_PDU_I uint8 dummy_sub_state = Any_uint8_LessThan(SEND_NUM_STATES); uint8 dummy_flags = Any_uint8_LessThan(PDU_INVALID_MAX); uint16 initial_recv_spurious = Any_uint16(); - void (* arg_fns[SEND_NUM_STATES][PDU_INVALID_MAX])(transaction_t*, const pdu_header_t*); + void (* const arg_fns[SEND_NUM_STATES][PDU_INVALID_MAX])(transaction_t*, const pdu_header_t*) = { {NULL} }; arg_t->state_data.s.sub_state = dummy_sub_state; @@ -2950,8 +2871,6 @@ void Test_CF_CFDP_S_DispatchRecv_Received_msg_ph_As_fdh_Has_flags_LessThan_PDU_I arg_t->chan_num = dummy_chan_num; CF_AppData.hk.channel_hk[dummy_chan_num].counters.recv.spurious = initial_recv_spurious; - arg_fns[dummy_sub_state][dummy_flags] = NULL; - /* Act */ CF_CFDP_S_DispatchRecv(arg_t, arg_fns); @@ -3099,7 +3018,6 @@ void Test_CF_CFDP_S1_Tx_When_t_sub_state_Is_0_Call_CF_CFDP_S_SubstateSendMetadat /* Act */ CF_CFDP_S1_Tx(arg_t); - /* Assert */ /* Assert unstubbable: CF_CFDP_S_SubstateSendMetadata - check CF_CFDP_SendMd call */ UtAssert_STUB_COUNT(CF_CFDP_SendMd, 1); @@ -3200,7 +3118,6 @@ void Test_CF_CFDP_S2_Tx_When_t_sub_state_Is_0_Call_CF_CFDP_S_SubstateSendMetadat /* Act */ CF_CFDP_S2_Tx(arg_t); - /* Assert */ /* Assert unstubbable: CF_CFDP_S_SubstateSendMetadata - check CF_CFDP_SendMd call */ UtAssert_STUB_COUNT(CF_CFDP_SendMd, 1); @@ -3389,9 +3306,7 @@ void Test_CF_CFDP_S_Tick_CallTo_CF_TimerExpired_Returns_1_ThenSendsEventAndCalls /* Assert */ UtAssert_STUB_COUNT(CF_Timer_Expired, 1); - UtAssert_True(context_CF_Timer_Expired == &arg_t->inactivity_timer, - "CF_Timer_Expired received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Expired, &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired, &arg_t->inactivity_timer); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(context_CFE_EVS_SendEvent.EventID == CF_EID_ERR_CFDP_S_INACT_TIMER, "CFE_EVS_SendEvent received EventID %u and should have received %u (CF_EID_ERR_CFDP_S_INACT_TIMER)", @@ -3409,9 +3324,7 @@ void Test_CF_CFDP_S_Tick_CallTo_CF_TimerExpired_Returns_1_ThenSendsEventAndCalls UtAssert_STUB_COUNT(CF_Timer_Tick, 0); /* Assert CF_CFDP_S_Reset */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 1); - UtAssert_True(context_CF_CFDP_ResetTransaction.t == arg_t, - "CF_CFDP_ResetTransaction received t %p and should be %p (t)", - context_CF_CFDP_ResetTransaction.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetTransaction.t, arg_t); UtAssert_True(context_CF_CFDP_ResetTransaction.keep_history == 1, "CF_CFDP_ResetTransaction received keep_history %d and should be 1", context_CF_CFDP_ResetTransaction.keep_history == 1); @@ -3466,12 +3379,8 @@ void Test_CF_CFDP_S_Tick_ArmedTimerExpiredAnd_sub_state_EqTo_SEND_WAIT_FOR_EOF_A /* Assert */ UtAssert_STUB_COUNT(CF_Timer_Expired, 2); - UtAssert_True(context_CF_Timer_Expired[0] == &arg_t->inactivity_timer, - "CF_Timer_Expired received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Expired, &arg_t->inactivity_timer); - UtAssert_True(context_CF_Timer_Expired[1] == &arg_t->ack_timer, - "CF_Timer_Expired received t %p and should be %p (&t->ack_timer)", - context_CF_Timer_Expired, &arg_t->ack_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired[0], &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired[1], &arg_t->ack_timer); UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer == initial_inactivity_timer, "fault.inactivity_timer is %u and should not have changed from %u (value before call)", CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer, initial_inactivity_timer); @@ -3490,14 +3399,10 @@ void Test_CF_CFDP_S_Tick_ArmedTimerExpiredAnd_sub_state_EqTo_SEND_WAIT_FOR_EOF_A CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.ack_limit, initial_fault_ack_limit); UtAssert_STUB_COUNT(CF_CFDP_ArmAckTimer, 0); UtAssert_STUB_COUNT(CF_Timer_Tick, 1); - UtAssert_True(context_CF_Timer_Tick == &arg_t->inactivity_timer, - "CF_Timer_Tick received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Tick, &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Tick, &arg_t->inactivity_timer); /* Assert CF_CFDP_S_Reset */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 1); - UtAssert_True(context_CF_CFDP_ResetTransaction.t == arg_t, - "CF_CFDP_ResetTransaction received t %p and should be %p (t)", - context_CF_CFDP_ResetTransaction.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetTransaction.t, arg_t); UtAssert_True(context_CF_CFDP_ResetTransaction.keep_history == 1, "CF_CFDP_ResetTransaction received keep_history %d and should be 1", context_CF_CFDP_ResetTransaction.keep_history == 1); @@ -3554,12 +3459,8 @@ void Test_CF_CFDP_S_Tick_ArmedTimerExpiredAnd_sub_state_EqTo_SEND_WAIT_FOR_EOF_A /* Assert */ UtAssert_STUB_COUNT(CF_Timer_Expired, 2); - UtAssert_True(context_CF_Timer_Expired[0] == &arg_t->inactivity_timer, - "CF_Timer_Expired received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Expired, &arg_t->inactivity_timer); - UtAssert_True(context_CF_Timer_Expired[1] == &arg_t->ack_timer, - "CF_Timer_Expired received t %p and should be %p (&t->ack_timer)", - context_CF_Timer_Expired, &arg_t->ack_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired[0], &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired[1], &arg_t->ack_timer); UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer == initial_inactivity_timer, "fault.inactivity_timer is %u and should not have changed from %u (value before call)", CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer, initial_inactivity_timer); @@ -3569,14 +3470,10 @@ void Test_CF_CFDP_S_Tick_ArmedTimerExpiredAnd_sub_state_EqTo_SEND_WAIT_FOR_EOF_A CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.ack_limit, initial_fault_ack_limit); UtAssert_STUB_COUNT(CF_CFDP_ArmAckTimer, 0); UtAssert_STUB_COUNT(CF_Timer_Tick, 1); - UtAssert_True(context_CF_Timer_Tick == &arg_t->inactivity_timer, - "CF_Timer_Tick received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Tick, &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Tick, &arg_t->inactivity_timer); /* Assert CF_CFDP_SendEof */ UtAssert_STUB_COUNT(CF_CFDP_SendEof, 1); - UtAssert_True(context_CF_CFDP_SendEof.t == arg_t, - "CF_CFDP_SendEof received t %p and should be %p (t)", - context_CF_CFDP_SendEof.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendEof.t, arg_t); /* Assert CF_CFDP_S_Reset */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 0); } /* end Test_CF_CFDP_S_Tick_ArmedTimerExpiredAnd_sub_state_EqTo_SEND_WAIT_FOR_EOF_ACK_AndIncremented_ack_NotEqTo_ack_limit_CallTo_CFDP_S_SendEof_Return_CF_SEND_NO_MSG_CausesErrOut */ @@ -3638,12 +3535,8 @@ void Test_CF_CFDP_S_Tick_ArmedTimerExpiredAnd_sub_state_EqTo_SEND_WAIT_FOR_EOF_A /* Assert */ UtAssert_STUB_COUNT(CF_Timer_Expired, 2); - UtAssert_True(context_CF_Timer_Expired[0] == &arg_t->inactivity_timer, - "CF_Timer_Expired received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Expired, &arg_t->inactivity_timer); - UtAssert_True(context_CF_Timer_Expired[1] == &arg_t->ack_timer, - "CF_Timer_Expired received t %p and should be %p (&t->ack_timer)", - context_CF_Timer_Expired, &arg_t->ack_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired[0], &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired[1], &arg_t->ack_timer); UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer == initial_inactivity_timer, "fault.inactivity_timer is %u and should not have changed from %u (value before call)", CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer, initial_inactivity_timer); @@ -3653,19 +3546,13 @@ void Test_CF_CFDP_S_Tick_ArmedTimerExpiredAnd_sub_state_EqTo_SEND_WAIT_FOR_EOF_A CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.ack_limit, initial_fault_ack_limit); UtAssert_STUB_COUNT(CF_CFDP_ArmAckTimer, 0); UtAssert_STUB_COUNT(CF_Timer_Tick, 1); - UtAssert_True(context_CF_Timer_Tick == &arg_t->inactivity_timer, - "CF_Timer_Tick received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Tick, &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Tick, &arg_t->inactivity_timer); /* Assert CF_CFDP_SendEof */ UtAssert_STUB_COUNT(CF_CFDP_SendEof, 1); - UtAssert_True(context_CF_CFDP_SendEof.t == arg_t, - "CF_CFDP_SendEof received t %p and should be %p (t)", - context_CF_CFDP_SendEof.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendEof.t, arg_t); /* Assert CF_CFDP_S_Reset */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 1); - UtAssert_True(context_CF_CFDP_ResetTransaction.t == arg_t, - "CF_CFDP_ResetTransaction received t %p and should be %p (t)", - context_CF_CFDP_ResetTransaction.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetTransaction.t, arg_t); UtAssert_True(context_CF_CFDP_ResetTransaction.keep_history == 1, "CF_CFDP_ResetTransaction received keep_history %d and should be 1", context_CF_CFDP_ResetTransaction.keep_history == 1); @@ -3727,12 +3614,8 @@ void Test_CF_CFDP_S_Tick_ArmedTimerExpiredAnd_sub_state_EqTo_SEND_WAIT_FOR_EOF_A /* Assert */ UtAssert_STUB_COUNT(CF_Timer_Expired, 2); - UtAssert_True(context_CF_Timer_Expired[0] == &arg_t->inactivity_timer, - "CF_Timer_Expired received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Expired, &arg_t->inactivity_timer); - UtAssert_True(context_CF_Timer_Expired[1] == &arg_t->ack_timer, - "CF_Timer_Expired received t %p and should be %p (&t->ack_timer)", - context_CF_Timer_Expired, &arg_t->ack_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired[0], &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired[1], &arg_t->ack_timer); UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer == initial_inactivity_timer, "fault.inactivity_timer is %u and should not have changed from %u (value before call)", CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer, initial_inactivity_timer); @@ -3741,18 +3624,12 @@ void Test_CF_CFDP_S_Tick_ArmedTimerExpiredAnd_sub_state_EqTo_SEND_WAIT_FOR_EOF_A "fault.ack_limit was incremented to %u and should not have changed from %u (value before call)", CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.ack_limit, initial_fault_ack_limit); UtAssert_STUB_COUNT(CF_CFDP_ArmAckTimer, 1); - UtAssert_True(context_CF_CFDP_ArmAckTimer == arg_t, - "CF_CFDP_ArmAckTimer received t %p and should be %p (t)", - context_CF_CFDP_ArmAckTimer, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ArmAckTimer, arg_t); UtAssert_STUB_COUNT(CF_Timer_Tick, 1); - UtAssert_True(context_CF_Timer_Tick == &arg_t->inactivity_timer, - "CF_Timer_Tick received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Tick, &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Tick, &arg_t->inactivity_timer); /* Assert CF_CFDP_SendEof */ UtAssert_STUB_COUNT(CF_CFDP_SendEof, 1); - UtAssert_True(context_CF_CFDP_SendEof.t == arg_t, - "CF_CFDP_SendEof received t %p and should be %p (t)", - context_CF_CFDP_SendEof.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendEof.t, arg_t); /* Assert CF_CFDP_S_Reset */ UtAssert_STUB_COUNT(CF_CFDP_ResetTransaction, 0); } /* end Test_CF_CFDP_S_Tick_ArmedTimerExpiredAnd_sub_state_EqTo_SEND_WAIT_FOR_EOF_ACK_AndIncremented_ack_NotEqTo_ack_limit_CallTo_CFDP_S_SendEof_ReturnsAnythingExcept_CF_SEND_NO_MSG_Or_CF_SEND_ERROR_Call_CF_CFDP_ArmAckTimer */ @@ -3790,12 +3667,8 @@ void Test_CF_CFDP_S_Tick_ArmedTimerExpired_sub_state_NotEqTo_SEND_WAIT_FOR_EOF_A /* Assert */ UtAssert_STUB_COUNT(CF_Timer_Expired, 2); - UtAssert_True(context_CF_Timer_Expired[0] == &arg_t->inactivity_timer, - "CF_Timer_Expired received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Expired, &arg_t->inactivity_timer); - UtAssert_True(context_CF_Timer_Expired[1] == &arg_t->ack_timer, - "CF_Timer_Expired received t %p and should be %p (&t->ack_timer)", - context_CF_Timer_Expired, &arg_t->ack_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired[0], &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired[1], &arg_t->ack_timer); UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer == initial_inactivity_timer, "fault.inactivity_timer is %u and should not have changed from %u (value before call)", CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer, initial_inactivity_timer); @@ -3805,9 +3678,7 @@ void Test_CF_CFDP_S_Tick_ArmedTimerExpired_sub_state_NotEqTo_SEND_WAIT_FOR_EOF_A CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.ack_limit, initial_fault_ack_limit); UtAssert_STUB_COUNT(CF_CFDP_ArmAckTimer, 0); UtAssert_STUB_COUNT(CF_Timer_Tick, 1); - UtAssert_True(context_CF_Timer_Tick == &arg_t->inactivity_timer, - "CF_Timer_Tick received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Tick, &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Tick, &arg_t->inactivity_timer); /* Assert CF_CFDP_SendEof */ UtAssert_STUB_COUNT(CF_CFDP_SendEof, 0); /* Assert CF_CFDP_S_SubstateSendFinAck */ @@ -3846,12 +3717,8 @@ void Test_CF_CFDP_S_Tick_ArmedTimerNotExpiredCall_CF_Timer_Tick(void) /* Assert */ UtAssert_STUB_COUNT(CF_Timer_Expired, 2); - UtAssert_True(context_CF_Timer_Expired[0] == &arg_t->inactivity_timer, - "CF_Timer_Expired received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Expired, &arg_t->inactivity_timer); - UtAssert_True(context_CF_Timer_Expired[1] == &arg_t->ack_timer, - "CF_Timer_Expired received t %p and should be %p (&t->ack_timer)", - context_CF_Timer_Expired, &arg_t->ack_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired[0], &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired[1], &arg_t->ack_timer); UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer == initial_inactivity_timer, "fault.inactivity_timer is %u and should not have changed from %u (value before call)", CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer, initial_inactivity_timer); @@ -3861,12 +3728,8 @@ void Test_CF_CFDP_S_Tick_ArmedTimerNotExpiredCall_CF_Timer_Tick(void) CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.ack_limit, initial_fault_ack_limit); UtAssert_STUB_COUNT(CF_CFDP_ArmAckTimer, 0); UtAssert_STUB_COUNT(CF_Timer_Tick, 2); - UtAssert_True(context_CF_Timer_Tick[0] == &arg_t->inactivity_timer, - "CF_Timer_Tick call 1 received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Tick[0], &arg_t->inactivity_timer); - UtAssert_True(context_CF_Timer_Tick[1] == &arg_t->ack_timer, - "CF_Timer_Tick call 2 received t %p and should be %p (&t->ack_timer)", - context_CF_Timer_Tick[1], &arg_t->ack_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Tick[0], &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Tick[1], &arg_t->ack_timer); /* Assert CF_CFDP_SendEof */ UtAssert_STUB_COUNT(CF_CFDP_SendEof, 0); /* Assert CF_CFDP_S_Reset */ @@ -3904,9 +3767,7 @@ void Test_CF_CFDP_S_Tick_TimerNotArmedDoNotArmAckTimerOrDoTick(void) /* Assert */ UtAssert_STUB_COUNT(CF_Timer_Expired, 1); - UtAssert_True(context_CF_Timer_Expired == &arg_t->inactivity_timer, - "CF_Timer_Expired received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Expired, &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired, &arg_t->inactivity_timer); UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer == initial_inactivity_timer, "fault.inactivity_timer is %u and should not have changed from %u (value before call)", CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer, initial_inactivity_timer); @@ -3916,9 +3777,7 @@ void Test_CF_CFDP_S_Tick_TimerNotArmedDoNotArmAckTimerOrDoTick(void) CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.ack_limit, initial_fault_ack_limit); UtAssert_STUB_COUNT(CF_CFDP_ArmAckTimer, 0); UtAssert_STUB_COUNT(CF_Timer_Tick, 1); - UtAssert_True(context_CF_Timer_Tick == &arg_t->inactivity_timer, - "CF_Timer_Tick received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Tick, &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Tick, &arg_t->inactivity_timer); /* Assert CF_CFDP_SendEof */ UtAssert_STUB_COUNT(CF_CFDP_SendEof, 0); /* Assert CF_CFDP_S_Reset */ @@ -3966,9 +3825,7 @@ void Test_CF_CFDP_S_Tick_When_sub_state_IsEqTo_SEND_SEND_FIN_ACK_Call_CF_CFDP_S_ /* Assert */ UtAssert_STUB_COUNT(CF_Timer_Expired, 1); - UtAssert_True(context_CF_Timer_Expired == &arg_t->inactivity_timer, - "CF_Timer_Expired received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Expired, &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Expired, &arg_t->inactivity_timer); UtAssert_True(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer == initial_inactivity_timer, "fault.inactivity_timer is %u and should not have changed from %u (value before call)", CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.inactivity_timer, initial_inactivity_timer); @@ -3978,16 +3835,12 @@ void Test_CF_CFDP_S_Tick_When_sub_state_IsEqTo_SEND_SEND_FIN_ACK_Call_CF_CFDP_S_ CF_AppData.hk.channel_hk[arg_t->chan_num].counters.fault.ack_limit, initial_fault_ack_limit); UtAssert_STUB_COUNT(CF_CFDP_ArmAckTimer, 0); UtAssert_STUB_COUNT(CF_Timer_Tick, 1); - UtAssert_True(context_CF_Timer_Tick == &arg_t->inactivity_timer, - "CF_Timer_Tick received t %p and should be %p (&t->inactivity_timer)", - context_CF_Timer_Tick, &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_Tick, &arg_t->inactivity_timer); /* Assert CF_CFDP_SendEof */ UtAssert_STUB_COUNT(CF_CFDP_SendEof, 0); /* Assert CF_CFDP_S_SubstateSendFinAck */ UtAssert_STUB_COUNT(CF_CFDP_SendAck, 1); - UtAssert_True(context_CF_CFDP_SendAck.t == arg_t, - "CF_CFDP_SendAck received t %p and should be %p (t)", - context_CF_CFDP_SendAck.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_SendAck.t, arg_t); UtAssert_True(context_CF_CFDP_SendAck.ts == ACK_TS_ACTIVE, "CF_CFDP_SendAck received ts %u and should be %u (ACK_TS_ACTIVE)", context_CF_CFDP_SendAck.ts, ACK_TS_ACTIVE); diff --git a/unit-test/cf_cfdp_tests.c b/unit-test/cf_cfdp_tests.c index f6c15fb1..6037306f 100644 --- a/unit-test/cf_cfdp_tests.c +++ b/unit-test/cf_cfdp_tests.c @@ -1,4 +1,3 @@ - /* cf testing includes */ #include "cf_test_utils.h" @@ -16,7 +15,6 @@ #undef cfdp_ldst_uint32 #define cfdp_ldst_uint32(dst, src) (dst) = (src) - /* stub redefines for unit testing */ #undef FGV #define FGV Stub_FGV @@ -28,12 +26,9 @@ void cf_dequeue_transaction(transaction_t *t); #define CF_CList_InsertBack_Ex Stub_CF_CList_InsertBack_Ex void Stub_CF_CList_InsertBack_Ex(channel_t *c, cf_queue_index_t index, clist_node node); - - #include "cf_cfdp.c" #include "cf_cfdp_pdu.h" - /* cf_cfdp_tests globals */ extern type_of_context_CF_CList_Traverse_t type_of_context_CF_CList_Traverse; @@ -56,7 +51,7 @@ uint8 Any_cf_queue_index_t_Except(uint8 exception) if (num_checks >= max_checks) { - printf("Any_cf_queue_index_t_Except unable to get valid number in %u checks\n", num_checks); + UtPrintf("Any_cf_queue_index_t_Except unable to get valid number in %u checks\n", num_checks); UtAssert_Abort("Any_cf_queue_index_t_Except failed"); } else @@ -70,14 +65,14 @@ uint8 Any_cf_queue_index_t_Except(uint8 exception) } /* uint8 selected for ease of use */ -uint8 Any_cfdp_state_t() +uint8 Any_cfdp_state_t(void) { uint8 random_val = rand() % CFDP_INVALID; return random_val; } -uint8 Any_cfdp_state_t_ExceptThese(uint8* exceptions, uint8 num_exceptions) +uint8 Any_cfdp_state_t_ExceptThese(uint8 exceptions[], uint8 num_exceptions) { uint8 i = 0; @@ -94,7 +89,7 @@ uint8 Any_cfdp_state_t_ExceptThese(uint8* exceptions, uint8 num_exceptions) if (num_checks >= max_checks) { - printf("Any_cfdp_state_t_ExceptThese unable to get valid number in %u checks\n", num_checks); + UtPrintf("Any_cfdp_state_t_ExceptThese unable to get valid number in %u checks\n", num_checks); UtAssert_Abort("Any_cfdp_state_t_ExceptThese failed"); } else @@ -133,7 +128,6 @@ file_directive_t Any_file_directive_t_Except(file_directive_t exception) return rand_val; } - direction_t Any_direction_t(void) { return (direction_t)Any_uint8_LessThan(CF_DIR_NUM); @@ -157,7 +151,7 @@ void Handler_int_ForcedReturnArray(void *UserObj, UT_EntryKey_t FuncKey, const U int forced_return; uint8 array_location = UT_GetStubCount(FuncKey) - 1; - memcpy(&forced_return, (UserObj + array_location * sizeof(forced_return)), sizeof(forced_return)); + memcpy(&forced_return, ((uint8*)UserObj + array_location * sizeof(forced_return)), sizeof(forced_return)); UT_Stub_SetReturnValue(FuncKey, forced_return); } @@ -178,15 +172,14 @@ void Handler_CF_CFDP_S1_Tx_notNull_cur_AtSetCallNumber(void *UserObj, UT_EntryKe if (UT_GetStubCount(FuncKey) >= callNumberToSet_notNULL_for_CF_CFDP_S1_Tx_args_c_cur) { - args->c->cur = 0x1; + args->c->cur = CF_AppData.engine.transactions; /* args->c->cur = CF_AppData.engine.transactions is used to set to an arbitrary transaction that exists */ } } void Handler_CF_CFDP_S1_Tx_notCF_Q_TXA_q_index(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context) { - CF_CFDP_CycleTx_args_t *args = *((CF_CFDP_CycleTx_args_t **)UserObj); - transaction_t *t = *((transaction_t **)(UserObj + sizeof(void*))); + transaction_t *t = *((transaction_t **)((uint8*)UserObj + sizeof(void*))); if(UT_GetStubCount(FuncKey) > 1) { @@ -209,13 +202,6 @@ void Handler_CF_CList_Traverse_SecondCallSet_ran_one_To_1(void *UserObj, UT_Entr } } -void Handler_CF_CList_Traverse_Set_context_ToGivenUserObj(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context) -{ - trans_seq_arg_t* context = UT_Hook_GetArgValueByName(Context, "context", CF_CFDP_CycleTx_args_t*); - - context->t = (transaction_t*)UserObj; -} - void *Dummy_tick_args_t_fn(transaction_t *t, int *cont) { UT_GenStub_Execute(Dummy_tick_args_t_fn, Basic, NULL); @@ -227,7 +213,7 @@ void Handler_Dummy_tick_args_t_fn_Set_cur_notNULL(void *UserObj, UT_EntryKey_t F { transaction_t **cur = (transaction_t**)UserObj; - *cur = 1; + *cur = CF_AppData.engine.transactions; /* *cur = CF_AppData.engine.transactions is used to set to an arbitrary transaction that exists */ } void Handler_CF_CList_Traverse_Sets_args_early_exit_To_1(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context) @@ -240,9 +226,9 @@ void Handler_CF_CList_Traverse_Sets_args_early_exit_To_1(void *UserObj, UT_Entry void Handler_CF_CList_Traverse_Sets_args_cont_To_1_UntilGivenCount(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context) { tick_args_t *args = UT_Hook_GetArgValueByName(Context, "context", tick_args_t*); - int* stop_count = (int*)UserObj; + uint32 *stop_count = (uint32*)UserObj; - if (UT_GetStubCount(FuncKey) >= stop_count) + if (UT_GetStubCount(FuncKey) >= *stop_count) { args->cont = 0; @@ -343,7 +329,7 @@ void cf_cfdp_tests_Teardown(void) ** *******************************************************************************/ -void Test_CF_CFDP_ArmAckTimer_Calls_CF_Timer_InitRelSec_WithCorrectParamsAndArmsTimer(void) +void Test_CF_CFDP_ArmAckTimer_Call_CF_Timer_InitRelSec_WithCorrectParamsAndArmsTimer(void) { /* Arrange */ transaction_t dummy_t; @@ -362,45 +348,42 @@ void Test_CF_CFDP_ArmAckTimer_Calls_CF_Timer_InitRelSec_WithCorrectParamsAndArms /* Act */ CF_CFDP_ArmAckTimer(arg_t); - /* Assert */ UtAssert_STUB_COUNT(CF_Timer_InitRelSec, 1); - UtAssert_True(context_CF_Timer_InitRelSec.t == &arg_t->ack_timer, - "CF_Timer_InitRelSec received t %p and should be %p (&t->ack_timer)", - context_CF_Timer_InitRelSec.t, &arg_t->ack_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_InitRelSec.t, &arg_t->ack_timer); UtAssert_True(context_CF_Timer_InitRelSec.rel_sec == CF_AppData.config_table->ack_timer_s, "CF_Timer_InitRelSec received rel_sec %u and should be %u (CF_AppData.config_table->ack_timer_s)", context_CF_Timer_InitRelSec.rel_sec, CF_AppData.config_table->ack_timer_s); UtAssert_True(arg_t->flags.all.ack_timer_armed == 1, "CF_CFDP_ArmAckTimer set ack_timer_armed to %u and should be 1", arg_t->flags.all.ack_timer_armed); -} /* end Test_CF_CFDP_ArmAckTimer_Calls_CF_Timer_InitRelSec_WithCorrectParamsAndArmsTimer */ +} /* end Test_CF_CFDP_ArmAckTimer_Call_CF_Timer_InitRelSec_WithCorrectParamsAndArmsTimer */ /* end CF_CFDP_ArmAckTimer tests */ /******************************************************************************* ** -** CF_CFDP_GetClass tests (simple) - full coverage - 1 CF_Assert +** CF_CFDP_GetClass tests (simple) - full coverage - 1 coverage JIRA issue ** *******************************************************************************/ -void Test_CF_CFDP_GetClass_Asserts_q_index_IsEqTo_CF_Q_FREE(void) +void Test_CF_CFDP_GetClass_AssertsBecause_q_index_IsEqTo_CF_Q_FREE(void) { /* Arrange */ - transaction_t dummy_ti; - transaction_t* arg_ti = &dummy_ti; + // transaction_t dummy_ti; + // transaction_t* arg_ti = &dummy_ti; - arg_ti->flags.all.q_index = CF_Q_FREE; + // arg_ti->flags.all.q_index = CF_Q_FREE; - /* Act */ - //CF_CFDP_GetClass(arg_ti); + // /* Act */ + // //CF_CFDP_GetClass(arg_ti); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); -} /* end Test_CF_CFDP_GetClass_Asserts_q_index_IsEqTo_CF_Q_FREE */ +} /* end Test_CF_CFDP_GetClass_AssertsBecause_q_index_IsEqTo_CF_Q_FREE */ -void Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenNeitherStateIsSet(void) +void Test_CF_CFDP_GetClass_WhenNeitherStateIsSet_Return_CLASS_1(void) { /* Arrange */ uint8 excepted_states[2] = {CFDP_S2, CFDP_R2}; @@ -419,9 +402,9 @@ void Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenNeitherStateIsSet(void) UtAssert_True(local_result == CLASS_1, "CF_CFDP_GetClass returned %u and should be %u (CLASS_1)", local_result, CLASS_1); -} /* end Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenNeitherStateIsSet */ +} /* end Test_CF_CFDP_GetClass_WhenNeitherStateIsSet_Return_CLASS_1 */ -void Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenStateIs_CFDP_S2(void) +void Test_CF_CFDP_GetClass_WhenStateIs_CFDP_S2_Return_CLASS_1(void) { /* Arrange */ transaction_t dummy_ti; @@ -438,9 +421,9 @@ void Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenStateIs_CFDP_S2(void) UtAssert_True(local_result == CLASS_2, "CF_CFDP_GetClass returned %u and should be %u (CLASS_2)", local_result, CLASS_2); -} /* end Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenStateIs_CFDP_S2 */ +} /* end Test_CF_CFDP_GetClass_WhenStateIs_CFDP_S2_Return_CLASS_1 */ -void Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenStateIs_CFDP_R2(void) +void Test_CF_CFDP_GetClass_WhenStateIs_CFDP_R2_Return_CLASS_1(void) { /* Arrange */ transaction_t dummy_ti; @@ -457,32 +440,32 @@ void Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenStateIs_CFDP_R2(void) UtAssert_True(local_result == CLASS_2, "CF_CFDP_GetClass returned %u and should be %u (CLASS_2)", local_result, CLASS_2); -} /* end Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenStateIs_CFDP_S2 */ +} /* end Test_CF_CFDP_GetClass_WhenStateIs_CFDP_R2_Return_CLASS_1 */ /* end CF_CFDP_GetClass tests */ /******************************************************************************* ** -** CF_CFDP_IsSender tests (simple) - full coverage - 1 CF_Assert +** CF_CFDP_IsSender tests (simple) - full coverage - 1 coverage JIRA issue ** *******************************************************************************/ -void Test_CF_CFDP_IsSender_Asserts_q_index_IsEqTo_CF_Q_FREE(void) +void Test_CF_CFDP_IsSender_AssertsBecause_q_index_IsEqTo_CF_Q_FREE(void) { - /* Arrange */ - transaction_t dummy_ti; - transaction_t* arg_ti = &dummy_ti; + // /* Arrange */ + // transaction_t dummy_ti; + // transaction_t* arg_ti = &dummy_ti; - arg_ti->flags.all.q_index = CF_Q_FREE; + // arg_ti->flags.all.q_index = CF_Q_FREE; - /* Act */ - //CF_CFDP_IsSender(arg_ti); + // /* Act */ + // CF_CFDP_IsSender(arg_ti); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CFDP_IsSender_Asserts_q_index_IsEqTo_CF_Q_FREE */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +} /* end Test_CF_CFDP_IsSender_AssertsBecause_q_index_IsEqTo_CF_Q_FREE */ -void Test_CF_CFDP_IsSender_Returns_0_MeaningRecieverWhenNeitherStateIsSet(void) +void Test_CF_CFDP_IsSender_WhenNeitherStateIsSetReturn_0_MeaningReciever(void) { /* Arrange */ uint8 excepted_states[2] = {CFDP_S1, CFDP_S2}; @@ -501,9 +484,9 @@ void Test_CF_CFDP_IsSender_Returns_0_MeaningRecieverWhenNeitherStateIsSet(void) UtAssert_True(local_result == 0, "CF_CFDP_GetClass returned %u and should be 0 (receiver)", local_result); -} /* end Test_CF_CFDP_IsSender_Returns_0_MeaningRecieverWhenNeitherStateIsSet */ +} /* end Test_CF_CFDP_IsSender_WhenNeitherStateIsSetReturn_0_MeaningReciever */ -void Test_CF_CFDP_IsSender_Returns_1_MeaningSenderWhenStateIs_CFDP_S1(void) +void Test_CF_CFDP_IsSender_WhenStateIs_CFDP_S1_Return_1_MeaningSender(void) { /* Arrange */ transaction_t dummy_ti; @@ -520,9 +503,9 @@ void Test_CF_CFDP_IsSender_Returns_1_MeaningSenderWhenStateIs_CFDP_S1(void) UtAssert_True(local_result == 1, "CF_CFDP_GetClass returned %u and should be 1 (sender)", local_result); -} /* end Test_CF_CFDP_IsSender_Returns_1_MeaningSenderWhenStateIs_CFDP_S1 */ +} /* end Test_CF_CFDP_IsSender_WhenStateIs_CFDP_S1_Return_1_MeaningSender */ -void Test_CF_CFDP_IsSender_Returns_1_MeaningSenderWhenStateIs_CFDP_S2(void) +void Test_CF_CFDP_IsSender_WhenStateIs_CFDP_S2_Return_1_MeaningSender(void) { /* Arrange */ transaction_t dummy_ti; @@ -539,7 +522,7 @@ void Test_CF_CFDP_IsSender_Returns_1_MeaningSenderWhenStateIs_CFDP_S2(void) UtAssert_True(local_result == 1, "CF_CFDP_GetClass returned %u and should be 1 (sender)", local_result); -} /* end Test_CF_CFDP_IsSender_Returns_1_MeaningSenderWhenStateIs_CFDP_S2 */ +} /* end Test_CF_CFDP_IsSender_WhenStateIs_CFDP_S2_Return_1_MeaningSender */ /* end CF_CFDP_IsSender tests */ @@ -549,7 +532,7 @@ void Test_CF_CFDP_IsSender_Returns_1_MeaningSenderWhenStateIs_CFDP_S2(void) ** *******************************************************************************/ -void Test_CF_CFDP_ArmInactTimer_Calls_CF_Timer_InitRelSec_WithCorrectParams(void) +void Test_CF_CFDP_ArmInactTimer_Call_CF_Timer_InitRelSec_WithCorrectParams(void) { /* Arrange */ transaction_t dummy_t; @@ -566,44 +549,41 @@ void Test_CF_CFDP_ArmInactTimer_Calls_CF_Timer_InitRelSec_WithCorrectParams(void /* Act */ CF_CFDP_ArmInactTimer(arg_t); - /* Assert */ UtAssert_STUB_COUNT(CF_Timer_InitRelSec, 1); - UtAssert_True(context_CF_Timer_InitRelSec.t == &arg_t->inactivity_timer, - "CF_Timer_InitRelSec received t %p and should be %p (&t->ack_timer)", - context_CF_Timer_InitRelSec.t, &arg_t->inactivity_timer); + UtAssert_ADDRESS_EQ(context_CF_Timer_InitRelSec.t, &arg_t->inactivity_timer); UtAssert_True(context_CF_Timer_InitRelSec.rel_sec == CF_AppData.config_table->inactivity_timer_s, "CF_Timer_InitRelSec received rel_sec %u and should be %u (CF_AppData.config_table->ack_timer_s)", context_CF_Timer_InitRelSec.rel_sec, CF_AppData.config_table->inactivity_timer_s); -} /* end Test_CF_CFDP_ArmInactTimer_Calls_CF_Timer_InitRelSec_WithCorrectParams */ +} /* end Test_CF_CFDP_ArmInactTimer_Call_CF_Timer_InitRelSec_WithCorrectParams */ /* end CF_CFDP_ArmInactTimer tests */ /******************************************************************************* ** -** CF_CFDP_DispatchRecv tests (small) - full coverage - 1 CF_Assert - [unstubbables: CF_CFDP_RecvIdle, CF_CFDP_R1_Recv, CF_CFDP_S1_Recv, CF_CFDP_R2_Recv, CF_CFDP_S2_Recv, CF_CFDP_RecvDrop, CF_CFDP_ArmInactTimer] -** TODO: unstubbables for CF_CFDP_DispatchRecv tests are wrong, most of these calls are stubbable +** CF_CFDP_DispatchRecv tests (small) - full coverage - 1 coverage JIRA issue - [unstubbables: CF_CFDP_RecvIdle, CF_CFDP_R1_Recv, CF_CFDP_S1_Recv, CF_CFDP_R2_Recv, CF_CFDP_S2_Recv, CF_CFDP_RecvDrop, CF_CFDP_ArmInactTimer] +** NOTE: unstubbables for CF_CFDP_DispatchRecv tests are wrong, most of these calls are stubbable ** *******************************************************************************/ -void Test_CF_CFDP_DispatchRecv_Asserts_t_state_EqTo_CFDP_INVALID(void) +void Test_CF_CFDP_DispatchRecv_AssertsBecause_t_state_EqTo_CFDP_INVALID(void) { - /* Arrange */ - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; + // /* Arrange */ + // transaction_t dummy_t; + // transaction_t* arg_t = &dummy_t; - arg_t->state = CFDP_INVALID; + // arg_t->state = CFDP_INVALID; - /* Act */ - //CF_CFDP_DispatchRecv(arg_t); + // /* Act */ + // CF_CFDP_DispatchRecv(arg_t); - /* Assert */ - UtAssert_Failed("CF_Assert issue - t->statestatestatestatechan_num].counters.recv.dropped, initial_recv_dropped); /* Assert for CF_CFDP_ArmInactTimer */ UtAssert_STUB_COUNT(CF_Timer_InitRelSec, 1); -} /* end Test_CF_CFDP_DispatchRecv_Calls_CF_CFDP_RecvDrop_BecauseStateEq_CFDP_DROP */ +} /* end Test_CF_CFDP_DispatchRecv_WhenStateEq_CFDP_DROP_Call_CF_CFDP_RecvDrop */ /* end CF_CFDP_DispatchRecv tests */ /******************************************************************************* ** -** CF_CFDP_DispatchTx tests (small) - full coverage - 2 CF_Assert +** CF_CFDP_DispatchTx tests (small) - full coverage - 2 coverage JIRA issue ** *******************************************************************************/ -void Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_INVALID(void) +void Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_INVALID(void) { - /* Arrange */ - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; + // /* Arrange */ + // transaction_t dummy_t; + // transaction_t* arg_t = &dummy_t; - arg_t->state = CFDP_INVALID; + // arg_t->state = CFDP_INVALID; - /* Act */ - //CF_CFDP_DispatchTx(arg_t); + // /* Act */ + // CF_CFDP_DispatchTx(arg_t); - /* Assert */ - UtAssert_Failed("CF_Assert issue - t->statestatestate = CFDP_IDLE; + // arg_t->state = CFDP_IDLE; - /* Act */ - //CF_CFDP_DispatchTx(arg_t); + // /* Act */ + // CF_CFDP_DispatchTx(arg_t); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_IDLE */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +} /* end Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_IDLE */ -/* TODO: Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_R1 desired but not required */ -// void Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_R1(void) +/* TODO: Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_R1 desired but not required */ +// void Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_R1(void) // { // /* Arrange */ // transaction_t dummy_t; @@ -789,11 +769,11 @@ void Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_IDLE(void) // //CF_CFDP_DispatchTx(arg_t); // /* Assert */ -// UtAssert_Failed("CF_Assert issue"); -// } /* end Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_R1 */ +// UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +// } /* end Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_R1 */ -/* TODO: Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_R2 desired but not required */ -// void Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_R2(void) +/* TODO: Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_R2 desired but not required */ +// void Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_R2(void) // { // /* Arrange */ // transaction_t dummy_t; @@ -805,11 +785,11 @@ void Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_IDLE(void) // //CF_CFDP_DispatchTx(arg_t); // /* Assert */ -// UtAssert_Failed("CF_Assert issue"); -// } /* end Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_R2 */ +// UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +// } /* end Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_R2 */ -/* TODO: Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_DROP desired but not required */ -// void Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_DROP(void) +/* TODO: Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_DROP desired but not required */ +// void Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_DROP(void) // { // /* Arrange */ // transaction_t dummy_t; @@ -821,10 +801,10 @@ void Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_IDLE(void) // //CF_CFDP_DispatchTx(arg_t); // /* Assert */ -// UtAssert_Failed("CF_Assert issue"); -// } /* end Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_DROP */ +// UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +// } /* end Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_DROP */ -void Test_CF_CFDP_DispatchTx_Calls_CF_CFDP_S1_Tx_Because_t_state_EqTo_CFDP_S1(void) +void Test_CF_CFDP_DispatchTx_When_t_state_EqTo_CFDP_S1_Call_CF_CFDP_S1_Tx(void) { /* Arrange */ transaction_t dummy_t; @@ -839,15 +819,12 @@ void Test_CF_CFDP_DispatchTx_Calls_CF_CFDP_S1_Tx_Because_t_state_EqTo_CFDP_S1(vo /* Act */ CF_CFDP_DispatchTx(arg_t); - /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_S1_Tx, 1); - UtAssert_True(context_CF_CFDP_S1_Tx == arg_t, - "CF_CFDP_S1_Tx received t %p and should be %p (t)", - context_CF_CFDP_S1_Tx, arg_t); -} /* end Test_CF_CFDP_DispatchTx_Calls_CF_CFDP_S1_Tx_Because_t_state_EqTo_CFDP_S1 */ + UtAssert_ADDRESS_EQ(context_CF_CFDP_S1_Tx, arg_t); +} /* end Test_CF_CFDP_DispatchTx_When_t_state_EqTo_CFDP_S1_Call_CF_CFDP_S1_Tx */ -void Test_CF_CFDP_DispatchTx_Calls_CF_CFDP_S1_Tx_Because_t_state_EqTo_CFDP_S2(void) +void Test_CF_CFDP_DispatchTx_Call_When_t_state_EqTo_CFDP_S2_CF_CFDP_S1_Tx(void) { /* Arrange */ transaction_t dummy_t; @@ -862,23 +839,20 @@ void Test_CF_CFDP_DispatchTx_Calls_CF_CFDP_S1_Tx_Because_t_state_EqTo_CFDP_S2(vo /* Act */ CF_CFDP_DispatchTx(arg_t); - /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_S2_Tx, 1); - UtAssert_True(context_CF_CFDP_S2_Tx == arg_t, - "CF_CFDP_S2_Tx received t %p and should be %p (t)", - context_CF_CFDP_S2_Tx, arg_t); -} /* end Test_CF_CFDP_DispatchTx_Calls_CF_CFDP_S1_Tx_Because_t_state_EqTo_CFDP_S1 */ + UtAssert_ADDRESS_EQ(context_CF_CFDP_S2_Tx, arg_t); +} /* end Test_CF_CFDP_DispatchTx_Call_When_t_state_EqTo_CFDP_S2_CF_CFDP_S1_Tx */ /* end CF_CFDP_DispatchTx tests */ /******************************************************************************* ** -** CF_CFDP_FindUnusedChunks tests (small) - full coverage - 2 CF_Assert +** CF_CFDP_FindUnusedChunks tests (small) - full coverage - 2 coverage JIRA issue ** *******************************************************************************/ -void Test_CF_CFDP_FindUnusedChunks_Asserts_dir_IsEq_CF_DIR_NUM(void) +void Test_CF_CFDP_FindUnusedChunks_AssertsBecause_dir_IsEq_CF_DIR_NUM(void) { /* Arrange */ // channel_t dummy_c; @@ -889,11 +863,11 @@ void Test_CF_CFDP_FindUnusedChunks_Asserts_dir_IsEq_CF_DIR_NUM(void) //CF_CFDP_FindUnusedChunks(arg_c, arg_dir); /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CFDP_FindUnusedChunks_Asserts_dir_IsEq_CF_DIR_NUM */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +} /* end Test_CF_CFDP_FindUnusedChunks_AssertsBecause_dir_IsEq_CF_DIR_NUM */ -/* TODO: Test_CF_CFDP_FindUnusedChunks_Asserts_dir_IsGreaterThan_CF_DIR_NUM desired but not required */ -// void Test_CF_CFDP_FindUnusedChunks_Asserts_dir_IsGreaterThan_CF_DIR_NUM(void) +/* TODO: Test_CF_CFDP_FindUnusedChunks_AssertsBecause_dir_IsGreaterThan_CF_DIR_NUM desired but not required */ +// void Test_CF_CFDP_FindUnusedChunks_AssertsBecause_dir_IsGreaterThan_CF_DIR_NUM(void) // { // /* Arrange */ // // channel_t dummy_c; @@ -904,10 +878,10 @@ void Test_CF_CFDP_FindUnusedChunks_Asserts_dir_IsEq_CF_DIR_NUM(void) // //CF_CFDP_FindUnusedChunks(arg_c, arg_dir); // /* Assert */ -// UtAssert_Failed("CF_Assert issue"); -// } /* end Test_CF_CFDP_FindUnusedChunks_Asserts_dir_IsGreaterThan_CF_DIR_NUM */ +// UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +// } /* end Test_CF_CFDP_FindUnusedChunks_AssertsBecause_dir_IsGreaterThan_CF_DIR_NUM */ -void Test_CF_CFDP_FindUnusedChunks_Asserts_c_cs_dir_IsNull(void) +void Test_CF_CFDP_FindUnusedChunks_AssertsBecause_c_cs_dir_IsNull(void) { /* Arrange */ // channel_t dummy_c; @@ -920,8 +894,8 @@ void Test_CF_CFDP_FindUnusedChunks_Asserts_c_cs_dir_IsNull(void) //CF_CFDP_FindUnusedChunks(arg_c, arg_dir); /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CFDP_FindUnusedChunks_Asserts_c_cs_dir_IsNull */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +} /* end Test_CF_CFDP_FindUnusedChunks_AssertsBecause_c_cs_dir_IsNull */ void Test_CF_CFDP_FindUnusedChunks_Success(void) { @@ -945,62 +919,57 @@ void Test_CF_CFDP_FindUnusedChunks_Success(void) /* Act */ local_result = CF_CFDP_FindUnusedChunks(arg_c, arg_dir); - /* Assert */ - UtAssert_True(local_result == expected_result, - "CF_CFDP_FindUnusedChunks returned %p and should be %p (chunks_wrapper_t that contains c->cs[dir])", - local_result, expected_result); + UtAssert_ADDRESS_EQ(local_result, expected_result); UtAssert_STUB_COUNT(CF_CList_Pop, 1); - UtAssert_True(context_CF_CList_Pop.head == &arg_c->cs[arg_dir], - "CF_CList_Pop received head %p and should be %p (c->cs[dir])", - context_CF_CList_Pop.head, &arg_c->cs[arg_dir]); + UtAssert_ADDRESS_EQ(context_CF_CList_Pop.head, &arg_c->cs[arg_dir]); } /* end Test_CF_CFDP_FindUnusedChunks_Success */ /* end CF_CFDP_FindUnusedChunks tests */ /******************************************************************************* ** -** CF_CFDP_FindUnusedTransaction tests (large) - full coverage - 3 CF_Assert - [unstubbables: CF_CList_Remove_Ex] +** CF_CFDP_FindUnusedTransaction tests (large) - full coverage - 3 coverage JIRA issue - [unstubbables: CF_CList_Remove_Ex] ** *******************************************************************************/ -void Test_CF_CFDP_FindUnusedTransaction_Asserts_c_IsNull(void) +void Test_CF_CFDP_FindUnusedTransaction_AssertsBecause_c_IsNull(void) { - /* Arrange */ + // /* Arrange */ // channel_t* arg_c; - /* Act */ - //CF_CFDP_FindUnusedTransaction(arg_c); + // /* Act */ + // CF_CFDP_FindUnusedTransaction(arg_c); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CFDP_FindUnusedTransaction_ReturnsNullBecauseNoFreeTransactionsAreAvailable */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +} /* end Test_CF_CFDP_FindUnusedTransaction_WhenNoFreeTransactionsAreAvailableReturn_NULL */ -void Test_CF_CFDP_FindUnusedTransaction_Asserts_q_size_CF_Q_HIST_IsNotLessThan_CF_NUM_HISTORIES_PER_CHANNEL(void) +void Test_CF_CFDP_FindUnusedTransaction_AssertsBecause_q_size_CF_Q_HIST_IsNotLessThan_CF_NUM_HISTORIES_PER_CHANNEL(void) { - /* Arrange */ + // /* Arrange */ // channel_t* arg_c; - /* Act */ - //CF_CFDP_FindUnusedTransaction(arg_c); + // /* Act */ + // CF_CFDP_FindUnusedTransaction(arg_c); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CFDP_FindUnusedTransaction_Asserts_q_size_CF_Q_HIST_IsNotLessThan_CF_NUM_HISTORIES_PER_CHANNEL */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +} /* end Test_CF_CFDP_FindUnusedTransaction_AssertsBecause_q_size_CF_Q_HIST_IsNotLessThan_CF_NUM_HISTORIES_PER_CHANNEL */ -void Test_CF_CFDP_FindUnusedTransaction_Asserts_c_qs_CF_Q_HIST_IsNull(void) +void Test_CF_CFDP_FindUnusedTransaction_AssertsBecause_c_qs_CF_Q_HIST_IsNull(void) { - /* Arrange */ + // /* Arrange */ // channel_t* arg_c; - /* Act */ - //CF_CFDP_FindUnusedTransaction(arg_c); + // /* Act */ + // CF_CFDP_FindUnusedTransaction(arg_c); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CFDP_FindUnusedTransaction_Asserts_c_qs_CF_Q_HIST_IsNull */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +} /* end Test_CF_CFDP_FindUnusedTransaction_AssertsBecause_c_qs_CF_Q_HIST_IsNull */ -void Test_CF_CFDP_FindUnusedTransaction_ReturnsNullBecauseNoFreeTransactionsAreAvailable(void) +void Test_CF_CFDP_FindUnusedTransaction_WhenNoFreeTransactionsAreAvailableReturn_NULL(void) { /* Arrange */ channel_t dummy_c; @@ -1013,13 +982,11 @@ void Test_CF_CFDP_FindUnusedTransaction_ReturnsNullBecauseNoFreeTransactionsAreA local_result = CF_CFDP_FindUnusedTransaction(arg_c); /* Assert */ - UtAssert_True(local_result == NULL, - "CF_CFDP_FindUnusedTransaction returned %p and should be %p (NULL, no free transactions)", - local_result, NULL); + UtAssert_ADDRESS_EQ(local_result, NULL); -} /* end Test_CF_CFDP_FindUnusedTransaction_ReturnsNullBecauseNoFreeTransactionsAreAvailable */ +} /* end Test_CF_CFDP_FindUnusedTransaction_WhenNoFreeTransactionsAreAvailableReturn_NULL */ -void Test_CF_CFDP_FindUnusedTransaction_ReturnsExpected_t_WhenNoFreeHistory(void) +void Test_CF_CFDP_FindUnusedTransaction_WhenNoFreeHistoryReturnExpected_t(void) { /* Arrange */ channel_t* arg_c; @@ -1048,18 +1015,14 @@ void Test_CF_CFDP_FindUnusedTransaction_ReturnsExpected_t_WhenNoFreeHistory(void local_result = CF_CFDP_FindUnusedTransaction(arg_c); /* Assert */ - UtAssert_True(local_result == expected_t, - "CF_CFDP_FindUnusedTransaction returned %p and should be %p (t)", - local_result, expected_t); - UtAssert_True(local_result->history == &dummy_history, - "CF_CFDP_FindUnusedTransaction set t->history to %p and should be %p (c->qs[CF_Q_HIST]'s container)", - local_result, &dummy_history); + UtAssert_ADDRESS_EQ(local_result, expected_t); + UtAssert_ADDRESS_EQ(local_result->history, &dummy_history); UtAssert_True(local_result->history->dir == CF_DIR_NUM, "CF_CFDP_FindUnusedTransaction set t->history->dir to %u and should be %u (CF_DIR_NUM - no direction)", local_result->history->dir, CF_DIR_NUM); -} /* end Test_CF_CFDP_FindUnusedTransaction_ReturnsExpected_t_WhenNoFreeHistory */ +} /* end Test_CF_CFDP_FindUnusedTransaction_WhenNoFreeHistoryReturnExpected_t */ -void Test_CF_CFDP_FindUnusedTransaction_ReturnsExpected_t_WhenFreeHistory(void) +void Test_CF_CFDP_FindUnusedTransaction_WhenFreeHistoryReturnExpected_t(void) { /* Arrange */ channel_t* arg_c; @@ -1090,16 +1053,12 @@ void Test_CF_CFDP_FindUnusedTransaction_ReturnsExpected_t_WhenFreeHistory(void) local_result = CF_CFDP_FindUnusedTransaction(arg_c); /* Assert */ - UtAssert_True(local_result == expected_t, - "CF_CFDP_FindUnusedTransaction returned %p and should be %p (t)", - local_result, expected_t); - UtAssert_True(local_result->history == &dummy_history, - "CF_CFDP_FindUnusedTransaction set t->history to %p and should be %p (c->qs[CF_Q_HIST]'s container)", - local_result, &dummy_history); + UtAssert_ADDRESS_EQ(local_result, expected_t); + UtAssert_ADDRESS_EQ(local_result->history, &dummy_history); UtAssert_True(local_result->history->dir == CF_DIR_NUM, "CF_CFDP_FindUnusedTransaction set t->history->dir to %u and should be %u (CF_DIR_NUM - no direction)", local_result->history->dir, CF_DIR_NUM); -} /* end Test_CF_CFDP_FindUnusedTransaction_ReturnsExpected_t_WhenFreeHistory */ +} /* end Test_CF_CFDP_FindUnusedTransaction_WhenFreeHistoryReturnExpected_t */ /* end CF_CFDP_FindUnusedTransaction tests */ @@ -1109,17 +1068,15 @@ void Test_CF_CFDP_FindUnusedTransaction_ReturnsExpected_t_WhenFreeHistory(void) ** *******************************************************************************/ -void Test_CF_CFDP_ResetHistory_Calls_CF_CList_Remove_Ex_And_CF_CList_InsertBack_Ex_WithCorrectParams(void) +void Test_CF_CFDP_ResetHistory_Call_CF_CList_Remove_Ex_And_CF_CList_InsertBack_Ex_WithCorrectParams(void) { /* Arrange */ channel_t* arg_c; uint8 dummy_channel = Any_uint8_LessThan(CF_NUM_CHANNELS); - clist_node_t dummy_history_cl_node; history_t dummy_h; history_t* arg_h = &dummy_h; arg_c = &CF_AppData.engine.channels[dummy_channel]; - arg_h->cl_node = dummy_history_cl_node; /* Arrange unstubbable: CF_CList_Remove_Ex */ uint16 inital_q_size_HIST = Any_uint16_Except(0); @@ -1144,17 +1101,13 @@ void Test_CF_CFDP_ResetHistory_Calls_CF_CList_Remove_Ex_And_CF_CList_InsertBack_ /* Assert */ /* Assert for CF_CList_Remove */ - UtAssert_True(context_CF_CList_Remove.head == &arg_c->qs[CF_Q_HIST], - "CF_CList_Remove received head %p and should be %p (&c->qs[index])", - context_CF_CList_Remove.head, &arg_c->qs[CF_Q_HIST]); - UtAssert_True(context_CF_CList_Remove.node == &arg_h->cl_node, - "CF_CList_Remove received node %p and should be %p (&h->cl_node)", - context_CF_CList_Remove.node, &arg_h->cl_node); + UtAssert_ADDRESS_EQ(context_CF_CList_Remove.head, &arg_c->qs[CF_Q_HIST]); + UtAssert_ADDRESS_EQ(context_CF_CList_Remove.node, &arg_h->cl_node); UtAssert_True(CF_AppData.hk.channel_hk[arg_c-CF_AppData.engine.channels].q_size[CF_Q_HIST] == inital_q_size_HIST - 1, "q_size[CF_Q_HIST] is %u and should be 1 less than %u (value before call)", CF_AppData.hk.channel_hk[arg_c-CF_AppData.engine.channels].q_size[CF_Q_HIST], inital_q_size_HIST - 1); UtAssert_STUB_COUNT(CF_CList_InsertBack_Ex, 1); -} /* end Test_CF_CFDP_ResetHistory_Calls_CF_CList_Remove_Ex_And_CF_CList_InsertBack_Ex_WithCorrectParams */ +} /* end Test_CF_CFDP_ResetHistory_Call_CF_CList_Remove_Ex_And_CF_CList_InsertBack_Ex_WithCorrectParams */ /* end CF_CFDP_ResetHistory tests */ @@ -1164,7 +1117,7 @@ void Test_CF_CFDP_ResetHistory_Calls_CF_CList_Remove_Ex_And_CF_CList_InsertBack_ ** *******************************************************************************/ -void Test_CF_CFDP_FreeTransaction_Calls_CF_CList_InitNode_And_CF_CList_InsertBack_Ex_WithCorrectParams(void) +void Test_CF_CFDP_FreeTransaction_Call_CF_CList_InitNode_And_CF_CList_InsertBack_Ex_WithCorrectParams(void) { /* Arrange */ transaction_t dummy_t; @@ -1192,11 +1145,9 @@ void Test_CF_CFDP_FreeTransaction_Calls_CF_CList_InitNode_And_CF_CList_InsertBac /* Assert */ UtAssert_STUB_COUNT(CF_CList_InitNode, 1); - UtAssert_True(context_CF_CList_InitNode == &arg_t->cl_node, - "CF_CList_InitNode received node %p and should be %p (&t->cl_node)", - context_CF_CList_InitNode, &arg_t->cl_node); + UtAssert_ADDRESS_EQ(context_CF_CList_InitNode, &arg_t->cl_node); UtAssert_STUB_COUNT(CF_CList_InsertBack_Ex, 1); -} /* end Test_CF_CFDP_FreeTransaction_Calls_CF_CList_InitNode_And_CF_CList_InsertBack_Ex_WithCorrectParams */ +} /* end Test_CF_CFDP_FreeTransaction_Call_CF_CList_InitNode_And_CF_CList_InsertBack_Ex_WithCorrectParams */ /* end CF_CFDP_FreeTransaction tests */ @@ -1206,7 +1157,7 @@ void Test_CF_CFDP_FreeTransaction_Calls_CF_CList_InitNode_And_CF_CList_InsertBac ** *******************************************************************************/ -void Test_CF_CFDP_FindTransactionBySequenceNumber__DoesNotFindTransaction_context_src_eid_NotEq_history_src_eid(void) +void Test_CF_CFDP_FindTransactionBySequenceNumber__When_context_src_eid_NotEq_history_src_eid_DoNotFindTransaction(void) { /* Arrange */ clist_node arg_n; @@ -1229,9 +1180,9 @@ void Test_CF_CFDP_FindTransactionBySequenceNumber__DoesNotFindTransaction_contex UtAssert_True(local_result == 0, "CF_CFDP_FindTransactionBySequenceNumber_ returned %d and should be 0 (Not found)", local_result); -} /* end Test_CF_CFDP_FindTransactionBySequenceNumber__DoesNotFindTransaction_context_src_eid_NotEq_history_src_eid */ +} /* end Test_CF_CFDP_FindTransactionBySequenceNumber__When_context_src_eid_NotEq_history_src_eid_DoNotFindTransaction */ -void Test_CF_CFDP_FindTransactionBySequenceNumber__DoesNotFindTransaction_context_transaction_sequence_number_NotEq_history_seq_num(void) +void Test_CF_CFDP_FindTransactionBySequenceNumber__When_context_transaction_sequence_number_NotEq_history_seq_num_DoNotFindTransaction(void) { /* Arrange */ clist_node arg_n; @@ -1257,9 +1208,9 @@ void Test_CF_CFDP_FindTransactionBySequenceNumber__DoesNotFindTransaction_contex UtAssert_True(local_result == 0, "CF_CFDP_FindTransactionBySequenceNumber_ returned %d and should be 0 (Not found)", local_result); -} /* end Test_CF_CFDP_FindTransactionBySequenceNumber__DoesNotFindTransaction_context_transaction_sequence_number_NotEq_history_seq_num */ +} /* end Test_CF_CFDP_FindTransactionBySequenceNumber__When_context_transaction_sequence_number_NotEq_history_seq_num_DoNotFindTransaction */ -void Test_CF_CFDP_FindTransactionBySequenceNumber__FindsTransaction_history_And_context_Match_src_eid_And_seq_num(void) +void Test_CF_CFDP_FindTransactionBySequenceNumber__When_history_And_context_Match_src_eid_And_seq_num_FindTransaction(void) { /* Arrange */ clist_node arg_n; @@ -1285,7 +1236,7 @@ void Test_CF_CFDP_FindTransactionBySequenceNumber__FindsTransaction_history_And_ UtAssert_True(local_result == 1, "CF_CFDP_FindTransactionBySequenceNumber_ returned %d and should be 1 (Found)", local_result); -} /* end Test_CF_CFDP_FindTransactionBySequenceNumber__FindsTransaction_history_And_context_Match_src_eid_And_seq_num */ +} /* end Test_CF_CFDP_FindTransactionBySequenceNumber__When_history_And_context_Match_src_eid_And_seq_num_FindTransaction */ /* end CF_CFDP_FindTransactionBySequenceNumber_ tests */ @@ -1295,7 +1246,7 @@ void Test_CF_CFDP_FindTransactionBySequenceNumber__FindsTransaction_history_And_ ** *******************************************************************************/ -void Test_CF_CFDP_FindTransactionBySequenceNumber_DoesNotFindTransaction(void) +void Test_CF_CFDP_FindTransactionBySequenceNumber_DoNotFindTransaction(void) { /* Arrange */ channel_t dummy_c; @@ -1323,18 +1274,12 @@ void Test_CF_CFDP_FindTransactionBySequenceNumber_DoesNotFindTransaction(void) CF_CFDP_FindTransactionBySequenceNumber(arg_c, arg_transaction_sequence_number, arg_src_eid); /* Assert */ - UtAssert_True(local_result == NULL, - "CF_CFDP_FindTransactionBySequenceNumber returned %p and should be %p (NULL)", - local_result, NULL); + UtAssert_ADDRESS_EQ(local_result, NULL); UtAssert_STUB_COUNT(CF_CList_Traverse, NUM_CLISTS); for(i = 0; i < NUM_CLISTS; ++i) { - UtAssert_True(context_CF_CList_Traverse[i].start == expected_ptrs[i], - "CF_CList_Traverse call %d received start %p and should be %p (ptrs[%d])", - i, context_CF_CList_Traverse[i].start, expected_ptrs[i], i); - UtAssert_True(context_CF_CList_Traverse[i].fn == (clist_fn_t)CF_CFDP_FindTransactionBySequenceNumber_, - "CF_CList_Traverse received fn %p and should be %p (CF_CFDP_FindTransactionBySequenceNumber_)", - context_CF_CList_Traverse[i].fn, CF_CFDP_FindTransactionBySequenceNumber_); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse[i].start, expected_ptrs[i]); + UtAssert_True(context_CF_CList_Traverse[i].fn == (clist_fn_t)CF_CFDP_FindTransactionBySequenceNumber_, "context_CF_CList_Traverse[i].fn == (clist_fn_t)CF_CFDP_FindTransactionBySequenceNumber_"); UtAssert_True(context_CF_CList_Traverse[i].context_transaction_sequence_number == arg_transaction_sequence_number, "CF_CList_Traverse received context.transaction_sequence_number %u and should be %u (transaction_sequence_number)", context_CF_CList_Traverse[i].context_transaction_sequence_number, arg_transaction_sequence_number); @@ -1342,9 +1287,9 @@ void Test_CF_CFDP_FindTransactionBySequenceNumber_DoesNotFindTransaction(void) "CF_CList_Traverse received context.context_src_eid %u and should be %u (src_eid)", context_CF_CList_Traverse[i].context_src_eid, arg_src_eid); } -} /* end Test_CF_CFDP_FindTransactionBySequenceNumber_DoesNotFindTransaction */ +} /* end Test_CF_CFDP_FindTransactionBySequenceNumber_DoNotFindTransaction */ -void Test_CF_CFDP_FindTransactionBySequenceNumber_FindsTransactionOnLastClist(void) +void Test_CF_CFDP_FindTransactionBySequenceNumber_FindTransactionOnLastClist(void) { /* Arrange */ channel_t dummy_c; @@ -1376,18 +1321,12 @@ void Test_CF_CFDP_FindTransactionBySequenceNumber_FindsTransactionOnLastClist(vo CF_CFDP_FindTransactionBySequenceNumber(arg_c, arg_transaction_sequence_number, arg_src_eid); /* Assert */ - UtAssert_True(local_result == expected_result, - "CF_CFDP_FindTransactionBySequenceNumber returned %p and should be %p (ctx.t)", - local_result, expected_result); + UtAssert_ADDRESS_EQ(local_result, expected_result); UtAssert_STUB_COUNT(CF_CList_Traverse, NUM_CLISTS); for(i = 0; i < NUM_CLISTS; ++i) { - UtAssert_True(context_CF_CList_Traverse[i].start == expected_ptrs[i], - "CF_CList_Traverse call %d received start %p and should be %p (ptrs[%d])", - i, context_CF_CList_Traverse[i].start, expected_ptrs[i], i); - UtAssert_True(context_CF_CList_Traverse[i].fn == (clist_fn_t)CF_CFDP_FindTransactionBySequenceNumber_, - "CF_CList_Traverse received fn %p and should be %p (CF_CFDP_FindTransactionBySequenceNumber_)", - context_CF_CList_Traverse[i].fn, CF_CFDP_FindTransactionBySequenceNumber_); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse[i].start, expected_ptrs[i]); + UtAssert_True(context_CF_CList_Traverse[i].fn == (clist_fn_t)CF_CFDP_FindTransactionBySequenceNumber_, "context_CF_CList_Traverse[i].fn == (clist_fn_t)CF_CFDP_FindTransactionBySequenceNumber_"); UtAssert_True(context_CF_CList_Traverse[i].context_transaction_sequence_number == arg_transaction_sequence_number, "CF_CList_Traverse received context.transaction_sequence_number %u and should be %u (transaction_sequence_number)", context_CF_CList_Traverse[i].context_transaction_sequence_number, arg_transaction_sequence_number); @@ -1395,13 +1334,13 @@ void Test_CF_CFDP_FindTransactionBySequenceNumber_FindsTransactionOnLastClist(vo "CF_CList_Traverse received context.context_src_eid %u and should be %u (src_eid)", context_CF_CList_Traverse[i].context_src_eid, arg_src_eid); } -} /* end Test_CF_CFDP_FindTransactionBySequenceNumber_FindsTransactionOnLastClist */ +} /* end Test_CF_CFDP_FindTransactionBySequenceNumber_FindTransactionOnLastClist */ /* end CF_CFDP_FindTransactionBySequenceNumber tests */ /******************************************************************************* ** -** CF_CFDP_MsgOutGet tests (large) - full coverage - 1 JIRA Issue [] +** CF_CFDP_MsgOutGet tests (large) - full coverage - 1 coverage JIRA Issue - [] ** *******************************************************************************/ @@ -1417,7 +1356,7 @@ void Test_CF_CFDP_MsgOutGet_When_CF_AppData_engine_out_msg_Is_notNULL_ReturnPoin arg_t->chan_num = Any_cf_chan_num(); - CF_AppData.engine.out.msg = &dummy_msg; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_msg; CF_AppData.engine.outgoing_counter = initial_outgoing_counter; @@ -1455,8 +1394,8 @@ void Test_CF_CFDP_MsgOutGet_WhenChannel_max_outgoing_messages_per_wakeup_Is_0_An local_result = CF_CFDP_MsgOutGet(arg_t, arg_silent); /* Assert */ - UtAssert_Failed("JIRA ISSUE: GSFCCFS-1726 - Does not return NULL when it should, returns 0x10 (&((pdu_s_msg_t*)NULL)->ph"); - UtPrintf("The returned value is %p", local_result); + UtAssert_MIR("JIRA: GSFCCFS-1726 No coverage impact - Does not return NULL when it should, returns 0x10 (&((pdu_s_msg_t*)NULL)->ph"); + UtPrintf("The returned value is %p", (void*)local_result); // UtAssert_NULL(local_result); UtAssert_True(CF_AppData.engine.outgoing_counter == initial_outgoing_counter, "outgoing_counter is now %u and should not have changed from %u (value before call)", @@ -1489,8 +1428,8 @@ void Test_CF_CFDP_MsgOutGet_When_outgoing_counter_DoesNotEq_max_outgoing_message local_result = CF_CFDP_MsgOutGet(arg_t, arg_silent); /* Assert */ - UtAssert_Failed("JIRA ISSUE: GSFCCFS-1726 - Does not return NULL when it should, returns 0x10 (&((pdu_s_msg_t*)NULL)->ph"); - UtPrintf("The returned value is %p", local_result); + UtAssert_MIR("JIRA: GSFCCFS-1726 No coverage impact - Does not return NULL when it should, returns 0x10 (&((pdu_s_msg_t*)NULL)->ph"); + UtPrintf("The returned value is %p", (void*)local_result); // UtAssert_NULL(local_result);; UtAssert_True(CF_AppData.engine.outgoing_counter == initial_outgoing_counter, "outgoing_counter is now %u and should not have changed from %u (value before call)", @@ -1528,7 +1467,7 @@ void Test_CF_CFDP_MsgOutGet_When_max_outgoing_messages_per_wakeup_IsNot_0_And_ou void Test_CF_CFDP_MsgOutGet_When_CF_AppData_engine_out_msg_Is_nonNULL_ButSecondIfCheckingSameValueIs_NULL_WhichDoesNotAppearToBePossible(void) { - UtAssert_Failed("GSFCCFS-1727 Cannot hit branch where CF_AppData.engine.out.msg is checked again for NULL when nothing between first and second check could have changed it, it can NEVER be NULL"); + UtAssert_MIR("JIRA: GSFCCFS-1727 Cannot hit branch where CF_AppData.engine.out.msg is checked again for NULL when nothing between first and second check could have changed it, it can NEVER be NULL"); } /* end Test_CF_CFDP_MsgOutGet_When_CF_AppData_engine_out_msg_Is_nonNULL_ButSecondIfCheckingSameValueIs_NULL_WhichDoesNotAppearToBePossible */ void Test_CF_CFDP_MsgOutGet_When_sem_name_0_Is_non0_But_CallTo_OS_CountSemTimedWait_Returns_nonOS_SUCCESS_And_CF_AppData_engine_out_msg_IsStill_NULL_SendEventBecause_silent_Is_0_Return_NULL(void) @@ -1587,7 +1526,6 @@ void Test_CF_CFDP_MsgOutGet_When_sem_name_0_Is_non0_But_CallTo_OS_CountSemTimedW transaction_t* arg_t = &dummy_t; uint32 initial_outgoing_counter; int arg_silent = Any_int_Except(0); - const char* expected_Spec = "CF: no output message buffer available"; pdu_header_t* local_result; arg_t->chan_num = Any_cf_chan_num(); @@ -1622,13 +1560,12 @@ void Test_CF_CFDP_MsgOutGet_When_sem_name_0_Is_non0_Then_CallTo_OS_CountSemTimed { /* Arrange */ pdu_s_msg_t dummy_msg; - CFE_SB_Buffer_t* forced_return_CFE_SB_AllocateMessageBuffer = &dummy_msg; + CFE_SB_Buffer_t* forced_return_CFE_SB_AllocateMessageBuffer = (CFE_SB_Buffer_t*)&dummy_msg; cf_config_table_t dummy_config_table; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; uint32 initial_outgoing_counter; int arg_silent = 0; - const char* expected_Spec = "CF: no output message buffer available"; pdu_header_t* local_result; arg_t->chan_num = Any_cf_chan_num(); @@ -1664,13 +1601,12 @@ void Test_CF_CFDP_MsgOutGet_When_sem_name_0_Is_0_Then_CallTo_OS_CountSemTimedWai { /* Arrange */ pdu_s_msg_t dummy_msg; - CFE_SB_Buffer_t* forced_return_CFE_SB_AllocateMessageBuffer = &dummy_msg; + CFE_SB_Buffer_t* forced_return_CFE_SB_AllocateMessageBuffer = (CFE_SB_Buffer_t*)&dummy_msg; cf_config_table_t dummy_config_table; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; uint32 initial_outgoing_counter; int arg_silent = 0; - const char* expected_Spec = "CF: no output message buffer available"; pdu_header_t* local_result; arg_t->chan_num = Any_cf_chan_num(); @@ -1706,25 +1642,25 @@ void Test_CF_CFDP_MsgOutGet_When_sem_name_0_Is_0_Then_CallTo_OS_CountSemTimedWai /******************************************************************************* ** -** CF_CFDP_Send tests (small) - full coverage - 1 CF_Assert - [] +** CF_CFDP_Send tests (small) - full coverage - 1 coverage JIRA issue - [] ** *******************************************************************************/ -void Test_CF_CFDP_Send_Asserts_chan_num_IsEqTo_CF_NUM_CHANNELS(void) +void Test_CF_CFDP_Send_AssertsBecause_chan_num_IsEqTo_CF_NUM_CHANNELS(void) { - /* Arrange */ + // /* Arrange */ // uint8 arg_chan_num = CF_NUM_CHANNELS; // uint32 arg_len; - /* Act */ - //CF_CFDP_Send(arg_chan_num, arg_len); + // /* Act */ + // CF_CFDP_Send(arg_chan_num, arg_len); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CFDP_Send_Asserts_chan_num_IsEqTo_CF_NUM_CHANNELS */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +} /* end Test_CF_CFDP_Send_AssertsBecause_chan_num_IsEqTo_CF_NUM_CHANNELS */ -/* TODO: Test_CF_CFDP_Send_Asserts_chan_num_IsGreaterThanTo_CF_NUM_CHANNELS not required but desired */ -// void Test_CF_CFDP_Send_Asserts_chan_num_IsGreaterThanTo_CF_NUM_CHANNELS(void) +/* TODO: Test_CF_CFDP_Send_AssertsBecause_chan_num_IsGreaterThanTo_CF_NUM_CHANNELS not required but desired */ +// void Test_CF_CFDP_Send_AssertsBecause_chan_num_IsGreaterThanTo_CF_NUM_CHANNELS(void) // { // /* Arrange */ // // uint8 arg_chan_num = Any_uint8_GreaterThan(CF_NUM_CHANNELS); @@ -1734,17 +1670,16 @@ void Test_CF_CFDP_Send_Asserts_chan_num_IsEqTo_CF_NUM_CHANNELS(void) // //CF_CFDP_Send(arg_chan_num, arg_len); // /* Assert */ -// UtAssert_Failed("CF_Assert issue"); -// } /* end Test_CF_CFDP_Send_Asserts_chan_num_IsGreaterThanTo_CF_NUM_CHANNELS */ +// UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +// } /* end Test_CF_CFDP_Send_AssertsBecause_chan_num_IsGreaterThanTo_CF_NUM_CHANNELS */ -void Test_CF_CFDP_Send_InitializesMsgTimestampsItAndSendsIt(void) +void Test_CF_CFDP_Send_InitializeMsgTimestampsItAndSendsIt(void) { /* Arrange */ uint8 arg_chan_num = Any_uint8_LessThan(CF_NUM_CHANNELS); uint32 arg_len = Any_uint32(); uint32 initial_pdu = CF_AppData.hk.channel_hk[arg_chan_num].counters.sent.pdu; CFE_MSG_Message_t expected_msg; - CFE_MSG_Size_t expected_Size = arg_len + sizeof(((pdu_s_msg_t*)CF_AppData.engine.out.msg)->hdr); CFE_TIME_SysTime_t fake_time; CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&expected_msg; @@ -1763,9 +1698,7 @@ void Test_CF_CFDP_Send_InitializesMsgTimestampsItAndSendsIt(void) /* Assert */ UtAssert_STUB_COUNT(CFE_MSG_SetMsgTime, 1); - UtAssert_True(context_CFE_MSG_SetMsgTime.MsgPtr == &expected_msg, - "CFE_MSG_SetMsgTime received MsgPtr %p and should be %p (&CF_AppData.engine.out.msg->Msg)", - context_CFE_MSG_SetMsgTime.MsgPtr, &expected_msg); + UtAssert_ADDRESS_EQ(context_CFE_MSG_SetMsgTime.MsgPtr, &expected_msg); UtAssert_True(context_CFE_MSG_SetMsgTime.Time.Seconds == fake_time.Seconds, "CFE_MSG_SetMsgTime received Time.Seconds %u and should be %u (call to CFE_TIME_GetTime Seconds)", context_CFE_MSG_SetMsgTime.Time.Seconds, fake_time.Seconds); @@ -1776,10 +1709,8 @@ void Test_CF_CFDP_Send_InitializesMsgTimestampsItAndSendsIt(void) UtAssert_True(resultant_pdu == initial_pdu + 1, "CF_AppData.hk.channel_hk[chan_num].counters.sent.pdu is %d and should be 1 more than %d (value before call)", resultant_pdu, initial_pdu); - UtAssert_True(CF_AppData.engine.out.msg == NULL, - "CF_AppData.engine.out.msg is %p and should be %p (set in call)", - CF_AppData.engine.out.msg, NULL); -} /* end Test_CF_CFDP_Send_InitializesMsgTimestampsItAndSendsIt */ + UtAssert_ADDRESS_EQ(CF_AppData.engine.out.msg, NULL); +} /* end Test_CF_CFDP_Send_InitializeMsgTimestampsItAndSendsIt */ /* end CF_CFDP_Send tests */ @@ -1789,7 +1720,7 @@ void Test_CF_CFDP_Send_InitializesMsgTimestampsItAndSendsIt(void) ** *******************************************************************************/ -void Test_CF_CFDP_SetPduLength_SetsGiven_ph_length_ToGiven_length(void) +void Test_CF_CFDP_SetPduLength_SetGiven_ph_length_ToGiven_length(void) { /* Arrange */ pdu_header_t dummy_ph; @@ -1804,7 +1735,7 @@ void Test_CF_CFDP_SetPduLength_SetsGiven_ph_length_ToGiven_length(void) UtAssert_True(arg_ph->length == arg_length, "ph->length is %u and should be %u (length)", arg_ph->length, arg_length); -} /* end Test_CF_CFDP_Send_Asserts_chan_num_IsEqTo_CF_NUM_CHANNELS */ +} /* end Test_CF_CFDP_SetPduLength_SetGiven_ph_length_ToGiven_length */ /* end CF_CFDP_SetPduLength tests */ @@ -1817,14 +1748,14 @@ void Test_CF_CFDP_SetPduLength_SetsGiven_ph_length_ToGiven_length(void) void Test_CF_CFDP_ConstructPduHeader_CallTo_CF_CFDP_MsgOutGet_Returns_NULL_DoNothingReturn_NULL(void) { /* Arrange */ - uint8 dummy_chan_num = Any_cf_chan_num(); - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; - uint8 arg_directive_code; - cf_entity_id_t arg_src_eid; - cf_entity_id_t arg_dst_eid; - uint8 arg_towards_sender; - cf_transaction_seq_t arg_tsn; - int arg_silent; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; + uint8 arg_directive_code = Any_uint8(); + cf_entity_id_t arg_src_eid = Any_uint8(); + cf_entity_id_t arg_dst_eid = Any_uint8(); + uint8 arg_towards_sender = Any_uint8(); + cf_transaction_seq_t arg_tsn = Any_uint32(); + int arg_silent = Any_int(); pdu_header_t* local_result; /* Arrange for CF_CFDP_MsgOutGet*/ @@ -1834,40 +1765,37 @@ void Test_CF_CFDP_ConstructPduHeader_CallTo_CF_CFDP_MsgOutGet_Returns_NULL_DoNot CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; arg_t->flags.all.suspended = 0; - UT_SetDefaultReturnValue(OS_CountSemTimedWait, Any_uint32_Except(OS_SUCCESS)); + UT_SetDefaultReturnValue(UT_KEY(OS_CountSemTimedWait), Any_uint32_Except(OS_SUCCESS)); /* Act */ local_result = CF_CFDP_ConstructPduHeader(arg_t, arg_directive_code, arg_src_eid, arg_dst_eid, arg_towards_sender, arg_tsn, arg_silent); /* Assert */ - UtAssert_True(local_result == NULL, - "CF_CFDP_ConstructPduHeader returned %p and should be %p (NULL)", - local_result, NULL); + UtAssert_ADDRESS_EQ(local_result, NULL); } /* end Test_CF_CFDP_ConstructPduHeader_CallTo_CF_CFDP_MsgOutGet_Returns_NULL_DoNothingReturn_NULL */ void Test_CF_CFDP_ConstructPduHeader_Given_directive_code_0_CallTo_CF_CFDP_MsgOutGet_ReturnsMsgReturnMsg(void) { /* Arrange */ pdu_s_msg_t dummy_msg; - transaction_t* arg_t = &CF_AppData.engine.channels[Any_cf_chan_num()]; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; uint8 arg_directive_code = 0; - cf_entity_id_t arg_src_eid; - cf_entity_id_t arg_dst_eid; - uint8 arg_towards_sender; - cf_transaction_seq_t arg_tsn; - int arg_silent; + cf_entity_id_t arg_src_eid = Any_uint8(); + cf_entity_id_t arg_dst_eid = Any_uint8(); + uint8 arg_towards_sender = Any_uint8(); + cf_transaction_seq_t arg_tsn = Any_uint32(); + int arg_silent = Any_int(); pdu_header_t* local_result; /* Arrange for CF_CFDP_MsgOutGet*/ - CF_AppData.engine.out.msg = &dummy_msg; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_msg; /* Act */ local_result = CF_CFDP_ConstructPduHeader(arg_t, arg_directive_code, arg_src_eid, arg_dst_eid, arg_towards_sender, arg_tsn, arg_silent); /* Assert */ - UtAssert_True(local_result == &dummy_msg.ph, - "CF_CFDP_ConstructPduHeader returned %p and should be %p ((pdu_s_msg_t*)msg->ph)", - local_result, &dummy_msg.ph); + UtAssert_ADDRESS_EQ(local_result, &dummy_msg.ph); UtAssert_STUB_COUNT(CF_SetVariableHeader, 1); /* Teardown -- TODO:figure out how to get rid of this, test independence is a problem here */ @@ -1878,25 +1806,24 @@ void Test_CF_CFDP_ConstructPduHeader_Given_directive_code_1_CallTo_CF_CFDP_MsgOu { /* Arrange */ pdu_s_msg_t dummy_msg; - transaction_t* arg_t = &CF_AppData.engine.channels[Any_cf_chan_num()]; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; uint8 arg_directive_code = 1; - cf_entity_id_t arg_src_eid; - cf_entity_id_t arg_dst_eid; - uint8 arg_towards_sender; - cf_transaction_seq_t arg_tsn; - int arg_silent; + cf_entity_id_t arg_src_eid = Any_uint8(); + cf_entity_id_t arg_dst_eid = Any_uint8(); + uint8 arg_towards_sender = Any_uint8(); + cf_transaction_seq_t arg_tsn = Any_uint32(); + int arg_silent = Any_int(); pdu_header_t* local_result; /* Arrange for CF_CFDP_MsgOutGet*/ - CF_AppData.engine.out.msg = &dummy_msg; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_msg; /* Act */ local_result = CF_CFDP_ConstructPduHeader(arg_t, arg_directive_code, arg_src_eid, arg_dst_eid, arg_towards_sender, arg_tsn, arg_silent); /* Assert */ - UtAssert_True(local_result == &dummy_msg.ph, - "CF_CFDP_ConstructPduHeader returned %p and should be %p ((pdu_s_msg_t*)msg->ph)", - local_result, &dummy_msg.ph); + UtAssert_ADDRESS_EQ(local_result, &dummy_msg.ph); UtAssert_STUB_COUNT(CF_SetVariableHeader, 1); /* Teardown -- TODO:figure out how to get rid of this, test independence is a problem here */ @@ -1911,53 +1838,52 @@ void Test_CF_CFDP_ConstructPduHeader_Given_directive_code_1_CallTo_CF_CFDP_MsgOu ** *******************************************************************************/ -void Test_CF_strnlen_When_end_IsNot_NULL_ReturnsLengthOfGiven_s(void) +void Test_CF_strnlen_When_end_IsNot_NULL_ReturnLengthOfGiven_s(void) { /* Arrange */ - char* arg_s[256]; - size_t arg_maxlen = 256; /* 256 is arbitrary and used for small size */ - size_t expected_length = Any_uint8(); /* Any_uint8() is arbirary and used for small size */ + const char arg_s[7] = "NO NULL"; + size_t arg_maxlen = 8; /* 256 is arbitrary and used for small size */ + size_t expected_length = 7; size_t local_result; - AnyRandomStringOfLettersOfLengthCopy(arg_s, expected_length); /* Act */ local_result = CF_strnlen(arg_s, arg_maxlen); /* Assert */ UtAssert_True(local_result == expected_length, - "CF_strnlen returned %u and should be %u (length of s)", + "CF_strnlen returned %lu and should be %lu (length of s)", local_result, expected_length); -} /* end Test_CF_strnlen_When_end_IsNot_NULL_ReturnsLengthOfGiven_s */ +} /* end Test_CF_strnlen_When_end_IsNot_NULL_ReturnLengthOfGiven_s */ -void Test_CF_strnlen_When_end_Is_NULL_ReturnsLengthOfGiven_s(void) +void Test_CF_strnlen_When_end_Is_NULL_ReturnLengthOfGiven_s(void) { /* Arrange */ - char* arg_s[256]; - size_t expected_length = Any_uint8_Except(0); /* Any_uint8_Except(0) is arbirary and used for small size and to allow maxlen to be less than it */ - size_t arg_maxlen = Any_uint8_LessThan(expected_length); + const char arg_s[15] = "HAS NULL AT 14\0"; + size_t arg_maxlen = Any_uint8_LessThan(strlen(arg_s)); size_t local_result; - AnyRandomStringOfLettersOfLengthCopy(arg_s, expected_length); - /* Act */ local_result = CF_strnlen(arg_s, arg_maxlen); /* Assert */ UtAssert_True(local_result == arg_maxlen, - "CF_strnlen returned %u and should be %u (maxlen)", + "CF_strnlen returned %lu and should be %lu (maxlen)", local_result, arg_maxlen); -} /* end Test_CF_strnlen_When_end_Is_NULL_ReturnsLengthOfGiven_s */ + UtAssert_True(local_result != strlen(arg_s), + "CF_strnlen returned %lu and should not be %lu (string len)", + local_result, strlen(arg_s)); +} /* end Test_CF_strnlen_When_end_Is_NULL_ReturnLengthOfGiven_s */ /* end CF_strnlen tests */ /******************************************************************************* ** -** CF_CFDP_SendMd tests (large) - full coverage - 1 CF_Assert - [unstubbbles: CF_CFDP_ConstructPduHeader (medium), CF_CFDP_CopyDataToLv (small), CF_CFDP_SetPduLength (simple), CF_CFDP_Send (small)] +** CF_CFDP_SendMd tests (large) - full coverage - 5 coverage JIRA issue - [unstubbbles: CF_CFDP_ConstructPduHeader (medium), CF_CFDP_CopyDataToLv (small), CF_CFDP_SetPduLength (simple), CF_CFDP_Send (small)] ** *******************************************************************************/ -void Test_CF_CFDP_SendMd_GetsNull_pdu_header_Returns_CF_SEND_NO_MSG(void) +void Test_CF_CFDP_SendMd_GetNull_pdu_header_Return_CF_SEND_NO_MSG(void) { /* Arrange */ history_t dummy_history; @@ -1974,6 +1900,8 @@ void Test_CF_CFDP_SendMd_GetsNull_pdu_header_Returns_CF_SEND_NO_MSG(void) CF_AppData.engine.outgoing_counter = Any_uint32_Except(0); CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = CF_AppData.engine.outgoing_counter; + + arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ /* Act */ local_result = CF_CFDP_SendMd(arg_t); @@ -1982,9 +1910,9 @@ void Test_CF_CFDP_SendMd_GetsNull_pdu_header_Returns_CF_SEND_NO_MSG(void) UtAssert_True(local_result == CF_SEND_NO_MSG, "CF_CFDP_SendMd returned %u and should be %u (CF_SEND_NO_MSG)", local_result, CF_SEND_NO_MSG); -} /* end Test_CF_CFDP_SendMd_GetsNull_pdu_header_Returns_CF_SEND_NO_MSG */ +} /* end Test_CF_CFDP_SendMd_GetNull_pdu_header_Return_CF_SEND_NO_MSG */ -void Test_CF_CFDP_SendMd_Asserts_state_NotEq_CFDP_S1_Or_CFDP_S2(void) +void Test_CF_CFDP_SendMd_AssertsBecause_state_NotEq_CFDP_S1_Or_CFDP_S2(void) { /* Arrange */ // pdu_msg_t dummy_msg_out; @@ -2008,14 +1936,19 @@ void Test_CF_CFDP_SendMd_Asserts_state_NotEq_CFDP_S1_Or_CFDP_S2(void) // arg_t->flags.all.suspended = 0; // CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_msg_out; + // arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ + /* Act */ //local_result = CF_CFDP_SendMd(arg_t); /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CFDP_SendMd_Asserts_state_NotEq_CFDP_S1_Or_CFDP_S2 */ + /* This causes 3 branches to not be taken */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - (t->state == CFDP_S1) || (t->state == CFDP_S2)"); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - (t->state == CFDP_S1) || (t->state == CFDP_S2)"); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - (t->state == CFDP_S1) || (t->state == CFDP_S2)"); +} /* end Test_CF_CFDP_SendMd_AssertsBecause_state_NotEq_CFDP_S1_Or_CFDP_S2 */ -void Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_src_len_Eq_sizeof_src_filename(void) +void Test_CF_CFDP_SendMd_When_src_len_Eq_sizeof_src_filename_Return_CF_SEND_FAILURE(void) { /* Arrange */ pdu_s_msg_t dummy_msg_out; @@ -2032,7 +1965,7 @@ void Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_src_len_Eq_sizeof_src_filename( AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.dst_filename, dst_filename_size); arg_t->state = Any_uint8_FromThese(passing_states, sizeof(passing_states)/sizeof(passing_states[0])); - /* Arrange unstubbable: CF_CFDP_ConstructPduHeader and CF_CFDP_MsgOutGet */ + /* Arrange unstubbable: CF_CFDP_ConstructPduHeader and CF_CFDP_MsgOutGet and CF_CFDP_GetClass */ cf_config_table_t dummy_config_table; CF_AppData.config_table = &dummy_config_table; @@ -2043,6 +1976,8 @@ void Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_src_len_Eq_sizeof_src_filename( arg_t->flags.all.suspended = 0; CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_msg_out; + arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ + /* Act */ local_result = CF_CFDP_SendMd(arg_t); @@ -2050,9 +1985,9 @@ void Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_src_len_Eq_sizeof_src_filename( UtAssert_True(local_result == CF_SEND_FAILURE, "CF_CFDP_SendMd returned %u and should be %u (CF_SEND_FAILURE)", local_result, CF_SEND_FAILURE); -} /* end Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_src_len_Eq_sizeof_src_filename */ +} /* end Test_CF_CFDP_SendMd_When_src_len_Eq_sizeof_src_filename_Return_CF_SEND_FAILURE */ -void Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_dst_len_Eq_sizeof_dst_filename(void) +void Test_CF_CFDP_SendMd_When_dst_len_Eq_sizeof_dst_filename_Return_CF_SEND_FAILURE(void) { /* Arrange */ pdu_s_msg_t dummy_msg_out; @@ -2080,6 +2015,8 @@ void Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_dst_len_Eq_sizeof_dst_filename( arg_t->flags.all.suspended = 0; CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_msg_out; + arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ + /* Act */ local_result = CF_CFDP_SendMd(arg_t); @@ -2087,85 +2024,89 @@ void Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_dst_len_Eq_sizeof_dst_filename( UtAssert_True(local_result == CF_SEND_FAILURE, "CF_CFDP_SendMd returned %u and should be %u (CF_SEND_FAILURE)", local_result, CF_SEND_FAILURE); -} /* end Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_dst_len_Eq_sizeof_dst_filename */ +} /* end Test_CF_CFDP_SendMd_When_dst_len_Eq_sizeof_dst_filename_Return_CF_SEND_FAILURE */ void Test_CF_CFDP_SendMd_Returns_CF_SEND_ERROR_CF_CFDP_CopyDataToLv_Returns_neg1_On_src_Call(void) { - /* Arrange */ - pdu_md_t dummy_msg_out; - history_t dummy_history; - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; - cfdp_send_ret_t local_result; - uint8 passing_states[2] = {CFDP_S1, CFDP_S2}; - size_t src_filename_size = Any_uint8_LessThan(sizeof(arg_t->history->fnames.src_filename)); - size_t dst_filename_size = Any_uint8_LessThan(sizeof(arg_t->history->fnames.dst_filename)); + // /* Arrange */ + // pdu_md_t dummy_msg_out; + // history_t dummy_history; + // transaction_t dummy_t; + // transaction_t* arg_t = &dummy_t; + // cfdp_send_ret_t local_result; + // uint8 passing_states[2] = {CFDP_S1, CFDP_S2}; + // size_t src_filename_size = Any_uint8_LessThan(sizeof(arg_t->history->fnames.src_filename)); + // size_t dst_filename_size = Any_uint8_LessThan(sizeof(arg_t->history->fnames.dst_filename)); - arg_t->history = &dummy_history; - AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.src_filename, src_filename_size); - AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.dst_filename, dst_filename_size); - arg_t->state = Any_uint8_FromThese(passing_states, sizeof(passing_states)/sizeof(passing_states[0])); + // arg_t->history = &dummy_history; + // AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.src_filename, src_filename_size); + // AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.dst_filename, dst_filename_size); + // arg_t->state = Any_uint8_FromThese(passing_states, sizeof(passing_states)/sizeof(passing_states[0])); - /* Arrange unstubbable: CF_CFDP_MsgOutGet */ - cf_config_table_t dummy_config_table; + // /* Arrange unstubbable: CF_CFDP_MsgOutGet */ + // cf_config_table_t dummy_config_table; - CF_AppData.config_table = &dummy_config_table; - arg_t->chan_num = Any_uint8_LessThan(CF_NUM_CHANNELS); - CF_AppData.engine.outgoing_counter = 0; - CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 1; - CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; - arg_t->flags.all.suspended = 0; - CF_AppData.engine.out.msg = &dummy_msg_out; + // CF_AppData.config_table = &dummy_config_table; + // arg_t->chan_num = Any_uint8_LessThan(CF_NUM_CHANNELS); + // CF_AppData.engine.outgoing_counter = 0; + // CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 1; + // CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; + // arg_t->flags.all.suspended = 0; + // CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_msg_out; - /* Arrange unstubbable: CF_CFDP_CopyDataToLv */ - /* no way to arrange it to fail */ + // arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ - /* Act */ + // /* Arrange unstubbable: CF_CFDP_CopyDataToLv */ + // /* no way to arrange it to fail */ + + // /* Act */ // local_result = CF_CFDP_SendMd(arg_t); - /* Assert */ - UtAssert_Failed("Unable to stub CF_CFDP_CopyDataToLv -- cannot hit if(ret<0) for src\nComment in code states it 'should not happen' and it cannot be forced to fail."); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCFCS-1737 Unable to stub CF_CFDP_CopyDataToLv -- cannot hit if(ret<0) for src\nComment in code states it 'should not happen' and it cannot be forced to fail."); } /* end Test_CF_CFDP_SendMd_Returns_CF_SEND_ERROR_CF_CFDP_CopyDataToLv_Returns_neg1_On_src_Call */ -void Test_CF_CFDP_SendMd_Returns_CF_SEND_ERROR_CF_CFDP_CopyDataToLv_Returns_neg1_On_dst_Call(void) +void Test_CF_CFDP_SendMd_WhenCallTo_CF_CFDP_CopyDataToLv_Returns_neg1_OnThe_dst_Call_Return_CF_SEND_ERROR(void) { - /* Arrange */ - pdu_md_t dummy_msg_out; - history_t dummy_history; - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; - cfdp_send_ret_t local_result; - uint8 passing_states[2] = {CFDP_S1, CFDP_S2}; - size_t src_filename_size = Any_uint8_LessThan(sizeof(arg_t->history->fnames.src_filename)); - size_t dst_filename_size = Any_uint8_LessThan(sizeof(arg_t->history->fnames.dst_filename)); + // /* Arrange */ + // pdu_md_t dummy_msg_out; + // history_t dummy_history; + // transaction_t dummy_t; + // transaction_t* arg_t = &dummy_t; + // cfdp_send_ret_t local_result; + // uint8 passing_states[2] = {CFDP_S1, CFDP_S2}; + // size_t src_filename_size = Any_uint8_LessThan(sizeof(arg_t->history->fnames.src_filename)); + // size_t dst_filename_size = Any_uint8_LessThan(sizeof(arg_t->history->fnames.dst_filename)); - arg_t->history = &dummy_history; - AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.src_filename, src_filename_size); - AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.dst_filename, dst_filename_size); - arg_t->state = Any_uint8_FromThese(passing_states, sizeof(passing_states)/sizeof(passing_states[0])); + // arg_t->history = &dummy_history; + // AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.src_filename, src_filename_size); + // AnyRandomStringOfLettersOfLengthCopy(arg_t->history->fnames.dst_filename, dst_filename_size); + // arg_t->state = Any_uint8_FromThese(passing_states, sizeof(passing_states)/sizeof(passing_states[0])); - /* Arrange unstubbable: CF_CFDP_MsgOutGet */ - cf_config_table_t dummy_config_table; + // /* Arrange unstubbable: CF_CFDP_MsgOutGet */ + // cf_config_table_t dummy_config_table; - CF_AppData.config_table = &dummy_config_table; - arg_t->chan_num = Any_uint8_LessThan(CF_NUM_CHANNELS); - CF_AppData.engine.outgoing_counter = 0; - CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 1; - CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; - arg_t->flags.all.suspended = 0; - CF_AppData.engine.out.msg = &dummy_msg_out; + // CF_AppData.config_table = &dummy_config_table; + // arg_t->chan_num = Any_uint8_LessThan(CF_NUM_CHANNELS); + // CF_AppData.engine.outgoing_counter = 0; + // CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 1; + // CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; + // arg_t->flags.all.suspended = 0; + // CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_msg_out; - /* Arrange for CF_CFDP_CopyDataToLv */ - /* no way to arrange it to fail */ + // arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ - /* Act */ - //local_result = CF_CFDP_SendMd(arg_t); + // /* Arrange for CF_CFDP_CopyDataToLv */ + // /* no way to arrange it to fail */ + + // /* Act */ + // local_result = CF_CFDP_SendMd(arg_t); /* Assert */ - UtAssert_Failed("Unable to stub CF_CFDP_CopyDataToLv -- cannot hit if(ret<0) for dst\nComment in code states it 'should not happen' and it cannot be forced to fail."); -} /* end Test_CF_CFDP_SendMd_Returns_CF_SEND_ERROR_CF_CFDP_CopyDataToLv_Returns_neg1_On_dst_Call */ + UtAssert_MIR("JIRA: GSFCFCS-1737 Unable to stub CF_CFDP_CopyDataToLv -- cannot hit if(ret<0) for dst\nComment in code states it 'should not happen' and it cannot be forced to fail."); +} /* end Test_CF_CFDP_SendMd_WhenCallTo_CF_CFDP_CopyDataToLv_Returns_neg1_OnThe_dst_Call_Return_CF_SEND_ERROR */ -void Test_CF_CFDP_SendMd_SuccessReturns_CF_SEND_SUCCESS(void) +void Test_CF_CFDP_SendMd_Return_CF_SEND_SUCCESS(void) { /* Arrange */ pdu_md_t dummy_msg_out; @@ -2191,7 +2132,9 @@ void Test_CF_CFDP_SendMd_SuccessReturns_CF_SEND_SUCCESS(void) CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 1; CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; arg_t->flags.all.suspended = 0; - CF_AppData.engine.out.msg = &dummy_msg_out; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_msg_out; + + arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ /* Arrange for CF_CFDP_CopyDataToLv */ /* no way to arrange it to fail - which for success test is fine */ @@ -2203,7 +2146,7 @@ void Test_CF_CFDP_SendMd_SuccessReturns_CF_SEND_SUCCESS(void) UtAssert_True(local_result == CF_SEND_SUCCESS, "CF_CFDP_SendMd returned %u and should be %u (CF_SEND_SUCCESS)", local_result, CF_SEND_SUCCESS); -} /* end Test_CF_CFDP_SendMd_DeepSetupTestsRequired */ +} /* end Test_CF_CFDP_SendMd_Return_CF_SEND_SUCCESS */ /* end CF_CFDP_SendMd tests */ @@ -2213,11 +2156,10 @@ void Test_CF_CFDP_SendMd_SuccessReturns_CF_SEND_SUCCESS(void) ** *******************************************************************************/ -void Test_CF_CFDP_SendFd_Returns_CF_SEND_ERROR_Because_len_GreaterThan_sizeof_pdu_pd_data_t(void) +void Test_CF_CFDP_SendFd_When_len_GreaterThan_sizeof_pdu_pd_data_t_Return_CF_SEND_ERROR(void) { /* Arrange */ transaction_t* arg_t = NULL; - pdu_header_t dummy_pdu; uint32 arg_offset = Any_uint32(); int arg_len = sizeof(pdu_fd_data_t) + 1; cfdp_send_ret_t local_result; @@ -2229,9 +2171,9 @@ void Test_CF_CFDP_SendFd_Returns_CF_SEND_ERROR_Because_len_GreaterThan_sizeof_pd UtAssert_True(local_result == CF_SEND_ERROR, "CF_CFDP_SendMd returned %u and should be %u (CF_SEND_ERROR)", local_result, CF_SEND_ERROR); -} /* end Test_CF_CFDP_SendFd_Returns_CF_SEND_ERROR_Because_len_GreaterThan_sizeof_pdu_pd_data_t */ +} /* end Test_CF_CFDP_SendFd_When_len_GreaterThan_sizeof_pdu_pd_data_t_Return_CF_SEND_ERROR */ -void Test_CF_CFDP_SendFd_SuccessReturns_CF_SEND_SUCCESS(void) +void Test_CF_CFDP_SendFd_Return_CF_SEND_SUCCESS(void) { /* Arrange */ pdu_s_msg_t dummy_msg; @@ -2241,7 +2183,7 @@ void Test_CF_CFDP_SendFd_SuccessReturns_CF_SEND_SUCCESS(void) int arg_len = sizeof(pdu_fd_data_t) - 1; cfdp_send_ret_t local_result; - CF_AppData.engine.out.msg = &dummy_msg; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_msg; arg_t->chan_num = Any_cf_chan_num(); @@ -2256,7 +2198,7 @@ void Test_CF_CFDP_SendFd_SuccessReturns_CF_SEND_SUCCESS(void) UtAssert_True(local_result == CF_SEND_SUCCESS, "CF_CFDP_SendMd returned %u and should be %u (CF_SEND_SUCCESS)", local_result, CF_SEND_SUCCESS); -} /* end Test_CF_CFDP_SendFd_SuccessReturns_CF_SEND_SUCCESS */ +} /* end Test_CF_CFDP_SendFd_Return_CF_SEND_SUCCESS */ /* end CF_CFDP_SendFd tests */ @@ -2266,15 +2208,14 @@ void Test_CF_CFDP_SendFd_SuccessReturns_CF_SEND_SUCCESS(void) ** *******************************************************************************/ -void Test_CF_CFDP_FinishEofAck_SetsExpectedValues(void) +void Test_CF_CFDP_FinishEofAck_SetExpectedValues(void) { /* Arrange */ tlv_t dummy_tlv; - tlv_t* arg_tlv; + tlv_t* arg_tlv = &dummy_tlv; cf_entity_id_t dummy_eid = Any_uint8(); cf_config_table_t dummy_config_table; int forced_return_CF_GetMemcpySize = Any_int(); - int expected_result = offsetof(tlv_t, data) + forced_return_CF_GetMemcpySize; int local_result; CF_AppData.config_table = &dummy_config_table; @@ -2288,11 +2229,11 @@ void Test_CF_CFDP_FinishEofAck_SetsExpectedValues(void) /* Assert */ UtAssert_True(local_result == offsetof(tlv_t, data) + forced_return_CF_GetMemcpySize, - "CF_CFDP_FinishEofAck returned %d and should be %d (offsetof(tlv_t, data) + %d (csize)", + "CF_CFDP_FinishEofAck returned %d and should be %lu (offsetof(tlv_t, data) + %d (csize)", local_result, offsetof(tlv_t, data), forced_return_CF_GetMemcpySize); UtAssert_STUB_COUNT(CF_GetMemcpySize, 1); UtAssert_STUB_COUNT(CF_MemcpyToBE, 1); -} /* end Test_CF_CFDP_FinishEofAck_SetsExpectedValues */ +} /* end Test_CF_CFDP_FinishEofAck_SetExpectedValues */ /* end CF_CFDP_FinishEofAck tests */ @@ -2302,13 +2243,13 @@ void Test_CF_CFDP_FinishEofAck_SetsExpectedValues(void) ** *******************************************************************************/ -void Test_CF_CFDP_SendEof_GetsNull_pdu_Return_CF_SEND_NO_MSG(void) +void Test_CF_CFDP_SendEof_Get_NULL_pdu_Return_CF_SEND_NO_MSG(void) { /* Arrange */ cf_config_table_t dummy_config_table; - uint8 dummy_chan_num = Any_cf_chan_num(); history_t dummy_history; - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; cfdp_send_ret_t local_result; CF_AppData.config_table = &dummy_config_table; @@ -2321,7 +2262,7 @@ void Test_CF_CFDP_SendEof_GetsNull_pdu_Return_CF_SEND_NO_MSG(void) CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; arg_t->flags.all.suspended = 0; - UT_SetDefaultReturnValue(OS_CountSemTimedWait, Any_uint32_Except(OS_SUCCESS)); + UT_SetDefaultReturnValue(UT_KEY(OS_CountSemTimedWait), Any_uint32_Except(OS_SUCCESS)); /* Act */ local_result = CF_CFDP_SendEof(arg_t); @@ -2330,16 +2271,16 @@ void Test_CF_CFDP_SendEof_GetsNull_pdu_Return_CF_SEND_NO_MSG(void) UtAssert_True(local_result == CF_SEND_NO_MSG, "CF_CFDP_SendEof returned %u and should be %u (CF_SEND_NO_MSG)", local_result, CF_SEND_NO_MSG); -} /* end Test_CF_CFDP_SendEof_GetsNull_pdu_Return_CF_SEND_NO_MSG */ +} /* end Test_CF_CFDP_SendEof_Get_NULL_pdu_Return_CF_SEND_NO_MSG */ void Test_CF_CFDP_SendEof_SuccessWithNoError(void) { /* Arrange */ pdu_eof_t dummy_eof; cf_config_table_t dummy_config_table; - uint8 dummy_chan_num = Any_cf_chan_num(); history_t dummy_history; - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; cfdp_send_ret_t local_result; CF_AppData.config_table = &dummy_config_table; @@ -2347,13 +2288,13 @@ void Test_CF_CFDP_SendEof_SuccessWithNoError(void) arg_t->history->cc = CC_NO_ERROR; /* Arrange for CF_CFDP_MsgOutGet*/ - CF_AppData.engine.out.msg = &dummy_eof; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_eof; CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 0; CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; arg_t->flags.all.suspended = 0; - UT_SetDefaultReturnValue(OS_CountSemTimedWait, Any_uint32_Except(OS_SUCCESS)); + UT_SetDefaultReturnValue(UT_KEY(OS_CountSemTimedWait), Any_uint32_Except(OS_SUCCESS)); /* Act */ local_result = CF_CFDP_SendEof(arg_t); @@ -2369,9 +2310,9 @@ void Test_CF_CFDP_SendEof_SuccessWithError(void) /* Arrange */ pdu_eof_t dummy_eof; cf_config_table_t dummy_config_table; - uint8 dummy_chan_num = Any_cf_chan_num(); history_t dummy_history; - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; cfdp_send_ret_t local_result; CF_AppData.config_table = &dummy_config_table; @@ -2379,13 +2320,13 @@ void Test_CF_CFDP_SendEof_SuccessWithError(void) arg_t->history->cc = Any_uint8_Except(CC_NO_ERROR); /* Arrange for CF_CFDP_MsgOutGet*/ - CF_AppData.engine.out.msg = &dummy_eof; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_eof; CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 0; CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; arg_t->flags.all.suspended = 0; - UT_SetDefaultReturnValue(OS_CountSemTimedWait, Any_uint32_Except(OS_SUCCESS)); + UT_SetDefaultReturnValue(UT_KEY(OS_CountSemTimedWait), Any_uint32_Except(OS_SUCCESS)); /* Act */ local_result = CF_CFDP_SendEof(arg_t); @@ -2402,17 +2343,17 @@ void Test_CF_CFDP_SendEof_SuccessWithError(void) /******************************************************************************* ** -** CF_CFDP_SendAck tests (medium) - full coverage - 3 CF_Assert - [unstubbables: CF_CFDP_IsSender (simple), CF_CFDP_ConstructPduHeader (medium - unstubbables: CF_CFDP_MsgOutGet (large), CF_CFDP_GetClass (simple) ), CF_CFDP_SetPduLength (simple), CF_CFDP_Send (small)] +** CF_CFDP_SendAck tests (medium) - full coverage - 1 coverage JIRA issue - [unstubbables: CF_CFDP_IsSender (simple), CF_CFDP_ConstructPduHeader (medium - unstubbables: CF_CFDP_MsgOutGet (large), CF_CFDP_GetClass (simple) ), CF_CFDP_SetPduLength (simple), CF_CFDP_Send (small)] ** *******************************************************************************/ -void Test_CF_CFDP_SendAck_When_CF_CFDP_IsSender_Returns_false_GetsNull_ph_Returns_CF_SEND_NO_MSG(void) +void Test_CF_CFDP_SendAck_When_CF_CFDP_IsSender_Returns_false_Get_NULL_ph_Return_CF_SEND_NO_MSG(void) { /* Arrange */ cf_config_table_t dummy_config_table; - uint8 dummy_chan_num = Any_cf_chan_num(); history_t dummy_history; - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; ack_transaction_status_t arg_ts = Any_uint8(); file_directive_t arg_dir_code = Any_uint8(); condition_code_t arg_cc = Any_uint8(); @@ -2442,57 +2383,57 @@ void Test_CF_CFDP_SendAck_When_CF_CFDP_IsSender_Returns_false_GetsNull_ph_Return UtAssert_True(local_result == CF_SEND_NO_MSG, "CF_CFDP_SendAck returned %u and should be %u (CF_SEND_NO_MSG)", local_result, CF_SEND_NO_MSG); -} /* end Test_CF_CFDP_SendAck_When_CF_CFDP_IsSender_Returns_false_GetsNull_ph_Returns_CF_SEND_NO_MSG */ +} /* end Test_CF_CFDP_SendAck_When_CF_CFDP_IsSender_Returns_false_Get_NULL_ph_Return_CF_SEND_NO_MSG */ -void Test_CF_CFDP_SendAck_Asserts_WhenGiven_dir_code_Is_Not_PDU_EOF_Or_PDU_FIN(void) +void Test_CF_CFDP_SendAck_AssertsBecauseGiven_dir_code_Is_Not_PDU_EOF_Or_PDU_FIN(void) { - /* Arrange */ - pdu_ack_t dummy_ack; - cf_config_table_t dummy_config_table; - uint8 dummy_chan_num = Any_cf_chan_num(); - history_t dummy_history; - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; - ack_transaction_status_t arg_ts = Any_uint8(); - uint8 exceptions[2] = {PDU_EOF, PDU_FIN}; - file_directive_t arg_dir_code = Any_uint8_ExceptThese(exceptions, 2); - condition_code_t arg_cc = Any_uint8(); - cf_entity_id_t arg_peer_eid = Any_uint8(); - cf_transaction_seq_t arg_tsn = Any_uint8(); - cfdp_send_ret_t local_result; + // /* Arrange */ + // pdu_ack_t dummy_ack; + // cf_config_table_t dummy_config_table; + // history_t dummy_history; + // uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + // transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; + // ack_transaction_status_t arg_ts = Any_uint8(); + // uint8 exceptions[2] = {PDU_EOF, PDU_FIN}; + // file_directive_t arg_dir_code = Any_uint8_ExceptThese(exceptions, 2); + // condition_code_t arg_cc = Any_uint8(); + // cf_entity_id_t arg_peer_eid = Any_uint8(); + // cf_transaction_seq_t arg_tsn = Any_uint8(); + // cfdp_send_ret_t local_result; - CF_AppData.config_table = &dummy_config_table; - arg_t->history = &dummy_history; + // CF_AppData.config_table = &dummy_config_table; + // arg_t->history = &dummy_history; - /* Arrange for CF_CFDP_IsSender */ - arg_t->flags.all.q_index = Any_uint8_LessThan(CF_Q_FREE); - arg_t->state = CFDP_S1; /* ensures true from CF_CFDP_IsSender */ + // /* Arrange for CF_CFDP_IsSender */ + // arg_t->flags.all.q_index = Any_uint8_LessThan(CF_Q_FREE); + // arg_t->state = CFDP_S1; /* ensures true from CF_CFDP_IsSender */ - /* Arrange for CF_CFDP_ConstructPduHeader */ - /* Arrange for CF_CFDP_MsgOutGet */ - CF_AppData.engine.out.msg = &dummy_ack; - CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 0; + // /* Arrange for CF_CFDP_ConstructPduHeader */ + // /* Arrange for CF_CFDP_MsgOutGet */ + // CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_ack; + // CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 0; - CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; - arg_t->flags.all.suspended = 0; + // CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; + // arg_t->flags.all.suspended = 0; - /* Act */ - //local_result = CF_CFDP_SendAck(arg_t, arg_ts, arg_dir_code, arg_cc, arg_peer_eid, arg_tsn); + // /* Act */ + // local_result = CF_CFDP_SendAck(arg_t, arg_ts, arg_dir_code, arg_cc, arg_peer_eid, arg_tsn); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ // UtAssert_True(local_result == CF_SEND_NO_MSG, // "CF_CFDP_SendAck returned %u and should be %u (CF_SEND_NO_MSG)", // local_result, CF_SEND_NO_MSG); -} /* end Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_EOF_And_CF_CFDP_IsSender_Returns_true_GetsMsg_pdu_Returns_CF_SEND_NO_MSG */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - (dir_code==PDU_EOF)||(dir_code==PDU_FIN)"); +} /* end Test_CF_CFDP_SendAck_AssertsBecauseGiven_dir_code_Is_Not_PDU_EOF_Or_PDU_FIN */ -void Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_EOF_And_CF_CFDP_IsSender_Returns_true_GetsMsg_pdu_Returns_CF_SEND_NO_MSG(void) +void Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_EOF_And_CF_CFDP_IsSender_Returns_true_GetMsg_pdu_Return_CF_SEND_NO_MSG(void) { /* Arrange */ pdu_ack_t dummy_ack; cf_config_table_t dummy_config_table; - uint8 dummy_chan_num = Any_cf_chan_num(); history_t dummy_history; - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; ack_transaction_status_t arg_ts = Any_uint8(); file_directive_t arg_dir_code = PDU_EOF; condition_code_t arg_cc = Any_uint8(); @@ -2509,7 +2450,7 @@ void Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_EOF_And_CF_CFDP_IsSender_Ret /* Arrange for CF_CFDP_ConstructPduHeader */ /* Arrange for CF_CFDP_MsgOutGet */ - CF_AppData.engine.out.msg = &dummy_ack; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_ack; CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 0; CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; @@ -2522,16 +2463,16 @@ void Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_EOF_And_CF_CFDP_IsSender_Ret UtAssert_True(local_result == CF_SEND_SUCCESS, "CF_CFDP_SendAck returned %u and should be %u (CF_SEND_SUCCESS)", local_result, CF_SEND_SUCCESS); -} /* end Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_EOF_And_CF_CFDP_IsSender_Returns_true_GetsMsg_pdu_Returns_CF_SEND_NO_MSG */ +} /* end Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_EOF_And_CF_CFDP_IsSender_Returns_true_GetMsg_pdu_Return_CF_SEND_NO_MSG */ -void Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_FIN_And_CF_CFDP_IsSender_Returns_true_GetsMsg_ph_Return_CF_SEND_SUCCESS(void) +void Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_FIN_And_CF_CFDP_IsSender_Returns_true_GetMsg_ph_Return_CF_SEND_SUCCESS(void) { /* Arrange */ pdu_ack_t dummy_ack; cf_config_table_t dummy_config_table; - uint8 dummy_chan_num = Any_cf_chan_num(); history_t dummy_history; - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; ack_transaction_status_t arg_ts = Any_uint8(); file_directive_t arg_dir_code = PDU_EOF; condition_code_t arg_cc = Any_uint8(); @@ -2548,7 +2489,7 @@ void Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_FIN_And_CF_CFDP_IsSender_Ret /* Arrange for CF_CFDP_ConstructPduHeader */ /* Arrange for CF_CFDP_MsgOutGet */ - CF_AppData.engine.out.msg = &dummy_ack; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_ack; CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 0; CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; @@ -2561,7 +2502,7 @@ void Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_FIN_And_CF_CFDP_IsSender_Ret UtAssert_True(local_result == CF_SEND_SUCCESS, "CF_CFDP_SendAck returned %u and should be %u (CF_SEND_SUCCESS)", local_result, CF_SEND_SUCCESS); -} /* end Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_FIN_And_CF_CFDP_IsSender_Returns_true_GetsMsg_ph_Return_CF_SEND_SUCCESS */ +} /* end Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_FIN_And_CF_CFDP_IsSender_Returns_true_GetMsg_ph_Return_CF_SEND_SUCCESS */ /* end CF_CFDP_SendAck tests */ @@ -2571,13 +2512,13 @@ void Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_FIN_And_CF_CFDP_IsSender_Ret ** *******************************************************************************/ -void Test_CF_CFDP_SendFin_GetsNull_ph_Return_CF_SEND_NO_MSG(void) +void Test_CF_CFDP_SendFin_Get_NULL_ph_Return_CF_SEND_NO_MSG(void) { /* Arrange */ cf_config_table_t dummy_config_table; - uint8 dummy_chan_num = Any_cf_chan_num(); history_t dummy_history; - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; fin_delivery_code_t arg_dc = Any_uint8(); fin_file_status_t arg_fs = Any_uint8(); condition_code_t arg_cc = Any_uint8(); @@ -2601,16 +2542,16 @@ void Test_CF_CFDP_SendFin_GetsNull_ph_Return_CF_SEND_NO_MSG(void) UtAssert_True(local_result == CF_SEND_NO_MSG, "CF_CFDP_SendFin returned %u and should be %u (CF_SEND_NO_MSG)", local_result, CF_SEND_NO_MSG); -} /* end Test_CF_CFDP_SendFin_GetsNull_ph_Return_CF_SEND_NO_MSG */ +} /* end Test_CF_CFDP_SendFin_Get_NULL_ph_Return_CF_SEND_NO_MSG */ -void Test_CF_CFDP_SendFin_Given_cc_NotEqTo_CC_NO_ERROR_GetsNull_ph_Return_CF_SEND_SUCCESS(void) +void Test_CF_CFDP_SendFin_Given_cc_NotEqTo_CC_NO_ERROR_GetNull_ph_Return_CF_SEND_SUCCESS(void) { /* Arrange */ pdu_fin_t dummy_ack; cf_config_table_t dummy_config_table; - uint8 dummy_chan_num = Any_cf_chan_num(); history_t dummy_history; - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; fin_delivery_code_t arg_dc = Any_uint8(); fin_file_status_t arg_fs = Any_uint8(); condition_code_t arg_cc = CC_POS_ACK_LIMIT_REACHED; @@ -2621,7 +2562,7 @@ void Test_CF_CFDP_SendFin_Given_cc_NotEqTo_CC_NO_ERROR_GetsNull_ph_Return_CF_SEN /* Arrange for CF_CFDP_ConstructPduHeader */ /* Arrange for CF_CFDP_MsgOutGet */ - CF_AppData.engine.out.msg = &dummy_ack; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_ack; CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 0; CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; @@ -2634,16 +2575,16 @@ void Test_CF_CFDP_SendFin_Given_cc_NotEqTo_CC_NO_ERROR_GetsNull_ph_Return_CF_SEN UtAssert_True(local_result == CF_SEND_SUCCESS, "CF_CFDP_SendFin returned %u and should be %u (CF_SEND_SUCCESS)", local_result, CF_SEND_SUCCESS); -} /* end Test_CF_CFDP_SendFin_Given_cc_NotEqTo_CC_NO_ERROR_GetsNull_ph_Return_CF_SEND_SUCCESS */ +} /* end Test_CF_CFDP_SendFin_Given_cc_NotEqTo_CC_NO_ERROR_GetNull_ph_Return_CF_SEND_SUCCESS */ -void Test_CF_CFDP_SendFin_Given_cc_EqTo_CC_NO_ERROR_GetsNull_ph_Return_CF_SEND_SUCCESS(void) +void Test_CF_CFDP_SendFin_Given_cc_EqTo_CC_NO_ERROR_GetNull_ph_Return_CF_SEND_SUCCESS(void) { /* Arrange */ pdu_fin_t dummy_ack; cf_config_table_t dummy_config_table; - uint8 dummy_chan_num = Any_cf_chan_num(); history_t dummy_history; - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; fin_delivery_code_t arg_dc = Any_uint8(); fin_file_status_t arg_fs = Any_uint8(); condition_code_t arg_cc = CC_NO_ERROR; @@ -2654,7 +2595,7 @@ void Test_CF_CFDP_SendFin_Given_cc_EqTo_CC_NO_ERROR_GetsNull_ph_Return_CF_SEND_S /* Arrange for CF_CFDP_ConstructPduHeader */ /* Arrange for CF_CFDP_MsgOutGet */ - CF_AppData.engine.out.msg = &dummy_ack; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_ack; CF_AppData.config_table->chan[arg_t->chan_num].max_outgoing_messages_per_wakeup = 0; CF_AppData.hk.channel_hk[arg_t->chan_num].frozen = 0; @@ -2667,21 +2608,21 @@ void Test_CF_CFDP_SendFin_Given_cc_EqTo_CC_NO_ERROR_GetsNull_ph_Return_CF_SEND_S UtAssert_True(local_result == CF_SEND_SUCCESS, "CF_CFDP_SendFin returned %u and should be %u (CF_SEND_SUCCESS)", local_result, CF_SEND_SUCCESS); -} /* end Test_CF_CFDP_SendFin_Given_cc_EqTo_CC_NO_ERROR_GetsNull_ph_Return_CF_SEND_SUCCESS */ +} /* end Test_CF_CFDP_SendFin_Given_cc_EqTo_CC_NO_ERROR_GetNull_ph_Return_CF_SEND_SUCCESS */ /* end CF_CFDP_SendFin tests */ /******************************************************************************* ** -** CF_CFDP_SendNak tests (medium) - high coverage - 1 UNREACHABLE - [unstubbables: CF_CFDP_GetClass (simple), CF_CFDP_FinishEofAck (small), CF_CFDP_SetPduLength (simple), CF_CFDP_Send (small)] +** CF_CFDP_SendNak tests (medium) - high coverage - 2 coverage JIRA issue - [unstubbables: CF_CFDP_GetClass (simple), CF_CFDP_FinishEofAck (small), CF_CFDP_SetPduLength (simple), CF_CFDP_Send (small)] ** *******************************************************************************/ -void Test_CF_CFDP_SendNak_GetsNull_ph_Return_CF_SEND_NO_MSG(void) +void Test_CF_CFDP_SendNak_GetNull_ph_Return_CF_SEND_NO_MSG(void) { // /* Arrange */ - // uint8 dummy_chan_num = Any_cf_chan_num(); - // transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; + // uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + // transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; // int arg_num_segment_requests = 0; // cfdp_send_ret_t local_result; @@ -2694,45 +2635,59 @@ void Test_CF_CFDP_SendNak_GetsNull_ph_Return_CF_SEND_NO_MSG(void) // UtAssert_True(local_result == CF_SEND_NO_MSG, // "CF_CFDP_SendNak returned %u and should be %u (CF_SEND_NO_MSG)", // local_result, CF_SEND_NO_MSG); - UtAssert_Failed("UNREACHABLE: GSFCCFS-1689 if statement to return CF_SEND_NO_MSG"); -} /* end Test_CF_CFDP_SendNak_GetsNull_ph_Return_CF_SEND_NO_MSG */ + UtAssert_MIR("JIRA: GSFCCFS-1689 if statement to return CF_SEND_NO_MSG"); +} /* end Test_CF_CFDP_SendNak_GetNull_ph_Return_CF_SEND_NO_MSG */ -void Test_CF_CFDP_SendNak_Asserts_CF_CFDP_GetClass_With_t_Eq_CLASS_2(void) +void Test_CF_CFDP_SendNak_AssertsBecause_CF_CFDP_GetClass_With_t_Eq_CLASS_2(void) { - /* Arrange */ - pdu_nak_t dummy_nak; - uint8 dummy_chan_num = Any_cf_chan_num(); - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; - int arg_num_segment_requests; - cfdp_send_ret_t local_result; + // /* Arrange */ + // pdu_nak_t dummy_nak; + // uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + // transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; + // int arg_num_segment_requests; + // cfdp_send_ret_t local_result; - CF_AppData.engine.out.msg = &dummy_nak; + // CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_nak; - /* Arrange for CF_CFDP_GetClass */ - arg_t->flags.all.q_index = Any_uint8_LessThan(CF_Q_FREE); - arg_t->state = CFDP_S1; /* ensures failre */ + // /* Arrange for CF_CFDP_GetClass */ + // arg_t->flags.all.q_index = Any_uint8_LessThan(CF_Q_FREE); + // arg_t->state = CFDP_S1; /* ensures failre */ - /* Act */ + // /* Act */ // local_result = CF_CFDP_SendNak(arg_t, arg_num_segment_requests); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CFDP_SendNak_Asserts_CF_CFDP_GetClass_With_t_Eq_CLASS_2 */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - CF_CFDP_GetClass(t)==CLASS_2"); +} /* end Test_CF_CFDP_SendNak_AssertsBecause_CF_CFDP_GetClass_With_t_Eq_CLASS_2 */ void Test_CF_CFDP_SendNak_Success_Return_CF_SEND_SUCCESS(void) { /* Arrange */ - pdu_nak_t dummy_nak; + CFE_SB_Buffer_t dummy_msg; + pdu_s_msg_t* dummy_s_msg; + pdu_nak_t* dummy_nak; uint8 dummy_chan_num = Any_cf_chan_num(); - transaction_t* arg_t = &CF_AppData.engine.channels[dummy_chan_num]; + uint8 dummy_transaction_num = Any_uint8_LessThan(CF_NUM_TRANSACTIONS); + transaction_t* arg_t = &CF_AppData.engine.transactions[dummy_transaction_num]; int arg_num_segment_requests = 1; + int forced_return_CF_HeaderSize = 10; cfdp_send_ret_t local_result; - CF_AppData.engine.out.msg = &dummy_nak; + dummy_s_msg = (pdu_s_msg_t*)&dummy_msg; + dummy_nak = (pdu_nak_t*)&dummy_s_msg->ph; + + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&dummy_s_msg; + + UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &forced_return_CF_HeaderSize); + + dummy_nak->scope_start = 0; + dummy_nak->scope_end = 1; + arg_t->chan_num = dummy_chan_num; + /* Arrange for CF_CFDP_GetClass */ - arg_t->flags.all.q_index = Any_uint8_LessThan(CF_Q_FREE); + arg_t->flags.all.q_index = CF_Q_PEND; arg_t->state = CFDP_S2; /* ensures pass */ /* Act */ @@ -2748,25 +2703,25 @@ void Test_CF_CFDP_SendNak_Success_Return_CF_SEND_SUCCESS(void) /******************************************************************************* ** -** CF_CFDP_RecvPh tests (large) - full coverge - 2 CF_Assert - [] +** CF_CFDP_RecvPh tests (large) - full coverge - 2 coverage JIRA issue - [] ** *******************************************************************************/ -void Test_CF_CFDP_RecvPh_Asserts_chan_num_GreaterThan_CF_NUM_CHANNELS(void) +void Test_CF_CFDP_RecvPh_AssertsBecause_chan_num_GreaterThan_CF_NUM_CHANNELS(void) { /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CFDP_RecvPh_Asserts_chan_num_GreaterThan_CF_NUM_CHANNELS */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - chan_numchan_num].counters.recv.error, expected_counters_recv_error); -} /* end Test_CF_CFDP_RecvMd_Has_bytes_received_LessThan_sizof_ph_Plus_size_of_pdu_md_t_CountsErrorReturns_neg1 */ +} /* end Test_CF_CFDP_RecvMd_Has_bytes_received_LessThan_sizof_ph_Plus_size_of_pdu_md_t_CountErrorReturn_neg1 */ -/* TODO: Test_CF_CFDP_RecvMd_HasFirst_lv_ret_LessThan_0_SendsEventCountsErrorAndReturns_neg1 at received==size */ +/* NOTE: Test_CF_CFDP_RecvMd_HasFirst_lv_ret_LessThan_0_SendsEventCountErrorAndReturn_neg1 at received==size */ -void Test_CF_CFDP_RecvMd_HasFirst_lv_ret_LessThan_0_SendsEventCountsErrorAndReturns_neg1(void) +void Test_CF_CFDP_RecvMd_HasFirst_lv_ret_LessThan_0_SendsEventCountErrorAndReturn_neg1(void) { /* Arrange */ history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; + CFE_SB_Buffer_t dummy_msg; + pdu_header_t* dummy_ph; const char* expected_Spec = "CF: metadata pdu rejected due to invalid length in source filename of 0x%02x"; uint32 expected_counters_recv_error = Any_uint32(); - int force_return_CF_HeaderSize = Any_uint8_BetweenExcludeMax(6, 64); /* Any_uint8_BetweenExcludeMax(6, 64) to ensure reasonable values for test, large values cause segfaults */ - pdu_md_t* dummy_msg_in = (uint8*)dummy_ph + force_return_CF_HeaderSize; + int force_return_CF_HeaderSize = 6; /* force_return_CF_HeaderSize = 6 as a reasonable size */ + pdu_md_t* dummy_md; int local_result; + CF_AppData.engine.in.msg = &dummy_msg; + dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; + dummy_md = (pdu_md_t*)((uint8*)dummy_ph + force_return_CF_HeaderSize); + CF_AppData.engine.in.bytes_received = sizeof(pdu_md_t) + force_return_CF_HeaderSize; UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &force_return_CF_HeaderSize); - dummy_msg_in->size = Any_uint32(); + dummy_md->size = Any_uint32(); arg_t->history = &dummy_history; UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); /* Arrange unstubbable: CF_CFDP_CopyDataFromLv */ - ((lv_t*)dummy_msg_in->filename_lvs)->length = 64; /* 64 is a fail for -1 return */ + ((lv_t*)dummy_md->filename_lvs)->length = 64; /* 64 is a fail for -1 return */ arg_t->chan_num = Any_cf_chan_num(); CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.error = expected_counters_recv_error - 1; @@ -3063,33 +3023,38 @@ void Test_CF_CFDP_RecvMd_HasFirst_lv_ret_LessThan_0_SendsEventCountsErrorAndRetu "CFE_EVS_SendEvent received expected Spec\n'%s' - Received\n'%s' - Expected", context_CFE_EVS_SendEvent.Spec, expected_Spec); UtAssert_UINT32_EQ(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.error, expected_counters_recv_error); -} /* end Test_CF_CFDP_RecvMd_HasFirst_lv_ret_LessThan_0_SendsEventCountsErrorAndReturns_neg1 */ +} /* end Test_CF_CFDP_RecvMd_HasFirst_lv_ret_LessThan_0_SendsEventCountErrorAndReturn_neg1 */ -void Test_CF_CFDP_RecvMd_HasSecond_lv_ret_LessThan_0_BecauseLengthEqSizeSendsEventAndReturns_neg1(void) +void Test_CF_CFDP_RecvMd_HasSecond_lv_ret_LessThan_0_BecauseLengthEqSizeSendEventAndReturn_neg1(void) { /* Arrange */ history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; + CFE_SB_Buffer_t dummy_msg; + pdu_header_t* dummy_ph; const char* expected_Spec = "CF: metadata pdu rejected due to invalid length in dest filename of 0x%02x"; uint32 expected_counters_recv_error = Any_uint32(); - int force_return_CF_HeaderSize = Any_uint8_BetweenExcludeMax(6, 64); /* Any_uint8_BetweenExcludeMax(6, 64) to ensure reasonable values for test, large values cause segfaults */ - pdu_md_t* dummy_msg_in = (uint8*)dummy_ph + force_return_CF_HeaderSize; + int force_return_CF_HeaderSize = 6; /* force_return_CF_HeaderSize = 6 as a reasonable size */ + pdu_md_t* dummy_md; int local_result; + CF_AppData.engine.in.msg = &dummy_msg; + dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; + dummy_md = (pdu_md_t*)((uint8*)dummy_ph + force_return_CF_HeaderSize); + CF_AppData.engine.in.bytes_received = sizeof(pdu_md_t) + force_return_CF_HeaderSize; UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &force_return_CF_HeaderSize); - dummy_msg_in->size = Any_uint32(); + dummy_md->size = Any_uint32(); arg_t->history = &dummy_history; UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); /* Arrange unstubbable: CF_CFDP_CopyDataFromLv */ - ((lv_t*)dummy_msg_in->filename_lvs)->length = 1; /* 19 is arbitrary but small enough to work */ - ((lv_t*)(dummy_msg_in->filename_lvs + 2))->length = 64; /* 64 is a fail for -1 return */ + ((lv_t*)dummy_md->filename_lvs)->length = 1; /* 19 is arbitrary but small enough to work */ + ((lv_t*)(dummy_md->filename_lvs + 2))->length = 64; /* 64 is a fail for -1 return */ arg_t->chan_num = Any_cf_chan_num(); CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.error = expected_counters_recv_error - 1; @@ -3112,33 +3077,38 @@ void Test_CF_CFDP_RecvMd_HasSecond_lv_ret_LessThan_0_BecauseLengthEqSizeSendsEve "CFE_EVS_SendEvent received expected Spec\n'%s' - Received\n'%s' - Expected", context_CFE_EVS_SendEvent.Spec, expected_Spec); UtAssert_UINT32_EQ(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.error, expected_counters_recv_error); -} /* end Test_CF_CFDP_RecvMd_HasSecond_lv_ret_LessThan_0_BecauseLengthEqSizeSendsEventAndReturns_neg1 */ +} /* end Test_CF_CFDP_RecvMd_HasSecond_lv_ret_LessThan_0_BecauseLengthEqSizeSendEventAndReturn_neg1 */ -void Test_CF_CFDP_RecvMd_SendsEventAndReturns_0_WhenNoErrorConditions(void) +void Test_CF_CFDP_RecvMd_WhenNoErrorConditions_SendEventAndReturn_0(void) { - /* Arrange */ + /* Arrange */ history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - pdu_header_t* dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; + CFE_SB_Buffer_t dummy_msg; + pdu_header_t* dummy_ph; const char* expected_Spec = "CF: md received for source: %s, dest: %s"; uint32 initial_counters_recv_error = Any_uint32(); - int force_return_CF_HeaderSize = Any_uint8_BetweenExcludeMax(6, 64); /* Any_uint8_BetweenExcludeMax(6, 64) to ensure reasonable values for test, large values cause segfaults */ - pdu_md_t* dummy_msg_in = (uint8*)dummy_ph + force_return_CF_HeaderSize; + int force_return_CF_HeaderSize = 6; /* Any_uint8_BetweenExcludeMax(6, 64) to ensure reasonable values for test, large values cause segfaults */ + pdu_md_t* dummy_md; int local_result; + CF_AppData.engine.in.msg = &dummy_msg; + dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; + dummy_md = (pdu_md_t*)((uint8*)dummy_ph + force_return_CF_HeaderSize); + CF_AppData.engine.in.bytes_received = sizeof(pdu_md_t) + force_return_CF_HeaderSize; UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &force_return_CF_HeaderSize); - dummy_msg_in->size = Any_uint32(); + dummy_md->size = Any_uint32(); arg_t->history = &dummy_history; UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); /* Arrange unstubbable: CF_CFDP_CopyDataFromLv */ - ((lv_t*)dummy_msg_in->filename_lvs)->length = 1; /* 19 is arbitrary but small enough to work */ - ((lv_t*)(dummy_msg_in->filename_lvs + 2))->length = 1; /* 1 gets us a success, for a non-negative return */ + ((lv_t*)dummy_md->filename_lvs)->length = 1; /* 19 is arbitrary but small enough to work */ + ((lv_t*)(dummy_md->filename_lvs + 2))->length = 1; /* 1 gets us a success, for a non-negative return */ arg_t->chan_num = Any_cf_chan_num(); CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.error = initial_counters_recv_error; @@ -3161,25 +3131,25 @@ void Test_CF_CFDP_RecvMd_SendsEventAndReturns_0_WhenNoErrorConditions(void) "CFE_EVS_SendEvent received expected Spec\n'%s' - Received\n'%s' - Expected", context_CFE_EVS_SendEvent.Spec, expected_Spec); UtAssert_UINT32_EQ(CF_AppData.hk.channel_hk[arg_t->chan_num].counters.recv.error, initial_counters_recv_error); -} /* end Test_CF_CFDP_RecvMd_SendsEventAndReturns_0_WhenNoErrorConditions */ +} /* end Test_CF_CFDP_RecvMd_WhenNoErrorConditions_SendEventAndReturn_0 */ /* end CF_CFDP_RecvMd tests */ /******************************************************************************* ** -** CF_CFDP_RecvFd tests (medium) - full coverage - 1 CF_Assert - [] +** CF_CFDP_RecvFd tests (medium) - full coverage - 1 coverage JIRA issue - [] ** *******************************************************************************/ void Test_CF_CFDP_RecvFd_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL(void) { - /* Arrange */ - /* Act */ - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Arrange */ + // /* Act */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - CF_AppData.engine.in.msg"); } /* end Test_CF_CFDP_RecvFd_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL */ -void Test_CF_CFDP_RecvFd_FailsAndSendsEventBecause_bytes_received_LessThan_sizeof_pdu_file_data_header_t_CountsErrorAndReturns_neg1(void) +void Test_CF_CFDP_RecvFd_When_bytes_received_LessThan_sizeof_pdu_file_data_header_t_CountsErrorAndReturns_neg1_FailAndSendsEvent(void) { /* Arrange */ transaction_t dummy_t; @@ -3190,7 +3160,7 @@ void Test_CF_CFDP_RecvFd_FailsAndSendsEventBecause_bytes_received_LessThan_sizeo int force_return_CF_HeaderSize = Any_uint8_Except(0); /* Any_uint8_Except(0) for positive result with reasonably expected size */ int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = Any_uint32_LessThan(force_return_CF_HeaderSize + sizeof(pdu_file_data_header_t));// TODO Any_CFE_MSG_Size_t_LessThan(); arg_t->chan_num = Any_uint8_LessThan(CF_NUM_CHANNELS); @@ -3218,21 +3188,20 @@ void Test_CF_CFDP_RecvFd_FailsAndSendsEventBecause_bytes_received_LessThan_sizeo UtAssert_True(local_result == -1, "CF_CFDP_RecvFd received %d and should be -1", local_result); -} /* end Test_CF_CFDP_RecvFd_FailsAndSendsEventBecause_bytes_received_LessThan_sizeof_pdu_file_data_header_t_CountsErrorAndReturns_neg1 */ +} /* end Test_CF_CFDP_RecvFd_When_bytes_received_LessThan_sizeof_pdu_file_data_header_t_CountsErrorAndReturns_neg1_FailAndSendsEvent */ /* TODO: EXAMPLE: Good example of why not checking things is not verifying behavior */ -void Test_CF_CFDP_RecvFd_Success_bytes_received_EqTo_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset(void) +void Test_CF_CFDP_RecvFd_When_bytes_received_EqTo_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset_Success(void) { /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_r_msg_t dummy_msg_in; - const char* expected_Spec = "CF: filedata pdu too short: %d bytes received"; uint32 initial_counters_recv_error = Any_uint32(); int force_return_CF_HeaderSize = Any_uint8_Except(0); /* Any_uint8_Except(0) for positive result with reasonably expected size */ int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = force_return_CF_HeaderSize + sizeof(pdu_file_data_header_t); arg_t->chan_num = Any_uint8_LessThan(CF_NUM_CHANNELS); @@ -3250,20 +3219,19 @@ void Test_CF_CFDP_RecvFd_Success_bytes_received_EqTo_sizeof_pdu_file_data_header UtAssert_True(local_result == 0, "CF_CFDP_RecvFd received %d and should be 0", local_result); -} /* end Test_CF_CFDP_RecvFd_Success_bytes_received_EqTo_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset */ +} /* end Test_CF_CFDP_RecvFd_When_bytes_received_EqTo_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset_Success */ -void Test_CF_CFDP_RecvFd_Success_bytes_received_GreaterThan_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset(void) +void Test_CF_CFDP_RecvFd_When_bytes_received_GreaterThan_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset_Success(void) { /* Arrange */ transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_r_msg_t dummy_msg_in; - const char* expected_Spec = "CF: filedata pdu too short: %d bytes received"; uint32 initial_counters_recv_error = Any_uint32(); int force_return_CF_HeaderSize = Any_uint8_Except(0); /* Any_uint8_Except(0) for positive result with reasonably expected size */ int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = Any_uint32_GreaterThan(force_return_CF_HeaderSize + sizeof(pdu_file_data_header_t)); arg_t->chan_num = Any_uint8_LessThan(CF_NUM_CHANNELS); @@ -3281,13 +3249,13 @@ void Test_CF_CFDP_RecvFd_Success_bytes_received_GreaterThan_sizeof_pdu_file_data UtAssert_True(local_result == 0, "CF_CFDP_RecvFd received %d and should be 0", local_result); -} /* end Test_CF_CFDP_RecvFd_Success_bytes_received_GreaterThan_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset */ +} /* end Test_CF_CFDP_RecvFd_When_bytes_received_GreaterThan_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset_Success */ /* end CF_CFDP_RecvFd tests */ /******************************************************************************* ** -** CF_CFDP_RecvEof tests (medium) - full coverage - 1 CF_ASsert - [] +** CF_CFDP_RecvEof tests (medium) - full coverage - 1 coverage JIRA issue - [] ** *******************************************************************************/ @@ -3296,19 +3264,18 @@ void Test_CF_CFDP_RecvEof_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL(void) /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - CF_AppData.engine.in.msg"); } /* end Test_CF_CFDP_RecvEof_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL */ -void Test_CF_CFDP_RecvEof_Fails_bytes_received_LessThan_offsetof_pdu_eof_t_fault_location_Returns_neg1(void) +void Test_CF_CFDP_RecvEof_When_bytes_received_LessThan_offsetof_pdu_eof_t_fault_location_Returns_neg1_Fail(void) { /* Arrange */ pdu_r_msg_t dummy_msg_in; const char* expected_Spec = "CF: eof pdu too short: %d bytes received"; - uint32 expected_counters_recv_error = Any_uint32(); int force_return_CF_HeaderSize = Any_uint8_Except(0); /* Any_uint8_Except(0) for positive result with reasonably expected size */ int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = Any_uint32_LessThan(force_return_CF_HeaderSize + offsetof(pdu_eof_t, fault_location)); UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &force_return_CF_HeaderSize); @@ -3332,18 +3299,16 @@ void Test_CF_CFDP_RecvEof_Fails_bytes_received_LessThan_offsetof_pdu_eof_t_fault UtAssert_True(local_result == -1, "CF_CFDP_RecvFd received %d and should be -1", local_result); -} /* end Test_CF_CFDP_RecvEof_Fails_bytes_received_LessThan_offsetof_pdu_eof_t_fault_location_Returns_neg1 */ +} /* end Test_CF_CFDP_RecvEof_When_bytes_received_LessThan_offsetof_pdu_eof_t_fault_location_Returns_neg1_Fail */ -void Test_CF_CFDP_RecvEof_BytesReceivedEq_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Returns_0 (void) +void Test_CF_CFDP_RecvEof_BytesReceivedEq_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Return_0 (void) { /* Arrange */ pdu_r_msg_t dummy_msg_in; - const char* expected_Spec = "CF: eof pdu too short: %d bytes received"; - uint32 expected_counters_recv_error = Any_uint32(); int force_return_CF_HeaderSize = Any_uint8_Except(0); /* Any_uint8_Except(0) for positive result with reasonably expected size */ int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = force_return_CF_HeaderSize + offsetof(pdu_eof_t, fault_location); UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &force_return_CF_HeaderSize); @@ -3358,18 +3323,16 @@ void Test_CF_CFDP_RecvEof_BytesReceivedEq_offsetof_fault_location_Calls_cfdp_get UtAssert_True(local_result == 0, "CF_CFDP_RecvFd received %d and should be 0", local_result); -} /* end Test_CF_CFDP_RecvEof_BytesReceivedEq_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Returns_0 */ +} /* end Test_CF_CFDP_RecvEof_BytesReceivedEq_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Return_0 */ -void Test_CF_CFDP_RecvEof_BytesReceivedGreaterThan_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Returns_0 (void) +void Test_CF_CFDP_RecvEof_BytesReceivedGreaterThan_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Return_0 (void) { /* Arrange */ pdu_r_msg_t dummy_msg_in; - const char* expected_Spec = "CF: eof pdu too short: %d bytes received"; - uint32 expected_counters_recv_error = Any_uint32(); int force_return_CF_HeaderSize = Any_uint8_Except(0); /* Any_uint8_Except(0) for positive result with reasonably expected size */ int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = Any_uint32_GreaterThan(force_return_CF_HeaderSize + offsetof(pdu_eof_t, fault_location)); UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &force_return_CF_HeaderSize); @@ -3384,22 +3347,22 @@ void Test_CF_CFDP_RecvEof_BytesReceivedGreaterThan_offsetof_fault_location_Calls UtAssert_True(local_result == 0, "CF_CFDP_RecvFd received %d and should be 0", local_result); -} /* end Test_CF_CFDP_RecvEof_BytesReceivedGreaterThan_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Returns_0 */ +} /* end Test_CF_CFDP_RecvEof_BytesReceivedGreaterThan_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Return_0 */ /* end CF_CFDP_RecvEof tests */ /******************************************************************************* ** -** CF_CFDP_RecvAck tests (small) - full coverage - 1 CF_Assert - [] +** CF_CFDP_RecvAck tests (small) - full coverage - 1 coverage JIRA issue - [] ** *******************************************************************************/ void Test_CF_CFDP_RecvAck_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL(void) { - /* Arrange */ - /* Act */ - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Arrange */ + // /* Act */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - CF_AppData.engine.in.msg"); } /* end Test_CF_CFDP_RecvAck_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL */ void Test_CF_CFDP_RecvAck_FailsBecause_bytes_received_LessThan_sizeof_pdu_ack_t_Returns_neg1(void) @@ -3407,10 +3370,9 @@ void Test_CF_CFDP_RecvAck_FailsBecause_bytes_received_LessThan_sizeof_pdu_ack_t_ /* Arrange */ pdu_r_msg_t dummy_msg_in; const char* expected_Spec = "CF: ack pdu too short: %d bytes received"; - uint32 expected_counters_recv_error = Any_uint32(); int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = Any_uint32_LessThan(sizeof(pdu_ack_t));// Any_CFE_MSG_Size_t(); UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); @@ -3438,11 +3400,9 @@ void Test_CF_CFDP_RecvAck_SuccessBecause_bytes_received_EqTo_sizeof_pdu_ack_t_Re { /* Arrange */ pdu_r_msg_t dummy_msg_in; - const char* expected_Spec = "CF: ack pdu too short: %ld bytes received"; - uint32 expected_counters_recv_error = Any_uint32(); int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = sizeof(pdu_ack_t); UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); @@ -3461,11 +3421,9 @@ void Test_CF_CFDP_RecvAck_SuccessBecause_bytes_received_GreaterThan_sizeof_pdu_a { /* Arrange */ pdu_r_msg_t dummy_msg_in; - const char* expected_Spec = "CF: ack pdu too short: %ld bytes received"; - uint32 expected_counters_recv_error = Any_uint32(); int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = Any_uint32_GreaterThan(sizeof(pdu_ack_t)); UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); @@ -3490,10 +3448,10 @@ void Test_CF_CFDP_RecvAck_SuccessBecause_bytes_received_GreaterThan_sizeof_pdu_a void Test_CF_CFDP_RecvFin_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL(void) { - /* Arrange */ - /* Act */ - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Arrange */ + // /* Act */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - CF_AppData.engine.in.msg"); } /* end Test_CF_CFDP_RecvFin_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL */ void Test_CF_CFDP_RecvFin_FailsBecause_bytes_received_IsLessThan_offsetof_pdu_fin_t_fault_location_Returns_neg1(void) @@ -3501,10 +3459,9 @@ void Test_CF_CFDP_RecvFin_FailsBecause_bytes_received_IsLessThan_offsetof_pdu_fi /* Arrange */ pdu_r_msg_t dummy_msg_in; const char* expected_Spec = "CF: fin pdu too short: %d bytes received"; - uint32 expected_counters_recv_error = Any_uint32(); int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = Any_uint32_LessThan(offsetof(pdu_fin_t, fault_location)); UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); @@ -3533,10 +3490,9 @@ void Test_CF_CFDP_RecvFin_FailsBecause_bytes_received_Is_1_LessThan_offsetof_pdu /* Arrange */ pdu_r_msg_t dummy_msg_in; const char* expected_Spec = "CF: fin pdu too short: %d bytes received"; - uint32 expected_counters_recv_error = Any_uint32(); int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = offsetof(pdu_fin_t, fault_location) - 1; UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); @@ -3564,10 +3520,9 @@ void Test_CF_CFDP_RecvFin_SuccessBecause_bytes_received_IsEqTo_offsetof_pdu_fin_ { /* Arrange */ pdu_r_msg_t dummy_msg_in; - uint32 expected_counters_recv_error = Any_uint32(); int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = offsetof(pdu_fin_t, fault_location); UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); @@ -3586,10 +3541,9 @@ void Test_CF_CFDP_RecvFin_SuccessBecause_bytes_received_IsGreaterThan_offsetof_p { /* Arrange */ pdu_r_msg_t dummy_msg_in; - uint32 expected_counters_recv_error = Any_uint32(); int local_result; - CF_AppData.engine.in.msg = &dummy_msg_in; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg_in; CF_AppData.engine.in.bytes_received = Any_uint32_GreaterThan(offsetof(pdu_fin_t, fault_location)); UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); @@ -3608,7 +3562,7 @@ void Test_CF_CFDP_RecvFin_SuccessBecause_bytes_received_IsGreaterThan_offsetof_p /******************************************************************************* ** -** CF_CFDP_RecvNak tests (medium) - full coverage - 2 CF_Assert - [] +** CF_CFDP_RecvNak tests (medium) - full coverage - 2 coverage JIRA issue - [] ** *******************************************************************************/ @@ -3617,7 +3571,7 @@ void Test_CF_CFDP_RecvNak_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL(void) /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - CF_AppData.engine.in.msg"); } /* end Test_CF_CFDP_RecvNak_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL */ void Test_CF_CFDP_RecvNak_AssertsBecause_num_segment_requests_Is_NULL(void) @@ -3625,7 +3579,7 @@ void Test_CF_CFDP_RecvNak_AssertsBecause_num_segment_requests_Is_NULL(void) /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - num_segment_requests"); } /* end Test_CF_CFDP_RecvNak_AssertsBecause_num_segment_requests_Is_NULL */ void Test_CF_CFDP_RecvNak_FailsBecause_bytes_received_IsLessThan_CF_HeaderSize_Plus_offsetof_pdu_nak_t_segment_requests_Return_neg1(void) @@ -3673,8 +3627,6 @@ void Test_CF_CFDP_RecvNak_bytes_received_IsEqTo_CF_HeaderSize_Plus_offsetof_pdu_ CF_AppData.engine.in.bytes_received = force_return_CF_HeaderSize + offsetof(pdu_nak_t, segment_requests[1]); UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &force_return_CF_HeaderSize); - - pdu_nak_t* dummy_nak = (pdu_nak_t*)&dummy_msg; /* Act */ local_result = CF_CFDP_RecvNak(arg_num_segment_requests); @@ -3702,8 +3654,6 @@ void Test_CF_CFDP_RecvNak_bytes_received_IsEqTo_CF_HeaderSize_Plus_offsetof_pdu_ CF_AppData.engine.in.bytes_received = force_return_CF_HeaderSize + offsetof(pdu_nak_t, segment_requests[CF_NAK_MAX_SEGMENTS - 1]); UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &force_return_CF_HeaderSize); - - pdu_nak_t* dummy_nak = (pdu_nak_t*)&dummy_msg; /* Act */ local_result = CF_CFDP_RecvNak(arg_num_segment_requests); @@ -3731,8 +3681,6 @@ void Test_CF_CFDP_RecvNak_bytes_received_IsEqTo_CF_HeaderSize_Plus_offsetof_pdu_ CF_AppData.engine.in.bytes_received = force_return_CF_HeaderSize + offsetof(pdu_nak_t, segment_requests[CF_NAK_MAX_SEGMENTS]); UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &force_return_CF_HeaderSize); - - pdu_nak_t* dummy_nak = (pdu_nak_t*)&dummy_msg; /* Act */ local_result = CF_CFDP_RecvNak(arg_num_segment_requests); @@ -3761,8 +3709,6 @@ void Test_CF_CFDP_RecvNak_bytes_received_IsEqTo_CF_HeaderSize_Plus_offsetof_pdu_ CF_AppData.engine.in.bytes_received = force_return_CF_HeaderSize + offsetof(pdu_nak_t, segment_requests[CF_NAK_MAX_SEGMENTS]) + segment_size; UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &force_return_CF_HeaderSize); - - pdu_nak_t* dummy_nak = (pdu_nak_t*)&dummy_msg; /* Act */ local_result = CF_CFDP_RecvNak(arg_num_segment_requests); @@ -3831,23 +3777,23 @@ void Test_CF_CFDP_RecvDrop_IncrementsCounterIn_CF_AppData_AndItRollsOver(void) /******************************************************************************* ** -** CF_CFDP_RecvIdle tests (very large) - full coverage - 1 CF_Assert - [unstubbables: CF_CFDP_FindUnusedChunks (small), CF_CFDP_DispatchRecv (small) [unstubbables: CF_CFDP_ArmInactTimer (simple)], CF_CFDP_RecvMd (large), CF_CFDP_ResetTransaction (large) [unstubbables: CF_CFDP_IsSender (simple), CF_CList_InsertBack_Ex (simple), CF_CFDP_IsSender (simple), CF_CFDP_FreeTransaction (small), [unstubbables: CF_CList_InsertBack_Ex (simple)]]] +** CF_CFDP_RecvIdle tests (very large) - full coverage - 1 coverge JIRA issue - [unstubbables: CF_CFDP_FindUnusedChunks (small), CF_CFDP_DispatchRecv (small) [unstubbables: CF_CFDP_ArmInactTimer (simple)], CF_CFDP_RecvMd (large), CF_CFDP_ResetTransaction (large) [unstubbables: CF_CFDP_IsSender (simple), CF_CList_InsertBack_Ex (simple), CF_CFDP_IsSender (simple), CF_CFDP_FreeTransaction (small), [unstubbables: CF_CList_InsertBack_Ex (simple)]]] ** *******************************************************************************/ void Test_CF_CFDP_RecvIdle_AssertBecause_CF_AppData_engine_in_msg_Is_NULL(void) { - /* Arrange */ - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; + // /* Arrange */ + // transaction_t dummy_t; + // transaction_t* arg_t = &dummy_t; - CF_AppData.engine.in.msg = NULL; + // CF_AppData.engine.in.msg = NULL; - /* Act */ + // /* Act */ // CF_CFDP_RecvIdle(arg_t); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); } /* end Test_CF_CFDP_RecvIdle_AssertBecause_CF_AppData_engine_in_msg_Is_NULL */ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_And_PDU_HDR_FLAGS_MODE_AreBoth_true_Set_t_state_To_CFDP_DROP(void) @@ -3858,13 +3804,13 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_And_PDU_HDR_FLAGS_MODE_Are transaction_t* arg_t = &dummy_t; CFE_SB_Buffer_t dummy_msg; - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; arg_t->history = &dummy_history; arg_t->chan_num = Any_cf_chan_num(); - UT_SetDefaultReturnValue(FGV, 1); + UT_SetDefaultReturnValue(UT_KEY(FGV), 1); arg_t->state = Any_uint8_Except(CFDP_DROP); /* arg_t->state = Any_uint8_Except(CFDP_DROP) not required by helpful for test verification */ @@ -3873,10 +3819,11 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_And_PDU_HDR_FLAGS_MODE_Are channel_t* ptr_c = &dummy_c; chunks_wrapper_t dummy_CF_CFDP_FindUnusedChunks_result; chunks_wrapper_t* forced_CF_CFDP_FindUnusedChunks_result = &dummy_CF_CFDP_FindUnusedChunks_result; - clist_node forced_return_CF_CList_Pop; + clist_node_t dummy_c_list_node; + clist_node forced_return_CF_CList_Pop = &dummy_c_list_node; CF_CList_Pop_context_t context_CF_CList_Pop; - CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = 1; + CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = forced_return_CF_CList_Pop; forced_return_CF_CList_Pop = &forced_CF_CFDP_FindUnusedChunks_result->cl_node; ptr_c->cs[CF_DIR_RX] = (clist_node)&forced_return_CF_CList_Pop; @@ -3905,14 +3852,14 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Is_true_And_PDU_HDR_FLAGS_ transaction_t* arg_t = &dummy_t; CFE_SB_Buffer_t dummy_msg; - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; arg_t->history = &dummy_history; arg_t->chan_num = Any_cf_chan_num(); - UT_SetDefaultReturnValue(FGV, 1); - UT_SetDeferredRetcode(FGV, 2, 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 1); + UT_SetDeferredRetcode(UT_KEY(FGV), 2, 0); arg_t->state = Any_uint8_Except(CFDP_R2); /* arg_t->state = Any_uint8_Except(CFDP_R2) not required by helpful for test verification */ @@ -3921,10 +3868,11 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Is_true_And_PDU_HDR_FLAGS_ channel_t* ptr_c = &dummy_c; chunks_wrapper_t dummy_CF_CFDP_FindUnusedChunks_result; chunks_wrapper_t* forced_CF_CFDP_FindUnusedChunks_result = &dummy_CF_CFDP_FindUnusedChunks_result; - clist_node forced_return_CF_CList_Pop; + clist_node_t dummy_c_list_node; + clist_node forced_return_CF_CList_Pop = &dummy_c_list_node; CF_CList_Pop_context_t context_CF_CList_Pop; - CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = 1; + CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = forced_return_CF_CList_Pop; forced_return_CF_CList_Pop = &forced_CF_CFDP_FindUnusedChunks_result->cl_node; ptr_c->cs[CF_DIR_RX] = (clist_node)&forced_return_CF_CList_Pop; @@ -3966,14 +3914,14 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Is_true_And_PDU_HDR_FLAGS_ transaction_t* arg_t = &dummy_t; CFE_SB_Buffer_t dummy_msg; - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; arg_t->history = &dummy_history; arg_t->chan_num = Any_cf_chan_num(); - UT_SetDefaultReturnValue(FGV, 1); - UT_SetDeferredRetcode(FGV, 2, 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 1); + UT_SetDeferredRetcode(UT_KEY(FGV), 2, 0); arg_t->state = Any_uint8_Except(CFDP_R2); /* arg_t->state = Any_uint8_Except(CFDP_R2) not required by helpful for test verification */ @@ -3982,10 +3930,11 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Is_true_And_PDU_HDR_FLAGS_ channel_t* ptr_c = &dummy_c; chunks_wrapper_t dummy_CF_CFDP_FindUnusedChunks_result; chunks_wrapper_t* forced_CF_CFDP_FindUnusedChunks_result = &dummy_CF_CFDP_FindUnusedChunks_result; - clist_node forced_return_CF_CList_Pop; + clist_node_t dummy_c_list_node; + clist_node forced_return_CF_CList_Pop = &dummy_c_list_node; CF_CList_Pop_context_t context_CF_CList_Pop; - CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = 1; + CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = forced_return_CF_CList_Pop; forced_return_CF_CList_Pop = &forced_CF_CFDP_FindUnusedChunks_result->cl_node; ptr_c->cs[CF_DIR_RX] = (clist_node)&forced_return_CF_CList_Pop; @@ -4007,6 +3956,11 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Is_true_And_PDU_HDR_FLAGS_ arg_t->history->dir = CF_DIR_TX; arg_t->p = NULL; /* arg_t->p = NULL bypasses an unnecessary branch */ + /* Arrange for CF_CFDP_ResetTransaction */ + channel_t* fake_c = &CF_AppData.engine.channels[arg_t->chan_num]; + + fake_c->num_cmd_tx = 1; /* fake_c->num_cmd_tx = 1; bypasses CF_Assert(c->num_cmd_tx) */ + /* Act */ CF_CFDP_RecvIdle(arg_t); @@ -4022,7 +3976,7 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Is_true_And_PDU_HDR_FLAGS_ UtAssert_STUB_COUNT(CF_CFDP_R2_Recv, 1); UtAssert_STUB_COUNT(CF_Timer_InitRelSec, 1); /* Assert for CF_CFDP_ResetTransaction */ - UtAssert_STUB_COUNT(CF_CList_InsertBack, 3); /* 1 directly in CF_CFDP_ResetTransaction, other two called from CF_CList_InsertBack_Ex (one of those in CF_CFDP_FreeTransaction) */ + UtAssert_STUB_COUNT(CF_CList_InsertBack, 1); } /* end Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Is_true_And_PDU_HDR_FLAGS_MODE_Is_false_Set_t_state_To_CFDP_R2_And_Call_CF_CFDP_R_Init_And_CF_CFDP_DispatchRecv_t_state_ChangedTo_CFDP_IDLE_DoReset */ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Returns_false_But_fdh_directive_code_IsNot_PDU_METADATA_SendEventAnd_Increment_recv_error(void) @@ -4039,13 +3993,13 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Returns_false_But_fdh_dire ((pdu_file_directive_header_t*)&dummy_msg.ph)->directive_code = Any_file_directive_t_Except(PDU_METADATA); - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; arg_t->history = &dummy_history; arg_t->chan_num = Any_cf_chan_num(); - UT_SetDefaultReturnValue(FGV, 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); arg_t->state = initial_t_state; @@ -4058,10 +4012,11 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Returns_false_But_fdh_dire channel_t* ptr_c = &dummy_c; chunks_wrapper_t dummy_CF_CFDP_FindUnusedChunks_result; chunks_wrapper_t* forced_CF_CFDP_FindUnusedChunks_result = &dummy_CF_CFDP_FindUnusedChunks_result; - clist_node forced_return_CF_CList_Pop; + clist_node_t dummy_c_list_node; + clist_node forced_return_CF_CList_Pop = &dummy_c_list_node; CF_CList_Pop_context_t context_CF_CList_Pop; - CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = 1; + CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = forced_return_CF_CList_Pop; forced_return_CF_CList_Pop = &forced_CF_CFDP_FindUnusedChunks_result->cl_node; ptr_c->cs[CF_DIR_RX] = (clist_node)&forced_return_CF_CList_Pop; @@ -4110,13 +4065,13 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Returns_false_And_fdh_dire ((pdu_file_directive_header_t*)&dummy_msg.ph)->directive_code = PDU_METADATA; - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; arg_t->history = &dummy_history; arg_t->chan_num = Any_cf_chan_num(); - UT_SetDefaultReturnValue(FGV, 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); arg_t->state = initial_t_state; @@ -4129,10 +4084,11 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Returns_false_And_fdh_dire channel_t* ptr_c = &dummy_c; chunks_wrapper_t dummy_CF_CFDP_FindUnusedChunks_result; chunks_wrapper_t* forced_CF_CFDP_FindUnusedChunks_result = &dummy_CF_CFDP_FindUnusedChunks_result; - clist_node forced_return_CF_CList_Pop; + clist_node_t dummy_c_list_node; + clist_node forced_return_CF_CList_Pop = &dummy_c_list_node; CF_CList_Pop_context_t context_CF_CList_Pop; - CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = 1; + CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = forced_return_CF_CList_Pop; forced_return_CF_CList_Pop = &forced_CF_CFDP_FindUnusedChunks_result->cl_node; ptr_c->cs[CF_DIR_RX] = (clist_node)&forced_return_CF_CList_Pop; @@ -4181,21 +4137,19 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Returns_false_And_fdh_dire transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_r_msg_t dummy_msg; - const char* expected_Spec = "CF: got invalid md pdu -- abandoning transaction"; uint8 exceptions[1] = {CFDP_IDLE}; cfdp_state_t initial_t_state = Any_cfdp_state_t_ExceptThese(exceptions, 1); uint32 initial_recv_error = Any_uint32(); ((pdu_file_directive_header_t*)&dummy_msg.ph)->directive_code = PDU_METADATA; - printf(" b ((pdu_file_directive_header_t*)&dummy_msg.ph)->directive_code = %u\n", ((pdu_file_directive_header_t*)&dummy_msg.ph)->directive_code); - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; arg_t->history = &dummy_history; arg_t->chan_num = Any_cf_chan_num(); - UT_SetDefaultReturnValue(FGV, 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); arg_t->state = initial_t_state; @@ -4212,10 +4166,11 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Returns_false_And_fdh_dire channel_t* ptr_c = &dummy_c; chunks_wrapper_t dummy_CF_CFDP_FindUnusedChunks_result; chunks_wrapper_t* forced_CF_CFDP_FindUnusedChunks_result = &dummy_CF_CFDP_FindUnusedChunks_result; - clist_node forced_return_CF_CList_Pop; + clist_node_t dummy_c_list_node; + clist_node forced_return_CF_CList_Pop = &dummy_c_list_node; CF_CList_Pop_context_t context_CF_CList_Pop; - CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = 1; + CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = forced_return_CF_CList_Pop; forced_return_CF_CList_Pop = &forced_CF_CFDP_FindUnusedChunks_result->cl_node; ptr_c->cs[CF_DIR_RX] = (clist_node)&forced_return_CF_CList_Pop; @@ -4227,11 +4182,10 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Returns_false_And_fdh_dire /* Arrange for CF_CFDP_RecvMd */ CF_AppData.engine.in.bytes_received = 0; /* force err_out */ pdu_header_t* dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; - int force_return_CF_HeaderSize = 0;//Any_uint8_BetweenExcludeMax(6, 64); /* Any_uint8_BetweenExcludeMax(6, 64) to ensure reasonable values for test, large values cause segfaults */ - pdu_md_t* dummy_msg_in = (uint8*)dummy_ph + force_return_CF_HeaderSize; - int local_result; + int force_return_CF_HeaderSize = 0; + pdu_md_t* dummy_msg_in = (pdu_md_t*)dummy_ph; - CF_AppData.engine.in.bytes_received = sizeof(pdu_md_t) + force_return_CF_HeaderSize; + CF_AppData.engine.in.bytes_received = sizeof(pdu_md_t); UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &force_return_CF_HeaderSize); dummy_msg_in->size = Any_uint32(); @@ -4271,21 +4225,19 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Returns_false_And_fdh_dire transaction_t dummy_t; transaction_t* arg_t = &dummy_t; pdu_r_msg_t dummy_msg; - const char* expected_Spec = "CF: got invalid md pdu -- abandoning transaction"; uint8 exceptions[1] = {CFDP_IDLE}; cfdp_state_t initial_t_state = Any_cfdp_state_t_ExceptThese(exceptions, 1); uint32 initial_recv_error = Any_uint32(); ((pdu_file_directive_header_t*)&dummy_msg.ph)->directive_code = PDU_METADATA; - printf(" b ((pdu_file_directive_header_t*)&dummy_msg.ph)->directive_code = %u\n", ((pdu_file_directive_header_t*)&dummy_msg.ph)->directive_code); - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; arg_t->history = &dummy_history; arg_t->chan_num = Any_cf_chan_num(); - UT_SetDefaultReturnValue(FGV, 0); + UT_SetDefaultReturnValue(UT_KEY(FGV), 0); arg_t->state = initial_t_state; @@ -4300,10 +4252,11 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Returns_false_And_fdh_dire channel_t* ptr_c = &dummy_c; chunks_wrapper_t dummy_CF_CFDP_FindUnusedChunks_result; chunks_wrapper_t* forced_CF_CFDP_FindUnusedChunks_result = &dummy_CF_CFDP_FindUnusedChunks_result; - clist_node forced_return_CF_CList_Pop; + clist_node_t dummy_c_list_node; + clist_node forced_return_CF_CList_Pop = &dummy_c_list_node; CF_CList_Pop_context_t context_CF_CList_Pop; - CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = 1; + CF_AppData.engine.channels[arg_t->chan_num].cs[CF_DIR_RX] = forced_return_CF_CList_Pop; forced_return_CF_CList_Pop = &forced_CF_CFDP_FindUnusedChunks_result->cl_node; ptr_c->cs[CF_DIR_RX] = (clist_node)&forced_return_CF_CList_Pop; @@ -4315,11 +4268,10 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Returns_false_And_fdh_dire /* Arrange for CF_CFDP_RecvMd */ CF_AppData.engine.in.bytes_received = 0; /* force err_out */ pdu_header_t* dummy_ph = &((pdu_r_msg_t*)CF_AppData.engine.in.msg)->ph; - int force_return_CF_HeaderSize = 0;//Any_uint8_BetweenExcludeMax(6, 64); /* Any_uint8_BetweenExcludeMax(6, 64) to ensure reasonable values for test, large values cause segfaults */ - pdu_md_t* dummy_msg_in = (uint8*)dummy_ph + force_return_CF_HeaderSize; - int local_result; + int force_return_CF_HeaderSize = 0; + pdu_md_t* dummy_msg_in = (pdu_md_t*)dummy_ph; - CF_AppData.engine.in.bytes_received = sizeof(pdu_md_t) + force_return_CF_HeaderSize; + CF_AppData.engine.in.bytes_received = sizeof(pdu_md_t); UT_SetHandlerFunction(UT_KEY(CF_HeaderSize), Handler_int_ForcedReturnOnly, &force_return_CF_HeaderSize); dummy_msg_in->size = Any_uint32(); @@ -4356,7 +4308,7 @@ void Test_CF_CFDP_RecvIdle_CheckOf_PDU_HDR_FLAGS_TYPE_Returns_false_And_fdh_dire /******************************************************************************* ** -** CF_CFDP_InitEngine tests (very large) - no coverage - [unstubbables: CF_CFDP_FreeTransaction (small), [unstubbables: CF_CList_InsertBack_Ex (simple)], CF_CList_InsertBack_Ex (simple)] +** CF_CFDP_InitEngine tests (very large) - full coverage - 1 coverage JIRA issue - [unstubbables: CF_CFDP_FreeTransaction (small), [unstubbables: CF_CList_InsertBack_Ex (simple)], CF_CList_InsertBack_Ex (simple)] ** *******************************************************************************/ @@ -4476,33 +4428,31 @@ void Test_CF_CFDP_InitEngine_FirstCallTo_OS_CountSemGetIdByNamel_Returns_nonOS_S void Test_CF_CFDP_InitEngine_AssertsBecause_chunk_mem_offset_Plus_CF_max_chunks_k_i_IsLessThan_CF_NUM_CHUNKS_ALL_CHANNELS(void) { - /* Arrange */ - cf_config_table_t dummy_config_table; - const char* expected_Spec = "CF: failed to get sem id for name %s, error=0x%08x"; - uint8 i = 0; + // /* Arrange */ + // cf_config_table_t dummy_config_table; + // const char* expected_Spec = "CF: failed to get sem id for name %s, error=0x%08x"; + // uint8 i = 0; - UT_SetDefaultReturnValue(UT_KEY(CFE_SB_CreatePipe), CFE_SUCCESS); + // UT_SetDefaultReturnValue(UT_KEY(CFE_SB_CreatePipe), CFE_SUCCESS); - UT_SetDefaultReturnValue(UT_KEY(CFE_SB_SubscribeLocal), CFE_SUCCESS); + // UT_SetDefaultReturnValue(UT_KEY(CFE_SB_SubscribeLocal), CFE_SUCCESS); - CF_AppData.config_table = &dummy_config_table; - CF_AppData.config_table->chan[i].sem_name[0] = 1; /* 1 forces branch to run */ + // CF_AppData.config_table = &dummy_config_table; + // CF_AppData.config_table->chan[i].sem_name[0] = 1; /* 1 forces branch to run */ - for(i=1; ichan[i].sem_name[0] = 0; /* 0 means always bypass the branch */ - } + // for(i=1; ichan[i].sem_name[0] = 0; /* 0 means always bypass the branch */ + // } - UT_SetDefaultReturnValue(UT_KEY(OS_CountSemGetIdByName), OS_SUCCESS); + // UT_SetDefaultReturnValue(UT_KEY(OS_CountSemGetIdByName), OS_SUCCESS); - CF_AppData.engine.enabled = 0; + // CF_AppData.engine.enabled = 0; - /* Act */ + // /* Act */ // result = CF_CFDP_InitEngine(); - /* Assert */ - /* TODO: not sure how to make this one fail as none of the items in this Assert are controllable, chunk_mem_offset is local variable only, the other two are constants */ - UtAssert_Failed("CF_Assert issue - (chunk_mem_offset+CF_max_chunks[k][i])<=CF_NUM_CHUNKS_ALL_CHANNELS"); + // /* Assert */ // UtAssert_INT32_EQ(result, CFE_SUCCESS); // UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); // UtAssert_STUB_COUNT(CFE_SB_CreatePipe, CF_NUM_CHANNELS); @@ -4511,6 +4461,8 @@ void Test_CF_CFDP_InitEngine_AssertsBecause_chunk_mem_offset_Plus_CF_max_chunks_ // UtAssert_True(CF_AppData.engine.enabled == 1, // "CF_AppData.engine.enabled is %u and should be 1", // CF_AppData.engine.enabled); + // /* NOTE: not sure how to make this one fail as none of the items in this Assert are controllable, chunk_mem_offset is local variable only, the other two are constants */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - (chunk_mem_offset+CF_max_chunks[k][i])<=CF_NUM_CHUNKS_ALL_CHANNELS"); } /* end Test_CF_CFDP_InitEngine_AssertsBecause_chunk_mem_offset_Plus_CF_max_chunks_k_i_IsLessThan_CF_NUM_CHUNKS_ALL_CHANNELS */ void Test_CF_CFDP_InitEngine_SuccessSet_CF_AppData_engine_enabled_To_1_AndReturn_CFE_SUCCESS(void) @@ -4553,7 +4505,7 @@ void Test_CF_CFDP_InitEngine_SuccessSet_CF_AppData_engine_enabled_To_1_AndReturn /******************************************************************************* ** -** CF_CFDP_ReceiveMessage tests (very large) - full coverage - [unstubbables: CF_CFDP_RecvPh (medium) [], CF_CFDP_FindTransactionBySequenceNumber (small) [unstubbables: CF_CFDP_FindTransactionBySequenceNumber_ (small)], CF_CFDP_DispatchRecv (simple) [unstubbables: CF_CFDP_ArmInactTimer (simple)], CF_CFDP_RecvFin (small) [], CF_CFDP_TxFile__ (simple) [], CF_CFDP_SendAck (medium) [unstubbables: CF_CFDP_ConstructPduHeader (TODO:Ahhhh!! stopped here on this investigation, this one is gonna be deeeeeeeeep)]] +** CF_CFDP_ReceiveMessage tests (very large) - full coverage - 3 coverage JIRA issues - [unstubbables: CF_CFDP_RecvPh (medium) [], CF_CFDP_FindTransactionBySequenceNumber (small) [unstubbables: CF_CFDP_FindTransactionBySequenceNumber_ (small)], CF_CFDP_DispatchRecv (simple) [unstubbables: CF_CFDP_ArmInactTimer (simple)], CF_CFDP_RecvFin (small) [], CF_CFDP_TxFile__ (simple) [], CF_CFDP_SendAck (medium) [unstubbables: CF_CFDP_ConstructPduHeader (TODO:Ahhhh!! stopped here on this investigation, this one is gonna be deeeeeeeeep)]] ** *******************************************************************************/ @@ -4570,7 +4522,7 @@ void Test_CF_CFDP_ReceiveMessage_When_rx_max_messages_per_wakeup_For_chan_num_Is CF_AppData.config_table = &dummy_config_table; CF_AppData.config_table->chan[dummy_chan_num].rx_max_messages_per_wakeup = 0; /* 0 forces for loop to not run */ - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; /* Act */ CF_CFDP_ReceiveMessage(arg_c); @@ -4595,7 +4547,7 @@ void Test_CF_CFDP_ReceiveMessage_CallTO_CFE_SB_ReceiveBuffer_Returns_CFE_SB_NO_M UT_SetDefaultReturnValue(UT_KEY(CFE_SB_ReceiveBuffer), CFE_SB_NO_MESSAGE); - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; /* Act */ CF_CFDP_ReceiveMessage(arg_c); @@ -4621,13 +4573,13 @@ void Test_CF_CFDP_ReceiveMessage_CallTO_CF_CFDP_RecvPh_Returns_non0_Set_CF_AppDa UT_SetDefaultReturnValue(UT_KEY(CFE_SB_ReceiveBuffer), Any_CFE_Status_t_Except(CFE_SB_NO_MESSAGE)); - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; /* Arrange for CF_CFDP_RecvPh */ int forced_return_CF_HeaderSize = INT32_MIN; /* forces nothing to be greater than */ /* CF_Assert(chan_numchan[dummy_chan_num].rx_max_messages_per_wakeup = 1; /* 1 forces for loop to run */ + + // UT_SetDefaultReturnValue(UT_KEY(CFE_SB_ReceiveBuffer), Any_CFE_Status_t_Except(CFE_SB_NO_MESSAGE)); + + // CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; + + // /* Arrange for CF_CFDP_RecvPh */ + // int forced_return_CF_HeaderSize = Any_int_Positive();/* Any_int_Positive() used because this is what the CUT sees, in practice this will be relatively small I, ASG, would think */ + // size_t forced_return_CFE_SB_GetUserDataLength = forced_return_CF_HeaderSize + Any_uint16();/* Any_CFE_MSG_Size_t not used because only need a small number here */ + // int forced_return_CF_GetVariableHeader = 0; + + // /* CF_Assert(chan_numstate = CFDP_R1; + // context_CF_CList_Traverse[NUM_CLISTS - 1].context_forced_t = forced_t_result; + + // /* Act */ + // CF_CFDP_ReceiveMessage(arg_c); + + // /* Assert */ + // UtAssert_STUB_COUNT(CFE_SB_ReceiveBuffer, 1); + // UtAssert_STUB_COUNT(CFE_ES_PerfLogAdd, 2); + // UtAssert_NULL(CF_AppData.engine.in.msg); + // /* Assert for CF_CFDP_RecvPh */ + // UtAssert_STUB_COUNT(CF_HeaderSize, 1); + // UtAssert_STUB_COUNT(CF_GetVariableHeader, 1); + // /* Assert for CF_CFDP_FindTransactionBySequenceNumber */ + // UtAssert_STUB_COUNT(CF_CList_Traverse, NUM_CLISTS); + // /* Assert for CF_CFDP_DispatchRecv via CF_CFDP_ArmInactTimer */ + // UtAssert_STUB_COUNT(CF_Timer_InitRelSec, 1); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - t->state>CFDP_IDLE"); +} /* end Test_CF_CFDP_ReceiveMessage_AssertsBecause_t_state_IsGreaterThan_CFDP_IDLE */ + void Test_CF_CFDP_ReceiveMessage_CallTo_src_And_dst_AreNot_config_table_local_eid_SendEvenThenSet_CF_AppData_engine_in_msg_To_NULL(void) { /* Arrange */ @@ -4728,7 +4749,7 @@ void Test_CF_CFDP_ReceiveMessage_CallTo_src_And_dst_AreNot_config_table_local_ei UT_SetDefaultReturnValue(UT_KEY(CFE_SB_ReceiveBuffer), Any_CFE_Status_t_Except(CFE_SB_NO_MESSAGE)); - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; CF_AppData.config_table->local_eid = Any_uint8(); /*TODO: change to any_cf_entity_id_t */ CF_AppData.engine.in.src = Any_uint8_Except(CF_AppData.config_table->local_eid); /* for src check fail */ @@ -4742,7 +4763,7 @@ void Test_CF_CFDP_ReceiveMessage_CallTo_src_And_dst_AreNot_config_table_local_ei int forced_return_CF_GetVariableHeader = 0; /* CF_Assert(chan_numlocal_eid = Any_uint8(); /*TODO: change to any_cf_entity_id_t */ CF_AppData.engine.in.src = CF_AppData.config_table->local_eid; /* for src check fail */ UT_SetDefaultReturnValue(UT_KEY(FGV), 1); @@ -4827,7 +4846,7 @@ void Test_CF_CFDP_ReceiveMessage_CallTo_Then_CallTo_FGV_Returns_non0_And_dst_IsN int forced_return_CF_GetVariableHeader = 0; /* CF_Assert(chan_numlocal_eid = Any_uint8(); /*TODO: change to any_cf_entity_id_t */ CF_AppData.engine.in.src = CF_AppData.config_table->local_eid; /* for src check fail */ UT_SetDefaultReturnValue(UT_KEY(FGV), 0); @@ -4914,7 +4931,7 @@ void Test_CF_CFDP_ReceiveMessage_CallTo_Then_bytes_received_IsLessThanExpected_A int forced_return_CF_GetVariableHeader = 0; /* CF_Assert(chan_numlocal_eid = Any_uint8(); /*TODO: change to any_cf_entity_id_t */ CF_AppData.engine.in.src = CF_AppData.config_table->local_eid; /* for src check fail */ UT_SetDefaultReturnValue(UT_KEY(FGV), 0); @@ -5000,7 +5015,7 @@ void Test_CF_CFDP_ReceiveMessage_CallTo_Then_directive_code_IsNotEqTo_PDU_FIN_An int forced_return_CF_GetVariableHeader = 0; /* CF_Assert(chan_numlocal_eid = Any_uint8(); /*TODO: change to any_cf_entity_id_t */ CF_AppData.engine.in.src = CF_AppData.config_table->local_eid; /* for src check fail */ UT_SetDefaultReturnValue(UT_KEY(FGV), 0); @@ -5088,7 +5098,7 @@ void Test_CF_CFDP_ReceiveMessage_CallTo_Then_CallTo_CF_CFDP_RecvFin_Returns_neg1 int forced_return_CF_GetVariableHeader = 0; /* CF_Assert(chan_numlocal_eid = Any_uint8(); /*TODO: change to any_cf_entity_id_t */ CF_AppData.engine.in.src = CF_AppData.config_table->local_eid; /* for src check fail */ UT_SetDefaultReturnValue(UT_KEY(FGV), 0); @@ -5172,7 +5179,7 @@ void Test_CF_CFDP_ReceiveMessage_CallTo_Then_CallTo_CF_CFDP_RecvFin_Returns_0_In int forced_return_CF_GetVariableHeader = 0; /* CF_Assert(chan_numlocal_eid = Any_uint8(); /*TODO: change to any_cf_entity_id_t */ CF_AppData.engine.in.src = CF_AppData.config_table->local_eid; /* for src check fail */ UT_SetDefaultReturnValue(UT_KEY(FGV), 0); @@ -5259,7 +5263,7 @@ void Test_CF_CFDP_ReceiveMessage_CallTo_Then_CallTo_CF_CFDP_RecvFin_Returns_0_Ca int forced_return_CF_GetVariableHeader = 0; /* CF_Assert(chan_numchan[dummy_chan_num].max_outgoing_messages_per_wakeup = 0; CF_AppData.engine.outgoing_counter = 1; /* Force fail */ - CF_AppData.engine.out.msg = &forced_set_CFE_MSG_Init; + CF_AppData.engine.out.msg = (CFE_SB_Buffer_t*)&forced_set_CFE_MSG_Init; arg_c->cur = &dummy_t; @@ -5317,68 +5320,154 @@ void Test_CF_CFDP_ReceiveMessage_CallTo_Then_CallTo_CF_CFDP_RecvFin_Returns_0_Ca void Test_CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_But_dst_IsEqTo_config_table_local_eid_And_q_size_CF_Q_RX_IsNotEqTo_CF_MAX_SIMULTANEOUS_RX_SendEventThenIncrement_counters_recv_dropped_AndSet_CF_AppData_engine_in_msg_To_NULL(void) { - /* Arrange */ - uint8 dummy_chan_num = Any_cf_chan_num(); - cf_config_table_t dummy_config_table; - channel_t* arg_c; - pdu_r_msg_t dummy_msg; - const char* expected_Spec = "CF: dropping packet from %d transaction number 0x%08x due max RX transactions reached"; - CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; + // /* Arrange */ + // uint8 dummy_chan_num = Any_cf_chan_num(); + // cf_config_table_t dummy_config_table; + // channel_t* arg_c; + // pdu_r_msg_t dummy_msg; + // const char* expected_Spec = "CF: dropping packet from %d transaction number 0x%08x due max RX transactions reached"; + // CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; - arg_c = &CF_AppData.engine.channels[dummy_chan_num]; + // arg_c = &CF_AppData.engine.channels[dummy_chan_num]; - CF_AppData.config_table = &dummy_config_table; - CF_AppData.config_table->chan[dummy_chan_num].rx_max_messages_per_wakeup = 1; /* 1 forces for loop to run */ + // CF_AppData.config_table = &dummy_config_table; + // CF_AppData.config_table->chan[dummy_chan_num].rx_max_messages_per_wakeup = 1; /* 1 forces for loop to run */ - UT_SetDefaultReturnValue(UT_KEY(CFE_SB_ReceiveBuffer), Any_CFE_Status_t_Except(CFE_SB_NO_MESSAGE)); + // UT_SetDefaultReturnValue(UT_KEY(CFE_SB_ReceiveBuffer), Any_CFE_Status_t_Except(CFE_SB_NO_MESSAGE)); - CF_AppData.engine.in.msg = &dummy_msg; - CF_AppData.config_table->local_eid = Any_uint8(); /*TODO: change to any_cf_entity_id_t */ - CF_AppData.engine.in.src = Any_uint8_Except(CF_AppData.config_table->local_eid); /* for src check fail */ + // CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; + // CF_AppData.config_table->local_eid = Any_uint8(); /*TODO: change to any_cf_entity_id_t */ + // CF_AppData.engine.in.src = Any_uint8_Except(CF_AppData.config_table->local_eid); /* for src check fail */ - CF_AppData.engine.in.dst = CF_AppData.config_table->local_eid; /* for dst check fail */ + // CF_AppData.engine.in.dst = CF_AppData.config_table->local_eid; /* for dst check fail */ - UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter_hook, &context_CFE_EVS_SendEvent); + // UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter_hook, &context_CFE_EVS_SendEvent); - CF_AppData.hk.channel_hk[dummy_chan_num].q_size[CF_Q_RX] = CF_MAX_SIMULTANEOUS_RX; + // CF_AppData.hk.channel_hk[dummy_chan_num].q_size[CF_Q_RX] = CF_MAX_SIMULTANEOUS_RX; - /* Arrange for CF_CFDP_RecvPh */ - int forced_return_CF_HeaderSize = Any_int_Positive();/* Any_int_Positive() used because this is what the CUT sees, in practice this will be relatively small I, ASG, would think */ - size_t forced_return_CFE_SB_GetUserDataLength = forced_return_CF_HeaderSize + 2;/* Any_CFE_MSG_Size_t not used because only need a small number here */ - int forced_return_CF_GetVariableHeader = 0; + // /* Arrange for CF_CFDP_RecvPh */ + // int forced_return_CF_HeaderSize = Any_int_Positive();/* Any_int_Positive() used because this is what the CUT sees, in practice this will be relatively small I, ASG, would think */ + // size_t forced_return_CFE_SB_GetUserDataLength = forced_return_CF_HeaderSize + 2;/* Any_CFE_MSG_Size_t not used because only need a small number here */ + // int forced_return_CF_GetVariableHeader = 0; + + // /* CF_Assert(chan_numchan_num will always segfault"); +} /* end Test_CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_But_dst_IsEqTo_config_table_local_eid_And_q_size_CF_Q_RX_IsNotEqTo_CF_MAX_SIMULTANEOUS_RX_SendEventThenIncrement_counters_recv_dropped_AndSet_CF_AppData_engine_in_msg_To_NULL */ + +void Test_CF_CFDP_ReceiveMessage_AssertsBecause_t_Is_NULL(void) +{ + // /* Arrange */ + // uint8 dummy_chan_num = Any_cf_chan_num(); + // cf_config_table_t dummy_config_table; + // channel_t* arg_c; + // pdu_r_msg_t dummy_msg; + // const char* expected_Spec = "CF: dropping packet from %d transaction number 0x%08x due max RX transactions reached"; + // CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; + + // arg_c = &CF_AppData.engine.channels[dummy_chan_num]; + + // CF_AppData.config_table = &dummy_config_table; + // CF_AppData.config_table->chan[dummy_chan_num].rx_max_messages_per_wakeup = 1; /* 1 forces for loop to run */ + + // UT_SetDefaultReturnValue(UT_KEY(CFE_SB_ReceiveBuffer), Any_CFE_Status_t_Except(CFE_SB_NO_MESSAGE)); + + // CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; + // CF_AppData.config_table->local_eid = Any_uint8(); /*TODO: change to any_cf_entity_id_t */ + // CF_AppData.engine.in.src = Any_uint8_Except(CF_AppData.config_table->local_eid); /* for src check fail */ + + // CF_AppData.engine.in.dst = CF_AppData.config_table->local_eid; /* for dst check fail */ + + // UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter_hook, &context_CFE_EVS_SendEvent); + + // CF_AppData.hk.channel_hk[dummy_chan_num].q_size[CF_Q_RX] = CF_MAX_SIMULTANEOUS_RX; + + // /* Arrange for CF_CFDP_RecvPh */ + // int forced_return_CF_HeaderSize = Any_int_Positive();/* Any_int_Positive() used because this is what the CUT sees, in practice this will be relatively small I, ASG, would think */ + // size_t forced_return_CFE_SB_GetUserDataLength = forced_return_CF_HeaderSize + 2;/* Any_CFE_MSG_Size_t not used because only need a small number here */ + // int forced_return_CF_GetVariableHeader = 0; - /* CF_Assert(chan_numchan_num will always segfault"); + // /* Assert */ // UtAssert_STUB_COUNT(CFE_SB_ReceiveBuffer, 1); // UtAssert_STUB_COUNT(CFE_ES_PerfLogAdd, 2); // UtAssert_NULL(CF_AppData.engine.in.msg); @@ -5400,7 +5489,8 @@ void Test_CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_But // /* Assert for CF_CFDP_DispatchRecv via CF_CFDP_ArmInactTimer */ // UtAssert_STUB_COUNT(CF_Timer_InitRelSec, 0); // UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); -} /* end Test_CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_But_dst_IsEqTo_config_table_local_eid_And_q_size_CF_Q_RX_IsNotEqTo_CF_MAX_SIMULTANEOUS_RX_SendEventThenIncrement_counters_recv_dropped_AndSet_CF_AppData_engine_in_msg_To_NULL */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - t"); +} /* end Test_CF_CFDP_ReceiveMessage_AssertsBecause_t_Is_NULL */ void Test_2CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_But_dst_IsEqTo_config_table_local_eid_And_q_size_CF_Q_RX_IsNotEqTo_CF_MAX_SIMULTANEOUS_RX_SendEventThenIncrement_counters_recv_dropped_AndSet_CF_AppData_engine_in_msg_To_NULL(void) { @@ -5408,11 +5498,13 @@ void Test_2CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_Bu uint8 dummy_chan_num = Any_cf_chan_num(); cf_config_table_t dummy_config_table; channel_t* arg_c; - pdu_r_msg_t dummy_msg; - const char* expected_Spec = "CF: dropping packet from %d transaction number 0x%08x due max RX transactions reached"; + CFE_SB_Buffer_t dummy_msg; CFE_EVS_SendEvent_context_t context_CFE_EVS_SendEvent; + history_t dummy_history; + arg_c = &CF_AppData.engine.channels[dummy_chan_num]; + arg_c->qs[CF_Q_HIST] = &dummy_history.cl_node; CF_AppData.config_table = &dummy_config_table; CF_AppData.config_table->chan[dummy_chan_num].rx_max_messages_per_wakeup = 1; /* 1 forces for loop to run */ @@ -5430,12 +5522,12 @@ void Test_2CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_Bu CF_AppData.hk.channel_hk[dummy_chan_num].q_size[CF_Q_RX] = Any_uint16_Except(CF_MAX_SIMULTANEOUS_RX); /* Arrange for CF_CFDP_RecvPh */ - int forced_return_CF_HeaderSize = Any_int_Positive();/* Any_int_Positive() used because this is what the CUT sees, in practice this will be relatively small I, ASG, would think */ + int forced_return_CF_HeaderSize = 0; size_t forced_return_CFE_SB_GetUserDataLength = forced_return_CF_HeaderSize + Any_uint16();/* Any_CFE_MSG_Size_t not used because only need a small number here */ int forced_return_CF_GetVariableHeader = 0; /* CF_Assert(chan_numph.length = forced_return_CFE_SB_GetUserDataLength - forced_return_CF_HeaderSize; /* ensures equality so (temp+hsize)==CF_AppData.engine.in.bytes_received */ /* Arrange for CF_CFDP_FindTransactionBySequenceNumber */ uint8 i = 0; transaction_t dummy_t; - transaction_t* forced_t_result = &dummy_t; CF_CList_Traverse_FIND_T_BY_SEQ_NUM_context_t context_CF_CList_Traverse[NUM_CLISTS]; type_of_context_CF_CList_Traverse = FIND_T_BY_SEQ_NUM; @@ -5461,6 +5552,13 @@ void Test_2CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_Bu context_CF_CList_Traverse[i].context_forced_t = NULL; } + /* Arrange for CF_CFDP_FindUnusedChunks */ + clist_node_t dummy_node; + + (&CF_AppData.engine.channels[dummy_t.chan_num])->cs[CF_DIR_RX] = &dummy_node; + + UT_SetDefaultReturnValue(UT_KEY(OS_ObjectIdDefined), true); + /* Arrange for CF_CFDP_FindUnusedTransaction */ clist_node_t dummy_cf_q_hist; @@ -5495,7 +5593,7 @@ void Test_2CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_Bu /******************************************************************************* ** -** CF_CFDP_CycleTx_ tests (medium) - full coverage - 1 CF_Assert - [unstubbables: CF_CFDP_DispatchTx (small)] +** CF_CFDP_CycleTx_ tests (medium) - full coverage - 1 coverage JIRA issue - [unstubbables: CF_CFDP_DispatchTx (small)] ** *******************************************************************************/ @@ -5521,22 +5619,22 @@ void Test_CF_CFDP_CycleTx__Given_node_TransactionContainer_t_flags_all_suspended void Test_CF_CFDP_CycleTx__AssertsBecauseGiven_node_TransactionContainer_t_flags_all_q_index_IsNotEqTo_CF_Q_TXA(void) { - /* Arrange */ - transaction_t dummy_t; - clist_node arg_clist_node = &dummy_t.cl_node; - CF_CFDP_CycleTx_args_t dummy_args; - void* arg_context = (void*)&dummy_args; - int local_result; + // /* Arrange */ + // transaction_t dummy_t; + // clist_node arg_clist_node = &dummy_t.cl_node; + // CF_CFDP_CycleTx_args_t dummy_args; + // void* arg_context = (void*)&dummy_args; + // int local_result; - dummy_t.flags.all.suspended = false; + // dummy_t.flags.all.suspended = false; - dummy_t.flags.all.q_index = Any_uint8_Except(CF_Q_TXA); + // dummy_t.flags.all.q_index = Any_uint8_Except(CF_Q_TXA); - /* Act */ + // /* Act */ // local_result = CF_CFDP_CycleTx_(arg_clist_node, arg_context); - /* Assert */ - UtAssert_Failed("CF_Assert issue - t->flags.all.q_index==CF_Q_TXA"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - t->flags.all.q_index==CF_Q_TXA"); } /* end Test_CF_CFDP_CycleTx__AssertsBecauseGiven_node_TransactionContainer_t_flags_all_q_index_IsNotEqTo_CF_Q_TXA */ void Test_CF_CFDP_CycleTx__Given_node_TransactionContainer_t_flags_all_q_index_IsEqTo_CF_Q_TXA_And_args_c_cur_Is_notNULL_Sets_args_ran_one_To_1_ThenReturn_1(void) @@ -5742,7 +5840,6 @@ void Test_CF_CFDP_CycleTx_When_cur_FromGiven_c_Is_notNULL_Set_c_cur_To_NULL(void void Test_CF_CFDP_CycleTx_When_c_qs_CF_Q_PEND_Is_NULL_CF_CList_Traverse_CalledOnlyOnce_Set_c_cur_To_NULL(void) { /* Arrange */ - transaction_t dummy_cur; cf_config_table_t dummy_config_table; channel_t* arg_c; @@ -5753,6 +5850,7 @@ void Test_CF_CFDP_CycleTx_When_c_qs_CF_Q_PEND_Is_NULL_CF_CList_Traverse_CalledOn arg_c->cur = NULL; arg_c->qs[CF_Q_PEND] = 0; + type_of_context_CF_CList_Traverse = POINTER; /* Act */ CF_CFDP_CycleTx(arg_c); @@ -5765,7 +5863,6 @@ void Test_CF_CFDP_CycleTx_When_c_qs_CF_Q_PEND_Is_NULL_CF_CList_Traverse_CalledOn void Test_CF_CFDP_CycleTx_When_c_qs_CF_Q_PEND_Is_NULL_Then_CF_CList_Traverse_CalledOnlyOnce_ReturnsAnd_ran_one_IsNow_non0_And_qs_NULL_Set_c_cur_To_NULL(void) { /* Arrange */ - transaction_t dummy_cur; cf_config_table_t dummy_config_table; channel_t* arg_c; @@ -5776,6 +5873,7 @@ void Test_CF_CFDP_CycleTx_When_c_qs_CF_Q_PEND_Is_NULL_Then_CF_CList_Traverse_Cal arg_c->cur = NULL; arg_c->qs[CF_Q_PEND] = 0; + type_of_context_CF_CList_Traverse = POINTER; UT_SetHandlerFunction(UT_KEY(CF_CList_Traverse), Handler_CF_CList_Traverse_Set_ran_one_To_1, arg_c); @@ -5790,7 +5888,6 @@ void Test_CF_CFDP_CycleTx_When_c_qs_CF_Q_PEND_Is_NULL_Then_CF_CList_Traverse_Cal void Test_CF_CFDP_CycleTx_EnterWhileLoopOnceAndCall_cf_move_transaction_SecondCallTo_CF_CList_Traverse_ReturnsAnd_ran_one_IsNow_non0_And_qs_NULL_Set_c_cur_To_NULL(void) { /* Arrange */ - clist_node_t dummy_node; transaction_t dummy_cur; cf_config_table_t dummy_config_table; channel_t* arg_c; @@ -5806,6 +5903,13 @@ void Test_CF_CFDP_CycleTx_EnterWhileLoopOnceAndCall_cf_move_transaction_SecondCa context_CF_CList_Traverse[0] = (void*)&arg_c->qs[CF_Q_PEND]; context_CF_CList_Traverse[1] = (void*)arg_c; + // TRAV_ARG_T, + // TRAVERSE_ALL_ARGS_T, + // POINTER, + // FIND_T_BY_SEQ_NUM, + // CLOSE_FILES, + /* Arrange for cf_move_transaction */ + type_of_context_CF_CList_Traverse = POINTER; UT_SetHandlerFunction(UT_KEY(CF_CList_Traverse), Handler_CF_CList_Traverse_SecondCallSet_ran_one_To_1, &context_CF_CList_Traverse); @@ -5922,7 +6026,7 @@ void Test_CF_CFDP_DoTick_Given_context_Determined_args_c_cur_Is_t_And_t_flags_al dummy_t.flags.all.suspended = false; - dummy_args.fn = Dummy_tick_args_t_fn; + dummy_args.fn = (void (*)(transaction_t*, int*))Dummy_tick_args_t_fn; dummy_args.early_exit = initial_early_exit; @@ -5955,7 +6059,7 @@ void Test_CF_CFDP_DoTick_Given_context_Determined_args_c_cur_Is_t_And_t_flags_al dummy_t.flags.all.suspended = false; - dummy_args.fn = Dummy_tick_args_t_fn; + dummy_args.fn = (void(*)(transaction_t *, int *))Dummy_tick_args_t_fn; UT_SetHandlerFunction(UT_KEY(Dummy_tick_args_t_fn), Handler_Dummy_tick_args_t_fn_Set_cur_notNULL, &dummy_args.c->cur); @@ -5979,7 +6083,7 @@ void Test_CF_CFDP_DoTick_Given_context_Determined_args_c_cur_Is_t_And_t_flags_al /******************************************************************************* ** -** CF_CFDP_TickTransactions tests (medium) - full coverage - 1 CF_Assert - [unstubbables: CF_CFDP_DoTick (medium)] +** CF_CFDP_TickTransactions tests (medium) - full coverage - 1 coverage JIRA issue - [unstubbables: CF_CFDP_DoTick (medium)] ** ** NOTE: The number of tests are determined by tick_type_t enum, if values are added there, there will be more values this function can use ** @@ -5987,20 +6091,20 @@ void Test_CF_CFDP_DoTick_Given_context_Determined_args_c_cur_Is_t_And_t_flags_al void Test_CF_CFDP_TickTransactions_AssertsBecause_c_tick_type_IsEqTo_CF_TICK_NUM_TYPES(void) { - /* Arrange */ - channel_t dummy_c; - channel_t* arg_c = &dummy_c; + // /* Arrange */ + // channel_t dummy_c; + // channel_t* arg_c = &dummy_c; - arg_c->tick_type = CF_TICK_NUM_TYPES; + // arg_c->tick_type = CF_TICK_NUM_TYPES; - /* Act */ + // /* Act */ // CF_CFDP_TickTransactions(arg_c); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - c->tick_typetick_type = CF_TICK_RX; + + type_of_context_CF_CList_Traverse = POINTER; /* Act */ CF_CFDP_TickTransactions(arg_c); @@ -6043,6 +6149,8 @@ void Test_CF_CFDP_TickTransaction_Given_c_tick_type_Is_CF_TICK_TXW_NORM_AndDeter uint8 expected_number_of_CF_CList_Traverse_calls = CF_TICK_NUM_TYPES - CF_TICK_TXW_NORM; arg_c->tick_type = CF_TICK_TXW_NORM; + + type_of_context_CF_CList_Traverse = POINTER; /* Act */ CF_CFDP_TickTransactions(arg_c); @@ -6062,6 +6170,8 @@ void Test_CF_CFDP_TickTransaction_Given_c_tick_type_Is_CF_TICK_TXW_NAK_AndDeterm uint8 expected_number_of_CF_CList_Traverse_calls = CF_TICK_NUM_TYPES - CF_TICK_TXW_NAK; arg_c->tick_type = CF_TICK_TXW_NAK; + + type_of_context_CF_CList_Traverse = POINTER; /* Act */ CF_CFDP_TickTransactions(arg_c); @@ -6081,6 +6191,8 @@ void Test_CF_CFDP_TickTransaction_Given_c_tick_type_Is_CF_TICK_TXW_NAK_And_Deter uint8 expected_number_of_CF_CList_Traverse_calls = CF_TICK_NUM_TYPES - CF_TICK_TXW_NAK; arg_c->tick_type = CF_TICK_TXW_NAK; + + type_of_context_CF_CList_Traverse = POINTER; UT_SetHandlerFunction(UT_KEY(CF_CList_Traverse), Handler_CF_CList_Traverse_Sets_args_early_exit_To_1, NULL); @@ -6102,6 +6214,8 @@ void Test_CF_CFDP_TickTransaction_Given_c_tick_type_Is_CF_TICK_TXW_NORM_And_Dete uint8 expected_number_of_CF_CList_Traverse_calls = 1; arg_c->tick_type = CF_TICK_TXW_NORM; + + type_of_context_CF_CList_Traverse = POINTER; UT_SetHandlerFunction(UT_KEY(CF_CList_Traverse), Handler_CF_CList_Traverse_Sets_args_early_exit_To_1, NULL); @@ -6120,12 +6234,13 @@ void Test_CF_CFDP_TickTransaction_Given_c_tick_type_Is_CF_TICK_TXW_NAK_RunsLoopA /* Arrange */ channel_t dummy_c; channel_t* arg_c = &dummy_c; - uint8 expected_number_of_CF_CList_Traverse_calls = 1; - int8 stop_count = Any_int_ZeroOrPositiveLessThan(9) + 2; /* Any_int_ZeroOrPositiveLessThan(9) + 2 is 2-10 */ + uint32 stop_count = Any_uint8_LessThan(9) + 2; /* Any_uint8_LessThan(9) + 2 is 2-10 */ arg_c->tick_type = CF_TICK_TXW_NAK; + + type_of_context_CF_CList_Traverse = POINTER; - UT_SetHandlerFunction(UT_KEY(CF_CList_Traverse), Handler_CF_CList_Traverse_Sets_args_cont_To_1_UntilGivenCount, stop_count); + UT_SetHandlerFunction(UT_KEY(CF_CList_Traverse), Handler_CF_CList_Traverse_Sets_args_cont_To_1_UntilGivenCount, &stop_count); /* Act */ CF_CFDP_TickTransactions(arg_c); @@ -6212,24 +6327,20 @@ void Test_CF_CFDP_TxFile___SetsGivenValuesOnTransaction_cfdp_class_SetTo_CLASS_2 void Test_CF_CFDP_TxFile_DoesNotError(void) { /* Arrange */ - channel_t dummy_c; - chunks_wrapper_t dummy_chunks; cf_config_table_t dummy_config_table; history_t dummy_history; transaction_t dummy_t; transaction_t* arg_t = &dummy_t; - cfdp_class_t arg_cfdp_class; - uint8 arg_keep; + cfdp_class_t arg_cfdp_class = Any_cfdp_class_t(); + uint8 arg_keep = Any_uint8(); uint8 arg_chan = Any_cf_chan_num(); - uint8 arg_priority; - cf_entity_id_t arg_dest_id; + uint8 arg_priority = Any_uint8(); + cf_entity_id_t arg_dest_id = Any_uint8(); CF_AppData.config_table = &dummy_config_table; arg_t->history = &dummy_history; - CF_AppData.engine.channels[arg_chan] = dummy_c; - /* Arrange for CF_CFDP_FindUnusedChunks */ clist_node_t dummy_cs; @@ -6251,7 +6362,7 @@ void Test_CF_CFDP_TxFile_DoesNotError(void) /******************************************************************************* ** -** CF_CFDP_TxFile tests (medium) - full coverage - 3 CF_Assert - 3 Deep Setup - [unstubbables: CF_CFDP_FindUnusedTransaction (large) - [unstubbables: CF_CList_Remove_Ex (small)], CF_CFDP_TxFile_ (medium) - [unstubbables: CF_CFDP_TxFile__ (simple) - [], CF_CFDP_ArmInactTimer (simple) - [], CF_CFDP_FindUnusedChunks (small) - []] +** CF_CFDP_TxFile tests (medium) - full coverage - 3 coverage JIRA issue - [unstubbables: CF_CFDP_FindUnusedTransaction (large) - [unstubbables: CF_CList_Remove_Ex (small)], CF_CFDP_TxFile_ (medium) - [unstubbables: CF_CFDP_TxFile__ (simple) - [], CF_CFDP_ArmInactTimer (simple) - [], CF_CFDP_FindUnusedChunks (small) - []] ** *******************************************************************************/ @@ -6260,7 +6371,7 @@ void Test_CF_CFDP_TxFile_AssertsBecause_chan_IsGreaterThan_CF_NUM_CHANNELS(void) /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); } /* end Test_CF_CFDP_TxFile_AssertsBecause_chan_IsGreaterThan_CF_NUM_CHANNELS */ /* TODO: Test_CF_CFDP_TxFile_AssertsBecause_chan_IsEqTo_CF_NUM_CHANNELS not required but desired */ @@ -6269,7 +6380,7 @@ void Test_CF_CFDP_TxFile_AssertsBecause_chan_IsGreaterThan_CF_NUM_CHANNELS(void) // /* Arrange */ // /* Act */ // /* Assert */ -// UtAssert_Failed("CF_Assert issue"); +// UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); // } /* end Test_CF_CFDP_TxFile_AssertsBecause_chan_IsEqTo_CF_NUM_CHANNELS */ void Test_CF_CFDP_TxFile_FailsBecause_c_num_cmd_tx_IsEqTo_CF_MAX_COMMANDED_PLAYBACK_FILES_PER_CHAN(void) @@ -6312,32 +6423,32 @@ void Test_CF_CFDP_TxFile_FailsBecause_c_num_cmd_tx_IsEqTo_CF_MAX_COMMANDED_PLAYB void Test_CF_CFDP_TxFile_AssertsBecause_t_IsReturned_NULL_From_CF_CFDP_FindUnusedTransaction(void) { - /* Arrange */ - history_t dummy_history; - transaction_t dummy_t; - channel_t* dummy_c; - char arg_src_filename[CF_FILENAME_MAX_LEN] = "placeholder\0"; - char arg_dst_filename[CF_FILENAME_MAX_LEN] = "dstholder\0"; - cfdp_class_t arg_cfdp_class = Any_cfdp_class_t(); - uint8 arg_keep = Any_uint8(); - uint8 arg_chan = Any_uint8_LessThan(CF_NUM_CHANNELS); - uint8 arg_priority = Any_uint8(); - cf_entity_id_t arg_dest_id = Any_uint8(); + // /* Arrange */ + // history_t dummy_history; + // transaction_t dummy_t; + // channel_t* dummy_c; + // char arg_src_filename[CF_FILENAME_MAX_LEN] = "placeholder\0"; + // char arg_dst_filename[CF_FILENAME_MAX_LEN] = "dstholder\0"; + // cfdp_class_t arg_cfdp_class = Any_cfdp_class_t(); + // uint8 arg_keep = Any_uint8(); + // uint8 arg_chan = Any_uint8_LessThan(CF_NUM_CHANNELS); + // uint8 arg_priority = Any_uint8(); + // cf_entity_id_t arg_dest_id = Any_uint8(); - dummy_c = &CF_AppData.engine.channels[arg_chan]; - dummy_c->num_cmd_tx = Any_uint32_Except(CF_MAX_COMMANDED_PLAYBACK_FILES_PER_CHAN); + // dummy_c = &CF_AppData.engine.channels[arg_chan]; + // dummy_c->num_cmd_tx = Any_uint32_Except(CF_MAX_COMMANDED_PLAYBACK_FILES_PER_CHAN); - UT_SetDataBuffer(UT_KEY(CFE_EVS_SendEvent), &EventID, - sizeof(EventID), false); + // UT_SetDataBuffer(UT_KEY(CFE_EVS_SendEvent), &EventID, + // sizeof(EventID), false); - dummy_t.history = &dummy_history; + // dummy_t.history = &dummy_history; - dummy_t.state = Any_uint8_Except(CFDP_IDLE); /* asserts */ + // dummy_t.state = Any_uint8_Except(CFDP_IDLE); /* asserts */ - /* Arrange for CF_CFDP_FindUnusedTransaction */ - dummy_c->qs[CF_Q_FREE] = NULL; /* makes t NULL */ + // /* Arrange for CF_CFDP_FindUnusedTransaction */ + // dummy_c->qs[CF_Q_FREE] = NULL; /* makes t NULL */ - /* Act */ + // /* Act */ // result = CF_CFDP_TxFile(arg_src_filename, // arg_dst_filename, // arg_cfdp_class, @@ -6346,50 +6457,50 @@ void Test_CF_CFDP_TxFile_AssertsBecause_t_IsReturned_NULL_From_CF_CFDP_FindUnuse // arg_priority, // arg_dest_id); - /* Assert */ - UtAssert_Failed("CF_Assert issue - t"); + // /* Assert */ // UtAssert_UINT32_EQ(result, CFE_SUCCESS); // /* Assert for CF_CFDP_TxFile_ */ // UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); // UtAssert_True(EventID == CF_EID_INF_CFDP_S_START_SEND, // "CFE_EVS_SendEvent receive event id %u and should receive %u (CF_EID_INF_CFDP_S_START_SEND)", // EventID, CF_EID_INF_CFDP_S_START_SEND); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - t"); } /* end Test_CF_CFDP_TxFile_AssertsBecause_t_IsReturned_NULL_From_CF_CFDP_FindUnusedTransaction */ void Test_CF_CFDP_TxFile_AssertsBecause_t_state_IsNotEqTo_CFDP_IDLE(void) { - /* Arrange */ - history_t dummy_history; - transaction_t dummy_t; - channel_t* dummy_c; - char arg_src_filename[CF_FILENAME_MAX_LEN] = "placeholder\0"; - char arg_dst_filename[CF_FILENAME_MAX_LEN] = "dstholder\0"; - cfdp_class_t arg_cfdp_class = Any_cfdp_class_t(); - uint8 arg_keep = Any_uint8(); - uint8 arg_chan = Any_uint8_LessThan(CF_NUM_CHANNELS); - uint8 arg_priority = Any_uint8(); - cf_entity_id_t arg_dest_id = Any_uint8(); + // /* Arrange */ + // history_t dummy_history; + // transaction_t dummy_t; + // channel_t* dummy_c; + // char arg_src_filename[CF_FILENAME_MAX_LEN] = "placeholder\0"; + // char arg_dst_filename[CF_FILENAME_MAX_LEN] = "dstholder\0"; + // cfdp_class_t arg_cfdp_class = Any_cfdp_class_t(); + // uint8 arg_keep = Any_uint8(); + // uint8 arg_chan = Any_uint8_LessThan(CF_NUM_CHANNELS); + // uint8 arg_priority = Any_uint8(); + // cf_entity_id_t arg_dest_id = Any_uint8(); - dummy_c = &CF_AppData.engine.channels[arg_chan]; - dummy_c->num_cmd_tx = Any_uint32_Except(CF_MAX_COMMANDED_PLAYBACK_FILES_PER_CHAN); + // dummy_c = &CF_AppData.engine.channels[arg_chan]; + // dummy_c->num_cmd_tx = Any_uint32_Except(CF_MAX_COMMANDED_PLAYBACK_FILES_PER_CHAN); - UT_SetDataBuffer(UT_KEY(CFE_EVS_SendEvent), &EventID, - sizeof(EventID), false); + // UT_SetDataBuffer(UT_KEY(CFE_EVS_SendEvent), &EventID, + // sizeof(EventID), false); - dummy_t.history = &dummy_history; + // dummy_t.history = &dummy_history; - dummy_t.state = Any_uint8_Except(CFDP_IDLE); /* asserts */ + // dummy_t.state = Any_uint8_Except(CFDP_IDLE); /* asserts */ - /* Arrange for CF_CFDP_FindUnusedTransaction */ - dummy_c->qs[CF_Q_FREE] = &dummy_t.cl_node; - dummy_c->qs[CF_Q_HIST] = &dummy_t.history->cl_node; - dummy_c->qs[CF_Q_HIST_FREE] = NULL; /* always chooses CF_Q_HIST */ + // /* Arrange for CF_CFDP_FindUnusedTransaction */ + // dummy_c->qs[CF_Q_FREE] = &dummy_t.cl_node; + // dummy_c->qs[CF_Q_HIST] = &dummy_t.history->cl_node; + // dummy_c->qs[CF_Q_HIST_FREE] = NULL; /* always chooses CF_Q_HIST */ - /* Arrange for CF_CList_Remove_Ex */ - CF_AppData.hk.channel_hk[dummy_c-CF_AppData.engine.channels].q_size[CF_Q_FREE] = 1; /* avoid assert first call */ - CF_AppData.hk.channel_hk[dummy_c-CF_AppData.engine.channels].q_size[CF_Q_HIST] = 1; /* avoid assert second call */ + // /* Arrange for CF_CList_Remove_Ex */ + // CF_AppData.hk.channel_hk[dummy_c-CF_AppData.engine.channels].q_size[CF_Q_FREE] = 1; /* avoid assert first call */ + // CF_AppData.hk.channel_hk[dummy_c-CF_AppData.engine.channels].q_size[CF_Q_HIST] = 1; /* avoid assert second call */ - /* Act */ + // /* Act */ // result = CF_CFDP_TxFile(arg_src_filename, // arg_dst_filename, // arg_cfdp_class, @@ -6399,14 +6510,14 @@ void Test_CF_CFDP_TxFile_AssertsBecause_t_state_IsNotEqTo_CFDP_IDLE(void) // arg_dest_id); - /* Assert */ - UtAssert_Failed("CF_Assert issue - t->state==CFDP_IDLE"); + // /* Assert */ // UtAssert_UINT32_EQ(result, CFE_SUCCESS); // /* Assert for CF_CFDP_TxFile_ */ // UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); // UtAssert_True(EventID == CF_EID_INF_CFDP_S_START_SEND, // "CFE_EVS_SendEvent receive event id %u and should receive %u (CF_EID_INF_CFDP_S_START_SEND)", // EventID, CF_EID_INF_CFDP_S_START_SEND); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - t->state==CFDP_IDLE"); } /* end Test_CF_CFDP_TxFile_AssertsBecause_t_state_IsNotEqTo_CFDP_IDLE */ void Test_CF_CFDP_TxFile_SuccessIncrements_c_num_cmd_tx_AndSets_t_flags_tx_cmd_tx_To_1(void) @@ -6603,11 +6714,11 @@ void Test_CF_CFDP_PlaybackDir_All_p_busy_Are_1_SendEventThenReturn_neg1(void) /* Arrange */ const char arg_src_filename[CF_FILENAME_MAX_LEN]; const char arg_dst_filename[CF_FILENAME_MAX_LEN]; - cfdp_class_t arg_cfdp_class; - uint8 arg_keep; + cfdp_class_t arg_cfdp_class = Any_cfdp_class_t(); + uint8 arg_keep = Any_uint8(); uint8 arg_chan = Any_cf_chan_num(); - uint8 arg_priority; - uint16 arg_dest_id; + uint8 arg_priority = Any_uint8(); + uint16 arg_dest_id = Any_uint16(); int i = 0; for(i=0; idiropen = 1; arg_p->num_ts = Any_uint8_BetweenExcludeMax(1, CF_NUM_TRANSACTIONS_PER_PLAYBACK); @@ -6775,7 +6886,7 @@ void Test_CF_CFDP_ProcessPlaybackDirectory_FirstCallTo_OS_DirectoryRead_Returns_ channel_t* arg_c = &dummy_c; playback_t dummy_p; playback_t* arg_p = &dummy_p; - const char context_OS_DirectoryRead[OS_MAX_FILE_NAME] = "..\0"; + char context_OS_DirectoryRead[OS_MAX_FILE_NAME] = "..\0"; arg_p->diropen = 1; arg_p->num_ts = 0; @@ -6806,42 +6917,41 @@ void Test_CF_CFDP_ProcessPlaybackDirectory_FirstCallTo_OS_DirectoryRead_Returns_ void Test_CF_CFDP_ProcessPlaybackDirectory_AssertsBecause_CallTo_CF_CFDP_FindUnusedTransaction_Returns_NULL(void) { - /* Arrange */ - channel_t* arg_c = &CF_AppData.engine.channels[Any_cf_chan_num()]; - playback_t dummy_p; - playback_t* arg_p = &dummy_p; - const char context_OS_DirectoryRead[OS_MAX_FILE_NAME]; - history_t dummy_history; - transaction_t dummy_pt; + // /* Arrange */ + // channel_t* arg_c = &CF_AppData.engine.channels[Any_cf_chan_num()]; + // playback_t dummy_p; + // playback_t* arg_p = &dummy_p; + // const char context_OS_DirectoryRead[OS_MAX_FILE_NAME]; + // history_t dummy_history; + // transaction_t dummy_pt; - AnyRandomStringOfLettersOfLengthCopy(context_OS_DirectoryRead, OS_MAX_FILE_NAME - 1); + // AnyRandomStringOfLettersOfLengthCopy(context_OS_DirectoryRead, OS_MAX_FILE_NAME - 1); - arg_p->diropen = 1; - arg_p->num_ts = CF_NUM_TRANSACTIONS_PER_PLAYBACK - 1; /* run one loop */ + // arg_p->diropen = 1; + // arg_p->num_ts = CF_NUM_TRANSACTIONS_PER_PLAYBACK - 1; /* run one loop */ - arg_p->busy = 1; + // arg_p->busy = 1; - UT_SetDefaultReturnValue(UT_KEY(OS_DirectoryRead), CFE_SUCCESS); - UT_SetDeferredRetcode(UT_KEY(OS_DirectoryRead), 2, Any_int32_Except(CFE_SUCCESS)); + // UT_SetDefaultReturnValue(UT_KEY(OS_DirectoryRead), CFE_SUCCESS); + // UT_SetDeferredRetcode(UT_KEY(OS_DirectoryRead), 2, Any_int32_Except(CFE_SUCCESS)); - UT_SetDataBuffer(UT_KEY(OS_DirectoryRead), context_OS_DirectoryRead, - sizeof(context_OS_DirectoryRead), false); + // UT_SetDataBuffer(UT_KEY(OS_DirectoryRead), context_OS_DirectoryRead, + // sizeof(context_OS_DirectoryRead), false); - UT_SetHandlerFunction(UT_KEY(OS_DirectoryClose), Handler_OS_DirectoryClose_ReportOnly, NULL); + // UT_SetHandlerFunction(UT_KEY(OS_DirectoryClose), Handler_OS_DirectoryClose_ReportOnly, NULL); - dummy_pt.history = &dummy_history; + // dummy_pt.history = &dummy_history; - AnyRandomStringOfLettersOfLengthCopy(dummy_pt.history->fnames.src_filename, CF_FILENAME_MAX_LEN - 1); - AnyRandomStringOfLettersOfLengthCopy(dummy_pt.history->fnames.dst_filename, CF_FILENAME_MAX_LEN - 1); + // AnyRandomStringOfLettersOfLengthCopy(dummy_pt.history->fnames.src_filename, CF_FILENAME_MAX_LEN - 1); + // AnyRandomStringOfLettersOfLengthCopy(dummy_pt.history->fnames.dst_filename, CF_FILENAME_MAX_LEN - 1); - /* Arrange for CF_CFDP_FindUnusedTransaction */ - arg_c->qs[CF_Q_FREE] = NULL; + // /* Arrange for CF_CFDP_FindUnusedTransaction */ + // arg_c->qs[CF_Q_FREE] = NULL; - /* Act */ + // /* Act */ // CF_CFDP_ProcessPlaybackDirectory(arg_c, arg_p); - /* Assert */ - UtAssert_Failed("CF_Assert issue - pt (is NULL)"); + // /* Assert */ // UtAssert_STUB_COUNT(OS_DirectoryRead, 1); // UtAssert_STUB_COUNT(OS_DirectoryClose, 0); // UtAssert_True(arg_p->diropen == 1, @@ -6857,6 +6967,7 @@ void Test_CF_CFDP_ProcessPlaybackDirectory_AssertsBecause_CallTo_CF_CFDP_FindUnu // UtAssert_STUB_COUNT(CF_CList_Remove, 2); // /* Assert for CF_CFDP_FindUnusedChunks */ // UtAssert_STUB_COUNT(CF_CList_Pop, 1); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - pt "); } /* end Test_CF_CFDP_ProcessPlaybackDirectory_AssertsBecause_CallTo_CF_CFDP_FindUnusedTransaction_Returns_NULL */ void Test_CF_CFDP_ProcessPlaybackDirectory_FirstCallTo_OS_DirectoryRead_Returns_CFE_SUCCESS_AndCheckThat_dirent_FileName_IsDirectoryDotsFailsThenCall_CF_CFDP_FindUnusedTransaction_And_CF_CFDP_TxFile__Increment_p_num_ts_ExitLoop(void) @@ -6865,7 +6976,7 @@ void Test_CF_CFDP_ProcessPlaybackDirectory_FirstCallTo_OS_DirectoryRead_Returns_ channel_t* arg_c = &CF_AppData.engine.channels[Any_cf_chan_num()]; playback_t dummy_p; playback_t* arg_p = &dummy_p; - const char context_OS_DirectoryRead[OS_MAX_FILE_NAME]; + char context_OS_DirectoryRead[OS_MAX_FILE_NAME]; history_t dummy_history; transaction_t dummy_pt; @@ -6933,7 +7044,7 @@ void Test_CF_CFDP_ProcessPlaybackDirectory_FirstCallTo_OS_DirectoryRead_Returns_ /******************************************************************************* ** -** CF_CFDP_UpdatePollPbCounted tests (small) - full coverage - 1 CF_Assert - [] +** CF_CFDP_UpdatePollPbCounted tests (small) - full coverage - 1 coverage JIRA issue - [] ** *******************************************************************************/ @@ -7005,7 +7116,7 @@ void Test_CF_CFDP_UpdatePollPbCounted_AssertsBecause_pb_counted_IsNotEqTo_up_And //CF_CFDP_UpdatePollPbCounted(arg_pb, arg_up, arg_counter); /* Assert */ - UtAssert_Failed("CF_Assert issue"); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - *counter"); } /* end Test_CF_CFDP_UpdatePollPbCounted_DecrementsValueAt_counter_Because_pb_counted_IsNotEqTo_up_And_up_Is_0 */ void Test_CF_CFDP_UpdatePollPbCounted_DecrementsValueAt_counter_Because_pb_counted_IsNotEqTo_up_And_up_Is_0(void) @@ -7110,7 +7221,7 @@ void Test_CF_CFDP_ProcessPollingDirectories_CallsOnly_CF_CFDP_UpdatePollPbCounte /* Assert for CF_CFDP_UpdatePollPbCounted */ UtAssert_True(CF_AppData.hk.channel_hk[dummy_chan_index].poll_counter == 0, "poll_counter is %u and should be 0 (was CF_MAX_POLLING_DIR_PER_CHAN)", - CF_AppData.hk.channel_hk[dummy_chan_index].poll_counter, 0); + CF_AppData.hk.channel_hk[dummy_chan_index].poll_counter); } /* end Test_CF_CFDP_ProcessPollingDirectories_CallsOnly_CF_CFDP_UpdatePollPbCounted_When_pd_enabled_Is_0 */ void Test_CF_CFDP_ProcessPollingDirectories_CallsOnly_CF_CFDP_UpdatePollPbCounted_When_pd_interval_sec_Is_0(void) @@ -7139,7 +7250,7 @@ void Test_CF_CFDP_ProcessPollingDirectories_CallsOnly_CF_CFDP_UpdatePollPbCounte /* Assert for CF_CFDP_UpdatePollPbCounted */ UtAssert_True(CF_AppData.hk.channel_hk[dummy_chan_index].poll_counter == 0, "poll_counter is %u and should be 0 (was CF_MAX_POLLING_DIR_PER_CHAN)", - CF_AppData.hk.channel_hk[dummy_chan_index].poll_counter, 0); + CF_AppData.hk.channel_hk[dummy_chan_index].poll_counter); } /* end Test_CF_CFDP_ProcessPollingDirectories_CallsOnly_CF_CFDP_UpdatePollPbCounted_When_pd_interval_sec_Is_0 */ void Test_CF_CFDP_ProcessPollingDirectories_When_p_pb_busy_Is_true_PlaybackIsActive_Calls_CF_CFDP_ProcessPlaybackDirectory_Sets_count_check_To_1_Calls_CF_CFDP_UpdatePollPbCounted(void) @@ -7406,16 +7517,14 @@ void Test_CF_CFDP_CycleEngine_DoesNothingWhen_engine_Is_0(void) /* Arrange */ CFE_SB_Buffer_t dummy_msg; - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; CF_AppData.engine.enabled = 0; /* Act */ CF_CFDP_CycleEngine(); /* Assert */ - UtAssert_True(CF_AppData.engine.in.msg == &dummy_msg, - "CF_AppData.engine.in.msg is %p and has not changed from %p (value before call)", - CF_AppData.engine.in.msg, &dummy_msg); + UtAssert_ADDRESS_EQ(CF_AppData.engine.in.msg, &dummy_msg); } /* end Test_CF_CFDP_CycleEngine_DoesNothingWhen_engine_Is_0 */ void Test_CF_CFDP_CycleEngine_ConsumesAllMessagesWithAllChannelsFrozen(void) @@ -7425,7 +7534,7 @@ void Test_CF_CFDP_CycleEngine_ConsumesAllMessagesWithAllChannelsFrozen(void) CFE_SB_Buffer_t dummy_msg; int i = 0; - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; CF_AppData.engine.enabled = 1; CF_AppData.config_table = &dummy_config_table; @@ -7445,9 +7554,7 @@ void Test_CF_CFDP_CycleEngine_ConsumesAllMessagesWithAllChannelsFrozen(void) /* Assert */ UtAssert_STUB_COUNT(CFE_SB_ReceiveBuffer, CF_NUM_CHANNELS); /* Assert for CF_CFDP_ReceiveMessage */ - UtAssert_True(CF_AppData.engine.in.msg == NULL, - "CF_AppData.engine.in.msg is %p and has not changed from %p (value before call)", - CF_AppData.engine.in.msg, NULL); + UtAssert_ADDRESS_EQ(CF_AppData.engine.in.msg, NULL); } /* end Test_CF_CFDP_CycleEngine_ConsumesAllMessagesWithAllChannelsFrozen */ void Test_CF_CFDP_CycleEngine_WhenOneChannelNotFrozenCalls_CF_CFDP_TickTransactions_And_CF_CFDP_CycleTx_And_CF_CFDP_ProcessPlaybackDirectories_And_CF_CFDP_ProcessPollingDirectories(void) @@ -7457,7 +7564,7 @@ void Test_CF_CFDP_CycleEngine_WhenOneChannelNotFrozenCalls_CF_CFDP_TickTransacti CFE_SB_Buffer_t dummy_msg; int i = 0; - CF_AppData.engine.in.msg = &dummy_msg; + CF_AppData.engine.in.msg = (CFE_SB_Buffer_t*)&dummy_msg; CF_AppData.engine.enabled = 1; CF_AppData.config_table = &dummy_config_table; @@ -7478,12 +7585,13 @@ void Test_CF_CFDP_CycleEngine_WhenOneChannelNotFrozenCalls_CF_CFDP_TickTransacti channel_t* dummy_c = &CF_AppData.engine.channels[0]; dummy_c->tick_type = CF_TICK_NUM_TYPES - 1; + type_of_context_CF_CList_Traverse = POINTER; /* Arrange for CF_CFDP_CycleTx */ transaction_t dummy_t; CF_AppData.config_table->chan[0].dequeue_enabled = 1; - dummy_c->cur = &dummy_t.cl_node; /* CF_AppData.engine.channels[0].cur = &dummy_t forces if statement to NOT fire */ + dummy_c->cur = &dummy_t; /* Arrange for CF_CFDP_ProcessPlaybackDirectories, CF_CFDP_ProcessPlaybackDirectory, CF_CFDP_UpdatePollPbCounted */ playback_t* dummy_p[CF_MAX_COMMANDED_PLAYBACK_DIRECTORIES_PER_CHAN] = {0}; @@ -7512,9 +7620,7 @@ void Test_CF_CFDP_CycleEngine_WhenOneChannelNotFrozenCalls_CF_CFDP_TickTransacti /* Assert */ UtAssert_STUB_COUNT(CFE_SB_ReceiveBuffer, 1); /* Assert for CF_CFDP_ReceiveMessage */ - UtAssert_True(CF_AppData.engine.in.msg == NULL, - "CF_AppData.engine.in.msg is %p and has not changed from %p (value before call)", - CF_AppData.engine.in.msg, NULL); + UtAssert_ADDRESS_EQ(CF_AppData.engine.in.msg, NULL); /* Assert for CF_CFDP_TickTransactions */ UtAssert_STUB_COUNT(CF_CList_Traverse, 1); /* Assert for CF_CFDP_CycleTx */ @@ -7534,27 +7640,27 @@ void Test_CF_CFDP_CycleEngine_WhenOneChannelNotFrozenCalls_CF_CFDP_TickTransacti /******************************************************************************* ** -** CF_CFDP_ResetTransaction tests (very large) - full coverage - 4 CF_Assert (1 causes a line and a branch problem) [unstubbables: CF_CFDP_IsSender, CF_CList_InsertBack_Ex, CF_CFDP_IsSender (yes twice), CF_CFDP_FreeTransaction] +** CF_CFDP_ResetTransaction tests (very large) - full coverage - 4 coverage JIRA issues (1 causes a line and a branch problem) [unstubbables: CF_CFDP_IsSender, CF_CList_InsertBack_Ex, CF_CFDP_IsSender (yes twice), CF_CFDP_FreeTransaction] ** *******************************************************************************/ void Test_CF_CFDP_ResetTransaction_AssertsBecause_t_chan_num_IsEqTo_CF_NUM_CHANNELS(void) { - /* Arrange */ - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; - int arg_keep_history = Any_int(); + // /* Arrange */ + // transaction_t dummy_t; + // transaction_t* arg_t = &dummy_t; + // int arg_keep_history = Any_int(); - arg_t->chan_num = CF_NUM_CHANNELS; + // arg_t->chan_num = CF_NUM_CHANNELS; - /* Act */ - //CF_CFDP_ResetTransaction(arg_t, arg_keep_history); + // /* Act */ + // CF_CFDP_ResetTransaction(arg_t, arg_keep_history); - /* Assert */ - UtAssert_Failed("CF_Assert Issue: t->chan_numchan_numchan_numchan_numfd = Any_uint32_Except(0); /* Any_uint32_Except(0) causes OS_ObjectIdDefined (non 0 != 0) to return true */ + arg_t->fd = Any_uint32_Except(0); /* Any_uint32_Except(0) causes OS_ObjectIdDefined (non 0 != 0) to return true */ + + /* Arrange for CF_CFDP_GetClass */ + arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ /* Act */ CF_CFDP_ResetTransaction(arg_t, arg_keep_history); @@ -7630,7 +7739,7 @@ void Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_true_Call_C expected_path = arg_t->history->fnames.dst_filename; /* either arg_t or history becomes NULL during CUT run, so save the location that will was sent as argument to OS_remove */ /* Arrange for OS_ObjectIdDefined */ - arg_t->fd = Any_uint32_Except(0); /* Any_uint32_Except(0) causes OS_ObjectIdDefined (non 0 != 0) to return true */ + arg_t->fd = Any_uint32_Except(0); /* Any_uint32_Except(0) causes OS_ObjectIdDefined (non 0 != 0) to return true */ /* Arrange for CF_CFDP_IsSender */ arg_t->flags.all.q_index = CF_Q_RX; /* bypass CF_Assert */ @@ -7719,6 +7828,9 @@ void Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t /* Arrange for OS_ObjectIdDefined */ arg_t->fd = 0; /* arg_t->fd = 0 causes OS_ObjectIdDefined (0 != 0) to return false */ + + /* Arrange for CF_CFDP_GetClass */ + arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ /* Act */ CF_CFDP_ResetTransaction(arg_t, arg_keep_history); @@ -7751,6 +7863,9 @@ void Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t /* Arrange for OS_ObjectIdDefined */ arg_t->fd = 0; /* arg_t->fd = 0 causes OS_ObjectIdDefined (0 != 0) to return false */ + + /* Arrange for CF_CFDP_GetClass */ + arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ /* Act */ CF_CFDP_ResetTransaction(arg_t, arg_keep_history); @@ -7787,6 +7902,9 @@ void Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t /* Arrange for OS_ObjectIdDefined */ arg_t->fd = 0; /* arg_t->fd = 0 causes OS_ObjectIdDefined (0 != 0) to return false */ + + /* Arrange for CF_CFDP_GetClass */ + arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ /* Act */ CF_CFDP_ResetTransaction(arg_t, arg_keep_history); @@ -7803,34 +7921,36 @@ void Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t void Test_CF_CFDP_ResetTransaction_AssertsBecause_c_num_cmd_tx_Is_0(void) { - /* Arrange */ - history_t dummy_history; - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; - int arg_keep_history = Any_int_Except(0); - cf_queue_index_t recorded_index[2]; + // /* Arrange */ + // history_t dummy_history; + // transaction_t dummy_t; + // transaction_t* arg_t = &dummy_t; + // int arg_keep_history = Any_int_Except(0); + // cf_queue_index_t recorded_index[2]; - arg_t->chan_num = Any_cf_chan_num(); + // arg_t->chan_num = Any_cf_chan_num(); - arg_t->history = &dummy_history; - arg_t->history->dir = CF_DIR_TX; + // arg_t->history = &dummy_history; + // arg_t->history->dir = CF_DIR_TX; - arg_t->flags.tx.cmd_tx = Any_uint32_Except(0); /* TODO make Any_unsigned_int_Except() */ + // arg_t->flags.tx.cmd_tx = Any_uint32_Except(0); /* TODO make Any_unsigned_int_Except() */ - (&CF_AppData.engine.channels[arg_t->chan_num])->num_cmd_tx = 0; + // (&CF_AppData.engine.channels[arg_t->chan_num])->num_cmd_tx = 0; - arg_t->p = NULL; + // arg_t->p = NULL; - UT_SetHandlerFunction(UT_KEY(CF_CList_InsertBack_Ex), handler_CF_CList_InsertBack_Ex_Record_indexes, &recorded_index); + // UT_SetHandlerFunction(UT_KEY(CF_CList_InsertBack_Ex), handler_CF_CList_InsertBack_Ex_Record_indexes, &recorded_index); - /* Arrange for OS_ObjectIdDefined */ - arg_t->fd = 0; /* arg_t->fd = 0 causes OS_ObjectIdDefined (0 != 0) to return false */ + // /* Arrange for OS_ObjectIdDefined */ + // arg_t->fd = 0; /* arg_t->fd = 0 causes OS_ObjectIdDefined (0 != 0) to return false */ + + // /* Arrange for CF_CFDP_GetClass */ + // arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ - /* Act */ - //CF_CFDP_ResetTransaction(arg_t, arg_keep_history); + // /* Act */ + // CF_CFDP_ResetTransaction(arg_t, arg_keep_history); - /* Assert */ - UtAssert_Failed("CF_Assert issue - c->num_cmd_tx"); + // /* Assert */ // UtAssert_STUB_COUNT(cf_dequeue_transaction, 1); // UtAssert_STUB_COUNT(CF_WrappedClose, 0); // UtAssert_UINT32_EQ((&CF_AppData.engine.channels[arg_t->chan_num])->num_cmd_tx, initial_num_cmd_tx - 1); @@ -7839,6 +7959,7 @@ void Test_CF_CFDP_ResetTransaction_AssertsBecause_c_num_cmd_tx_Is_0(void) // "index sent to first call of CF_CList_InsertBack_Ex was %u and should be %u (CF_Q_HIST)", // recorded_index[0], CF_Q_HIST); // UtAssert_STUB_COUNT(CF_CList_InsertBack, 1); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - c->num_cmd_tx"); } /* end Test_CF_CFDP_ResetTransaction_AssertsBecause_c_num_cmd_tx_Is_0 */ void Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t_history_dir_Is_CF_DIR_TX_And_t_flags_tx_cmd_tx_Is_1_And_keep_history_Is_non0_Call_CF_CList_InsertBack_Ex_With_CF_Q_HIST_ThenCall_CF_CList_InsertBack_And_CF_CFDP_FreeTransaction(void) @@ -7866,6 +7987,9 @@ void Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t /* Arrange for OS_ObjectIdDefined */ arg_t->fd = 0; /* arg_t->fd = 0 causes OS_ObjectIdDefined (0 != 0) to return false */ + + /* Arrange for CF_CFDP_GetClass */ + arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ /* Act */ CF_CFDP_ResetTransaction(arg_t, arg_keep_history); @@ -7881,6 +8005,50 @@ void Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t UtAssert_STUB_COUNT(CF_CList_InsertBack, 1); } /* end Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t_history_dir_Is_CF_DIR_TX_And_t_flags_tx_cmd_tx_Is_1_And_keep_history_Is_non0_Call_CF_CList_InsertBack_Ex_With_CF_Q_HIST_ThenCall_CF_CList_InsertBack_And_CF_CFDP_FreeTransaction */ +void Test_CF_CFDP_ResetTransaction_AssertsBecause_t_p_num_ts_Is_0(void) +{ + // /* Arrange */ + // history_t dummy_history; + // transaction_t dummy_t; + // transaction_t* arg_t = &dummy_t; + // uint32 initial_num_cmd_tx = Any_uint32_Except(0); + // int arg_keep_history = Any_int_Except(0); + // cf_queue_index_t recorded_index[2]; + + // arg_t->chan_num = Any_cf_chan_num(); + + // arg_t->history = &dummy_history; + // arg_t->history->dir = CF_DIR_TX; + + // arg_t->flags.tx.cmd_tx = 1; + + // (&CF_AppData.engine.channels[arg_t->chan_num])->num_cmd_tx = initial_num_cmd_tx; + + // arg_t->p = NULL; + + // UT_SetHandlerFunction(UT_KEY(CF_CList_InsertBack_Ex), handler_CF_CList_InsertBack_Ex_Record_indexes, &recorded_index); + + // /* Arrange for OS_ObjectIdDefined */ + // arg_t->fd = 0; /* arg_t->fd = 0 causes OS_ObjectIdDefined (0 != 0) to return false */ + + // /* Arrange for CF_CFDP_GetClass */ + // arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ + + // /* Act */ + // CF_CFDP_ResetTransaction(arg_t, arg_keep_history); + + // /* Assert */ + // UtAssert_STUB_COUNT(cf_dequeue_transaction, 1); + // UtAssert_STUB_COUNT(CF_WrappedClose, 0); + // UtAssert_UINT32_EQ((&CF_AppData.engine.channels[arg_t->chan_num])->num_cmd_tx, initial_num_cmd_tx - 1); + // UtAssert_STUB_COUNT(CF_CList_InsertBack_Ex, 2); /* Includes one call in CF_CFDP_FreeTransaction */ + // UtAssert_True(recorded_index[0] == CF_Q_HIST, + // "index sent to first call of CF_CList_InsertBack_Ex was %u and should be %u (CF_Q_HIST)", + // recorded_index[0], CF_Q_HIST); + // UtAssert_STUB_COUNT(CF_CList_InsertBack, 1); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert: t->p->num_ts"); +} /* end Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t_history_dir_Is_CF_DIR_TX_And_t_flags_tx_cmd_tx_Is_1_And_keep_history_Is_non0_Call_CF_CList_InsertBack_Ex_With_CF_Q_HIST_ThenCall_CF_CList_InsertBack_And_CF_CFDP_FreeTransaction */ + void Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t_history_dir_Is_CF_DIR_TX_And_t_p_Is_nonNULL_And_keep_history_Is_non0_Call_CF_CList_InsertBack_Ex_With_CF_Q_HIST_ThenCall_CF_CList_InsertBack_And_CF_CFDP_FreeTransaction(void) { /* Arrange */ @@ -7906,6 +8074,9 @@ void Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t /* Arrange for OS_ObjectIdDefined */ arg_t->fd = 0; /* arg_t->fd = 0 causes OS_ObjectIdDefined (0 != 0) to return false */ + + /* Arrange for CF_CFDP_GetClass */ + arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ /* Act */ CF_CFDP_ResetTransaction(arg_t, arg_keep_history); @@ -7923,32 +8094,34 @@ void Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t void Test_CF_CFDP_ResetTransaction_AssertsBecause_t_history_dir_IsNeither_CF_DIR_TX_or_CF_DIR_RX(void) { - /* Arrange */ - history_t dummy_history; - transaction_t dummy_t; - transaction_t* arg_t = &dummy_t; - playback_t dummy_p; - uint16 initial_num_ts = Any_uint16_Except(0); - int arg_keep_history = Any_int_Except(0); - uint8 exceptions[2] = {CF_DIR_RX, CF_DIR_TX}; - cf_queue_index_t recorded_index[2]; + // /* Arrange */ + // history_t dummy_history; + // transaction_t dummy_t; + // transaction_t* arg_t = &dummy_t; + // playback_t dummy_p; + // uint16 initial_num_ts = Any_uint16_Except(0); + // int arg_keep_history = Any_int_Except(0); + // uint8 exceptions[2] = {CF_DIR_RX, CF_DIR_TX}; + // cf_queue_index_t recorded_index[2]; - arg_t->chan_num = Any_cf_chan_num(); + // arg_t->chan_num = Any_cf_chan_num(); - arg_t->history = &dummy_history; - arg_t->history->dir = Any_uint8_ExceptThese(exceptions, 2); + // arg_t->history = &dummy_history; + // arg_t->history->dir = Any_uint8_ExceptThese(exceptions, 2); - /* Arrange for OS_ObjectIdDefined */ - arg_t->fd = 0; /* arg_t->fd = 0 causes OS_ObjectIdDefined (0 != 0) to return false */ + // /* Arrange for OS_ObjectIdDefined */ + // arg_t->fd = 0; /* arg_t->fd = 0 causes OS_ObjectIdDefined (0 != 0) to return false */ + + // /* Arrange for CF_CFDP_GetClass */ + // arg_t->flags.all.q_index = CF_Q_PEND; /* arg_t->flags.all.q_index = CF_Q_PEND ensures ti->flags.all.q_index!=CF_Q_FREE is never false */ - /* Act */ + // /* Act */ // CF_CFDP_ResetTransaction(arg_t, arg_keep_history); - /* Assert */ - UtAssert_Failed("CF_Assert issue - 0 (no not a typo, literally 0 is this one, comes from a default switch)"); + // /* Assert */ // UtAssert_STUB_COUNT(cf_dequeue_transaction, 1); // UtAssert_STUB_COUNT(CF_WrappedClose, 0); - + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - 0 (no not a typo, literally 0 is this one, comes from a default switch)"); } /* end Test_CF_CFDP_ResetTransaction_AssertsBecause_t_history_dir_IsNeither_CF_DIR_TX_or_CF_DIR_RX */ /* end CF_CFDP_ResetTransaction tests */ @@ -8123,7 +8296,6 @@ void Test_CF_CFDP_CancelTransaction_DoesNothingBecause_flags_all_cancelled_IsAlr /* Act */ CF_CFDP_CancelTransaction(arg_t); - /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_R_Cancel, 0); UtAssert_STUB_COUNT(CF_CFDP_S_Cancel, 0); @@ -8156,13 +8328,10 @@ void Test_CF_CFDP_CancelTransaction_Because_flags_all_canceled_IsFalse_CancelesT /* Act */ CF_CFDP_CancelTransaction(arg_t); - /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_R_Cancel, 0); UtAssert_STUB_COUNT(CF_CFDP_S_Cancel, 1); - UtAssert_True(context_CF_CFDP_S_Cancel == arg_t, - "CF_CFDP_S_Cancel received t %p and should receive %p (t)", - context_CF_CFDP_S_Cancel, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_S_Cancel, arg_t); UtAssert_True(arg_t->flags.all.canceled == 1, "t->flags.all.canceled is %d and should not have changed from 1", arg_t->flags.all.canceled); @@ -8192,12 +8361,9 @@ void Test_CF_CFDP_CancelTransaction_Because_flags_all_canceled_IsFalse_CancelesT /* Act */ CF_CFDP_CancelTransaction(arg_t); - /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_R_Cancel, 1); - UtAssert_True(context_CF_CFDP_R_Cancel == arg_t, - "CF_CFDP_R_Cancel received t %p and should receive %p (t)", - context_CF_CFDP_R_Cancel, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_R_Cancel, arg_t); UtAssert_STUB_COUNT(CF_CFDP_S_Cancel, 0); UtAssert_True(arg_t->flags.all.canceled == 1, "t->flags.all.canceled is %d and should not have changed from 1", @@ -8226,7 +8392,6 @@ void Test_CF_CFDP_CloseFiles_DoesNothingBecause_t_fd_Is_0_Returns_CLIST_CONT(voi /* Act */ local_result = CF_CFDP_CloseFiles(arg_n, arg_context); - /* Assert */ UtAssert_True(local_result == CLIST_CONT, "CF_CFDP_CloseFiles returned %u and should be %u (CLIST_CONT)", @@ -8252,7 +8417,6 @@ void Test_CF_CFDP_CloseFiles_Calls_CF_WrappedClose_Because_t_fd_Is_not0_Returns_ /* Act */ local_result = CF_CFDP_CloseFiles(arg_n, arg_context); - /* Assert */ UtAssert_True(local_result == CLIST_CONT, "CF_CFDP_CloseFiles returned %u and should be %u (CLIST_CONT)", @@ -8327,7 +8491,6 @@ void Test_CF_CFDP_DisableEngine_ClosesAllActiveFilesAndNoOpenPlaybackDirectories /* Act */ CF_CFDP_DisableEngine(); - /* Assert */ for(ci = 0; ci < CF_NUM_CHANNELS; ++ci) { @@ -8335,15 +8498,9 @@ void Test_CF_CFDP_DisableEngine_ClosesAllActiveFilesAndNoOpenPlaybackDirectories for(node_i = 0; node_i < num_clist_node_ptrs; ++node_i) { - UtAssert_True(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].start == dummy_channel[ci]->qs[qs_index[node_i]], - "Call %u to CF_CList_Traverse received start %p and should be %p (c->qs[%u])", - (ci * num_clist_node_ptrs) + node_i, context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].start, dummy_channel[ci]->qs[qs_index[node_i]], qs_index[node_i]); - UtAssert_True(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].fn == CF_CFDP_CloseFiles, - "Call %u to CF_CList_Traverse received fn %p and should be %p (CF_CFDP_CloseFiles)", - (ci * num_clist_node_ptrs) + node_i, context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].fn, CF_CFDP_CloseFiles); - UtAssert_True(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].context == NULL, - "Call %u to CF_CList_Traverse received context %p and should be %p (NULL)", - (ci * num_clist_node_ptrs) + node_i, context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].context, NULL); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].start, dummy_channel[ci]->qs[qs_index[node_i]]); + UtAssert_True(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].fn == CF_CFDP_CloseFiles, "context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].fn == CF_CFDP_CloseFiles"); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].context, NULL); } UtAssert_MemCmpValue(&CF_AppData.hk.channel_hk[ci].q_size, 0, sizeof(CF_AppData.hk.channel_hk[ci].q_size), @@ -8437,7 +8594,6 @@ void Test_CF_CFDP_DisableEngine_ClosesAllActiveFilesAndAnyOpenPlaybackDirectorie /* Act */ CF_CFDP_DisableEngine(); - /* Assert */ for(ci = 0; ci < CF_NUM_CHANNELS; ++ci) { @@ -8445,15 +8601,9 @@ void Test_CF_CFDP_DisableEngine_ClosesAllActiveFilesAndAnyOpenPlaybackDirectorie for(node_i = 0; node_i < num_clist_node_ptrs; ++node_i) { - UtAssert_True(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].start == dummy_channel[ci]->qs[qs_index[node_i]], - "Call %u to CF_CList_Traverse received start %p and should be %p (c->qs[%u])", - (ci * num_clist_node_ptrs) + node_i, context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].start, dummy_channel[ci]->qs[qs_index[node_i]], qs_index[node_i]); - UtAssert_True(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].fn == CF_CFDP_CloseFiles, - "Call %u to CF_CList_Traverse received fn %p and should be %p (CF_CFDP_CloseFiles)", - (ci * num_clist_node_ptrs) + node_i, context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].fn, CF_CFDP_CloseFiles); - UtAssert_True(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].context == NULL, - "Call %u to CF_CList_Traverse received context %p and should be %p (NULL)", - (ci * num_clist_node_ptrs) + node_i, context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].context, NULL); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].start, dummy_channel[ci]->qs[qs_index[node_i]]); + UtAssert_True(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].fn == CF_CFDP_CloseFiles, "context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].fn == CF_CFDP_CloseFiles"); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].context, NULL); } UtAssert_MemCmpValue(&CF_AppData.hk.channel_hk[ci].q_size, 0, sizeof(CF_AppData.hk.channel_hk[ci].q_size), @@ -8539,15 +8689,9 @@ void Test_CF_CFDP_DisableEngine_ClosesAllActiveFilesAndAllOpenPlaybackDirectorie for(node_i = 0; node_i < num_clist_node_ptrs; ++node_i) { - UtAssert_True(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].start == dummy_channel[ci]->qs[qs_index[node_i]], - "Call %u to CF_CList_Traverse received start %p and should be %p (c->qs[%u])", - (ci * num_clist_node_ptrs) + node_i, context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].start, dummy_channel[ci]->qs[qs_index[node_i]], qs_index[node_i]); - UtAssert_True(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].fn == CF_CFDP_CloseFiles, - "Call %u to CF_CList_Traverse received fn %p and should be %p (CF_CFDP_CloseFiles)", - (ci * num_clist_node_ptrs) + node_i, context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].fn, CF_CFDP_CloseFiles); - UtAssert_True(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].context == NULL, - "Call %u to CF_CList_Traverse received context %p and should be %p (NULL)", - (ci * num_clist_node_ptrs) + node_i, context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].context, NULL); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].start, dummy_channel[ci]->qs[qs_index[node_i]]); + UtAssert_True(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].fn == CF_CFDP_CloseFiles, "context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].fn == CF_CFDP_CloseFiles"); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse[(ci * num_clist_node_ptrs) + node_i].context, NULL); } UtAssert_MemCmpValue(&CF_AppData.hk.channel_hk[ci].q_size, 0, sizeof(CF_AppData.hk.channel_hk[ci].q_size), @@ -8580,59 +8724,59 @@ void Test_CF_CFDP_DisableEngine_ClosesAllActiveFilesAndAllOpenPlaybackDirectorie void add_CF_CFDP_ArmAckTimer_tests(void) { - UtTest_Add(Test_CF_CFDP_ArmAckTimer_Calls_CF_Timer_InitRelSec_WithCorrectParamsAndArmsTimer, + UtTest_Add(Test_CF_CFDP_ArmAckTimer_Call_CF_Timer_InitRelSec_WithCorrectParamsAndArmsTimer, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_ArmAckTimer_Calls_CF_Timer_InitRelSec_WithCorrectParamsAndArmsTimer"); + "Test_CF_CFDP_ArmAckTimer_Call_CF_Timer_InitRelSec_WithCorrectParamsAndArmsTimer"); } void add_CF_CFDP_GetClass_tests(void) { - UtTest_Add(Test_CF_CFDP_GetClass_Asserts_q_index_IsEqTo_CF_Q_FREE, + UtTest_Add(Test_CF_CFDP_GetClass_AssertsBecause_q_index_IsEqTo_CF_Q_FREE, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_GetClass_Asserts_q_index_IsEqTo_CF_Q_FREE"); - UtTest_Add(Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenNeitherStateIsSet, + "Test_CF_CFDP_GetClass_AssertsBecause_q_index_IsEqTo_CF_Q_FREE"); + UtTest_Add(Test_CF_CFDP_GetClass_WhenNeitherStateIsSet_Return_CLASS_1, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenNeitherStateIsSet"); - UtTest_Add(Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenStateIs_CFDP_S2, + "Test_CF_CFDP_GetClass_WhenNeitherStateIsSet_Return_CLASS_1"); + UtTest_Add(Test_CF_CFDP_GetClass_WhenStateIs_CFDP_S2_Return_CLASS_1, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenStateIs_CFDP_S2"); - UtTest_Add(Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenStateIs_CFDP_R2, + "Test_CF_CFDP_GetClass_WhenStateIs_CFDP_S2_Return_CLASS_1"); + UtTest_Add(Test_CF_CFDP_GetClass_WhenStateIs_CFDP_R2_Return_CLASS_1, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_GetClass_Returns_CLASS_1_WhenStateIs_CFDP_R2"); + "Test_CF_CFDP_GetClass_WhenStateIs_CFDP_R2_Return_CLASS_1"); } void add_CF_CFDP_IsSender_tests(void) { - UtTest_Add(Test_CF_CFDP_IsSender_Asserts_q_index_IsEqTo_CF_Q_FREE, + UtTest_Add(Test_CF_CFDP_IsSender_AssertsBecause_q_index_IsEqTo_CF_Q_FREE, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_IsSender_Asserts_q_index_IsEqTo_CF_Q_FREE"); - UtTest_Add(Test_CF_CFDP_IsSender_Returns_0_MeaningRecieverWhenNeitherStateIsSet, + "Test_CF_CFDP_IsSender_AssertsBecause_q_index_IsEqTo_CF_Q_FREE"); + UtTest_Add(Test_CF_CFDP_IsSender_WhenNeitherStateIsSetReturn_0_MeaningReciever, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_IsSender_Returns_0_MeaningRecieverWhenNeitherStateIsSet"); - UtTest_Add(Test_CF_CFDP_IsSender_Returns_1_MeaningSenderWhenStateIs_CFDP_S1, + "Test_CF_CFDP_IsSender_WhenNeitherStateIsSetReturn_0_MeaningReciever"); + UtTest_Add(Test_CF_CFDP_IsSender_WhenStateIs_CFDP_S1_Return_1_MeaningSender, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_IsSender_Returns_1_MeaningSenderWhenStateIs_CFDP_S1"); - UtTest_Add(Test_CF_CFDP_IsSender_Returns_1_MeaningSenderWhenStateIs_CFDP_S2, + "Test_CF_CFDP_IsSender_WhenStateIs_CFDP_S1_Return_1_MeaningSender"); + UtTest_Add(Test_CF_CFDP_IsSender_WhenStateIs_CFDP_S2_Return_1_MeaningSender, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_IsSender_Returns_1_MeaningSenderWhenStateIs_CFDP_S2"); + "Test_CF_CFDP_IsSender_WhenStateIs_CFDP_S2_Return_1_MeaningSender"); } void add_CF_CFDP_ArmInactTimer_tests(void) { - UtTest_Add(Test_CF_CFDP_ArmInactTimer_Calls_CF_Timer_InitRelSec_WithCorrectParams, + UtTest_Add(Test_CF_CFDP_ArmInactTimer_Call_CF_Timer_InitRelSec_WithCorrectParams, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_ArmInactTimer_Calls_CF_Timer_InitRelSec_WithCorrectParams"); + "Test_CF_CFDP_ArmInactTimer_Call_CF_Timer_InitRelSec_WithCorrectParams"); } void add_CF_CFDP_DispatchRecv_tests(void) { - UtTest_Add(Test_CF_CFDP_DispatchRecv_Asserts_t_state_EqTo_CFDP_INVALID, + UtTest_Add(Test_CF_CFDP_DispatchRecv_AssertsBecause_t_state_EqTo_CFDP_INVALID, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_DispatchRecv_Asserts_t_state_EqTo_CFDP_INVALID"); - // TODO: Test_CF_CFDP_DispatchRecv_Asserts_t_state_GreaterThan_CFDP_INVALID an edge case CF_Assert - // UtTest_Add(Test_CF_CFDP_DispatchRecv_Asserts_t_state_GreaterThan_CFDP_INVALID, + "Test_CF_CFDP_DispatchRecv_AssertsBecause_t_state_EqTo_CFDP_INVALID"); + // TODO: Test_CF_CFDP_DispatchRecv_AssertsBecause_t_state_GreaterThan_CFDP_INVALID an edge case CF_Assert + // UtTest_Add(Test_CF_CFDP_DispatchRecv_AssertsBecause_t_state_GreaterThan_CFDP_INVALID, // cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - // "Test_CF_CFDP_DispatchRecv_Asserts_t_state_GreaterThan_CFDP_INVALID"); + // "Test_CF_CFDP_DispatchRecv_AssertsBecause_t_state_GreaterThan_CFDP_INVALID"); // TODO: tests commented out because they are not necessary for coverage and are not yet implemented correctly // UtTest_Add(Test_CF_CFDP_DispatchRecv_Calls_CF_CFDP_RecvIdle_BecauseStateEq_CFDP_IDLE, // cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, @@ -8649,50 +8793,50 @@ void add_CF_CFDP_DispatchRecv_tests(void) // UtTest_Add(Test_CF_CFDP_DispatchRecv_Calls_CF_CFDP_S2_Recv_BecauseStateEq_CFDP_S2, // cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, // "Test_CF_CFDP_DispatchRecv_Calls_CF_CFDP_S2_Recv_BecauseStateEq_CFDP_S2"); - UtTest_Add(Test_CF_CFDP_DispatchRecv_Calls_CF_CFDP_RecvDrop_BecauseStateEq_CFDP_DROP, + UtTest_Add(Test_CF_CFDP_DispatchRecv_WhenStateEq_CFDP_DROP_Call_CF_CFDP_RecvDrop, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_DispatchRecv_Calls_CF_CFDP_RecvDrop_BecauseStateEq_CFDP_DROP"); + "Test_CF_CFDP_DispatchRecv_WhenStateEq_CFDP_DROP_Call_CF_CFDP_RecvDrop"); } void add_CF_CFDP_DispatchTx_tests(void) { - UtTest_Add(Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_INVALID, + UtTest_Add(Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_INVALID, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_INVALID"); - // UtTest_Add(Test_CF_CFDP_DispatchTx_Asserts_t_state_GreaterThanOrEqTo_CFDP_INVALID, + "Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_INVALID"); + // UtTest_Add(Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_GreaterThanOrEqTo_CFDP_INVALID, // cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - // "Test_CF_CFDP_DispatchTx_Asserts_t_state_GreaterThanOrEqTo_CFDP_INVALID"); - UtTest_Add(Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_IDLE, + // "Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_GreaterThanOrEqTo_CFDP_INVALID"); + UtTest_Add(Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_IDLE, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_IDLE"); - // UtTest_Add(Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_R1, + "Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_IDLE"); + // UtTest_Add(Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_R1, // cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - // "Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_R1"); - // UtTest_Add(Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_R2, + // "Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_R1"); + // UtTest_Add(Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_R2, // cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - // "Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_R2"); - // UtTest_Add(Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_DROP, + // "Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_R2"); + // UtTest_Add(Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_DROP, // cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - // "Test_CF_CFDP_DispatchTx_Asserts_t_state_EqTo_CFDP_DROP"); - UtTest_Add(Test_CF_CFDP_DispatchTx_Calls_CF_CFDP_S1_Tx_Because_t_state_EqTo_CFDP_S1, + // "Test_CF_CFDP_DispatchTx_AssertsBecause_t_state_EqTo_CFDP_DROP"); + UtTest_Add(Test_CF_CFDP_DispatchTx_When_t_state_EqTo_CFDP_S1_Call_CF_CFDP_S1_Tx, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_DispatchTx_Calls_CF_CFDP_S1_Tx_Because_t_state_EqTo_CFDP_S1"); - UtTest_Add(Test_CF_CFDP_DispatchTx_Calls_CF_CFDP_S1_Tx_Because_t_state_EqTo_CFDP_S2, + "Test_CF_CFDP_DispatchTx_When_t_state_EqTo_CFDP_S1_Call_CF_CFDP_S1_Tx"); + UtTest_Add(Test_CF_CFDP_DispatchTx_Call_When_t_state_EqTo_CFDP_S2_CF_CFDP_S1_Tx, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_DispatchTx_Calls_CF_CFDP_S1_Tx_Because_t_state_EqTo_CFDP_S2"); + "Test_CF_CFDP_DispatchTx_Call_When_t_state_EqTo_CFDP_S2_CF_CFDP_S1_Tx"); } void add_CF_CFDP_FindUnusedChunks_tests(void) { - UtTest_Add(Test_CF_CFDP_FindUnusedChunks_Asserts_dir_IsEq_CF_DIR_NUM, + UtTest_Add(Test_CF_CFDP_FindUnusedChunks_AssertsBecause_dir_IsEq_CF_DIR_NUM, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindUnusedChunks_Asserts_dir_IsEq_CF_DIR_NUM"); - // UtTest_Add(Test_CF_CFDP_FindUnusedChunks_Asserts_dir_IsGreaterThan_CF_DIR_NUM, + "Test_CF_CFDP_FindUnusedChunks_AssertsBecause_dir_IsEq_CF_DIR_NUM"); + // UtTest_Add(Test_CF_CFDP_FindUnusedChunks_AssertsBecause_dir_IsGreaterThan_CF_DIR_NUM, // cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - // "Test_CF_CFDP_FindUnusedChunks_Asserts_dir_IsGreaterThan_CF_DIR_NUM"); - UtTest_Add(Test_CF_CFDP_FindUnusedChunks_Asserts_c_cs_dir_IsNull, + // "Test_CF_CFDP_FindUnusedChunks_AssertsBecause_dir_IsGreaterThan_CF_DIR_NUM"); + UtTest_Add(Test_CF_CFDP_FindUnusedChunks_AssertsBecause_c_cs_dir_IsNull, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindUnusedChunks_Asserts_c_cs_dir_IsNull"); + "Test_CF_CFDP_FindUnusedChunks_AssertsBecause_c_cs_dir_IsNull"); UtTest_Add(Test_CF_CFDP_FindUnusedChunks_Success, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, "Test_CF_CFDP_FindUnusedChunks_Success"); @@ -8700,62 +8844,61 @@ void add_CF_CFDP_FindUnusedChunks_tests(void) void add_CF_CFDP_FindUnusedTransaction_tests(void) { - UtTest_Add(Test_CF_CFDP_FindUnusedTransaction_Asserts_c_IsNull, + UtTest_Add(Test_CF_CFDP_FindUnusedTransaction_AssertsBecause_c_IsNull, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindUnusedTransaction_Asserts_c_IsNull"); - UtTest_Add(Test_CF_CFDP_FindUnusedTransaction_Asserts_q_size_CF_Q_HIST_IsNotLessThan_CF_NUM_HISTORIES_PER_CHANNEL, + "Test_CF_CFDP_FindUnusedTransaction_AssertsBecause_c_IsNull"); + UtTest_Add(Test_CF_CFDP_FindUnusedTransaction_AssertsBecause_q_size_CF_Q_HIST_IsNotLessThan_CF_NUM_HISTORIES_PER_CHANNEL, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindUnusedTransaction_Asserts_q_size_CF_Q_HIST_IsNotLessThan_CF_NUM_HISTORIES_PER_CHANNEL"); - UtTest_Add(Test_CF_CFDP_FindUnusedTransaction_Asserts_c_qs_CF_Q_HIST_IsNull, + "Test_CF_CFDP_FindUnusedTransaction_AssertsBecause_q_size_CF_Q_HIST_IsNotLessThan_CF_NUM_HISTORIES_PER_CHANNEL"); + UtTest_Add(Test_CF_CFDP_FindUnusedTransaction_AssertsBecause_c_qs_CF_Q_HIST_IsNull, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindUnusedTransaction_Asserts_c_qs_CF_Q_HIST_IsNull"); - UtTest_Add(Test_CF_CFDP_FindUnusedTransaction_ReturnsNullBecauseNoFreeTransactionsAreAvailable, + "Test_CF_CFDP_FindUnusedTransaction_AssertsBecause_c_qs_CF_Q_HIST_IsNull"); + UtTest_Add(Test_CF_CFDP_FindUnusedTransaction_WhenNoFreeTransactionsAreAvailableReturn_NULL, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindUnusedTransaction_ReturnsNullBecauseNoFreeTransactionsAreAvailable"); - UtTest_Add(Test_CF_CFDP_FindUnusedTransaction_ReturnsExpected_t_WhenNoFreeHistory, + "Test_CF_CFDP_FindUnusedTransaction_WhenNoFreeTransactionsAreAvailableReturn_NULL"); + UtTest_Add(Test_CF_CFDP_FindUnusedTransaction_WhenNoFreeHistoryReturnExpected_t, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindUnusedTransaction_ReturnsExpected_t_WhenNoFreeHistory"); - UtTest_Add(Test_CF_CFDP_FindUnusedTransaction_ReturnsExpected_t_WhenFreeHistory, + "Test_CF_CFDP_FindUnusedTransaction_WhenNoFreeHistoryReturnExpected_t"); + UtTest_Add(Test_CF_CFDP_FindUnusedTransaction_WhenFreeHistoryReturnExpected_t, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindUnusedTransaction_ReturnsExpected_t_WhenFreeHistory"); + "Test_CF_CFDP_FindUnusedTransaction_WhenFreeHistoryReturnExpected_t"); } void add_CF_CFDP_ResetHistory_tests(void) { - UtTest_Add(Test_CF_CFDP_ResetHistory_Calls_CF_CList_Remove_Ex_And_CF_CList_InsertBack_Ex_WithCorrectParams, + UtTest_Add(Test_CF_CFDP_ResetHistory_Call_CF_CList_Remove_Ex_And_CF_CList_InsertBack_Ex_WithCorrectParams, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_ResetHistory_Calls_CF_CList_Remove_Ex_And_CF_CList_InsertBack_Ex_WithCorrectParams"); - + "Test_CF_CFDP_ResetHistory_Call_CF_CList_Remove_Ex_And_CF_CList_InsertBack_Ex_WithCorrectParams"); } void add_CF_CFDP_FreeTransaction_tests(void) { - UtTest_Add(Test_CF_CFDP_FreeTransaction_Calls_CF_CList_InitNode_And_CF_CList_InsertBack_Ex_WithCorrectParams, + UtTest_Add(Test_CF_CFDP_FreeTransaction_Call_CF_CList_InitNode_And_CF_CList_InsertBack_Ex_WithCorrectParams, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FreeTransaction_Calls_CF_CList_InitNode_And_CF_CList_InsertBack_Ex_WithCorrectParams"); + "Test_CF_CFDP_FreeTransaction_Call_CF_CList_InitNode_And_CF_CList_InsertBack_Ex_WithCorrectParams"); } void add_CF_CFDP_FindTransactionBySequenceNumber__tests(void) { - UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumber__DoesNotFindTransaction_context_src_eid_NotEq_history_src_eid, + UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumber__When_context_src_eid_NotEq_history_src_eid_DoNotFindTransaction, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindTransactionBySequenceNumber__DoesNotFindTransaction_context_src_eid_NotEq_history_src_eid"); - UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumber__DoesNotFindTransaction_context_transaction_sequence_number_NotEq_history_seq_num, + "Test_CF_CFDP_FindTransactionBySequenceNumber__When_context_src_eid_NotEq_history_src_eid_DoNotFindTransaction"); + UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumber__When_context_transaction_sequence_number_NotEq_history_seq_num_DoNotFindTransaction, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindTransactionBySequenceNumber__DoesNotFindTransaction_context_transaction_sequence_number_NotEq_history_seq_num"); - UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumber__FindsTransaction_history_And_context_Match_src_eid_And_seq_num, + "Test_CF_CFDP_FindTransactionBySequenceNumber__When_context_transaction_sequence_number_NotEq_history_seq_num_DoNotFindTransaction"); + UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumber__When_history_And_context_Match_src_eid_And_seq_num_FindTransaction, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindTransactionBySequenceNumber__FindsTransaction_history_And_context_Match_src_eid_And_seq_num"); + "Test_CF_CFDP_FindTransactionBySequenceNumber__When_history_And_context_Match_src_eid_And_seq_num_FindTransaction"); } void add_CF_CFDP_FindTransactionBySequenceNumber_tests(void) { - UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumber_DoesNotFindTransaction, + UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumber_DoNotFindTransaction, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindTransactionBySequenceNumber_DoesNotFindTransaction"); - UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumber_FindsTransactionOnLastClist, + "Test_CF_CFDP_FindTransactionBySequenceNumber_DoNotFindTransaction"); + UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumber_FindTransactionOnLastClist, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FindTransactionBySequenceNumber_FindsTransactionOnLastClist"); + "Test_CF_CFDP_FindTransactionBySequenceNumber_FindTransactionOnLastClist"); } void add_CF_CFDP_MsgOutGet_tests(void) @@ -8791,22 +8934,22 @@ void add_CF_CFDP_MsgOutGet_tests(void) void add_CF_CFDP_Send_tests(void) { - UtTest_Add(Test_CF_CFDP_Send_Asserts_chan_num_IsEqTo_CF_NUM_CHANNELS, + UtTest_Add(Test_CF_CFDP_Send_AssertsBecause_chan_num_IsEqTo_CF_NUM_CHANNELS, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_Send_Asserts_chan_num_IsEqTo_CF_NUM_CHANNELS"); - // UtTest_Add(Test_CF_CFDP_Send_Asserts_chan_num_IsGreaterThanTo_CF_NUM_CHANNELS, + "Test_CF_CFDP_Send_AssertsBecause_chan_num_IsEqTo_CF_NUM_CHANNELS"); + // UtTest_Add(Test_CF_CFDP_Send_AssertsBecause_chan_num_IsGreaterThanTo_CF_NUM_CHANNELS, // cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - // "Test_CF_CFDP_Send_Asserts_chan_num_IsGreaterThanTo_CF_NUM_CHANNELS"); - UtTest_Add(Test_CF_CFDP_Send_InitializesMsgTimestampsItAndSendsIt, + // "Test_CF_CFDP_Send_AssertsBecause_chan_num_IsGreaterThanTo_CF_NUM_CHANNELS"); + UtTest_Add(Test_CF_CFDP_Send_InitializeMsgTimestampsItAndSendsIt, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_Send_InitializesMsgTimestampsItAndSendsIt"); + "Test_CF_CFDP_Send_InitializeMsgTimestampsItAndSendsIt"); } void add_CF_CFDP_SetPduLength_tests(void) { - UtTest_Add(Test_CF_CFDP_SetPduLength_SetsGiven_ph_length_ToGiven_length, + UtTest_Add(Test_CF_CFDP_SetPduLength_SetGiven_ph_length_ToGiven_length, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SetPduLength_SetsGiven_ph_length_ToGiven_length"); + "Test_CF_CFDP_SetPduLength_SetGiven_ph_length_ToGiven_length"); } void add_CF_CFDP_ConstructPduHeader_tests(void) @@ -8824,61 +8967,61 @@ void add_CF_CFDP_ConstructPduHeader_tests(void) void add_CF_strnlen_tests(void) { - UtTest_Add(Test_CF_strnlen_When_end_IsNot_NULL_ReturnsLengthOfGiven_s, + UtTest_Add(Test_CF_strnlen_When_end_IsNot_NULL_ReturnLengthOfGiven_s, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_strnlen_When_end_IsNot_NULL_ReturnsLengthOfGiven_s"); - UtTest_Add(Test_CF_strnlen_When_end_Is_NULL_ReturnsLengthOfGiven_s, + "Test_CF_strnlen_When_end_IsNot_NULL_ReturnLengthOfGiven_s"); + UtTest_Add(Test_CF_strnlen_When_end_Is_NULL_ReturnLengthOfGiven_s, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_strnlen_When_end_Is_NULL_ReturnsLengthOfGiven_s"); + "Test_CF_strnlen_When_end_Is_NULL_ReturnLengthOfGiven_s"); } void add_CF_CFDP_SendMd_tests(void) { - UtTest_Add(Test_CF_CFDP_SendMd_GetsNull_pdu_header_Returns_CF_SEND_NO_MSG, + UtTest_Add(Test_CF_CFDP_SendMd_GetNull_pdu_header_Return_CF_SEND_NO_MSG, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendMd_GetsNull_pdu_header_Returns_CF_SEND_NO_MSG"); - UtTest_Add(Test_CF_CFDP_SendMd_Asserts_state_NotEq_CFDP_S1_Or_CFDP_S2, + "Test_CF_CFDP_SendMd_GetNull_pdu_header_Return_CF_SEND_NO_MSG"); + UtTest_Add(Test_CF_CFDP_SendMd_AssertsBecause_state_NotEq_CFDP_S1_Or_CFDP_S2, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendMd_Asserts_state_NotEq_CFDP_S1_Or_CFDP_S2"); - UtTest_Add(Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_src_len_Eq_sizeof_src_filename, + "Test_CF_CFDP_SendMd_AssertsBecause_state_NotEq_CFDP_S1_Or_CFDP_S2"); + UtTest_Add(Test_CF_CFDP_SendMd_When_src_len_Eq_sizeof_src_filename_Return_CF_SEND_FAILURE, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_src_len_Eq_sizeof_src_filename"); - UtTest_Add(Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_dst_len_Eq_sizeof_dst_filename, + "Test_CF_CFDP_SendMd_When_src_len_Eq_sizeof_src_filename_Return_CF_SEND_FAILURE"); + UtTest_Add(Test_CF_CFDP_SendMd_When_dst_len_Eq_sizeof_dst_filename_Return_CF_SEND_FAILURE, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendMd_Returns_CF_SEND_FAILURE_dst_len_Eq_sizeof_dst_filename"); + "Test_CF_CFDP_SendMd_When_dst_len_Eq_sizeof_dst_filename_Return_CF_SEND_FAILURE"); UtTest_Add(Test_CF_CFDP_SendMd_Returns_CF_SEND_ERROR_CF_CFDP_CopyDataToLv_Returns_neg1_On_src_Call, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, "Test_CF_CFDP_SendMd_Returns_CF_SEND_ERROR_CF_CFDP_CopyDataToLv_Returns_neg1_On_src_Call"); - UtTest_Add(Test_CF_CFDP_SendMd_Returns_CF_SEND_ERROR_CF_CFDP_CopyDataToLv_Returns_neg1_On_dst_Call, + UtTest_Add(Test_CF_CFDP_SendMd_WhenCallTo_CF_CFDP_CopyDataToLv_Returns_neg1_OnThe_dst_Call_Return_CF_SEND_ERROR, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendMd_Returns_CF_SEND_ERROR_CF_CFDP_CopyDataToLv_Returns_neg1_On_dst_Call"); - UtTest_Add(Test_CF_CFDP_SendMd_SuccessReturns_CF_SEND_SUCCESS, + "Test_CF_CFDP_SendMd_WhenCallTo_CF_CFDP_CopyDataToLv_Returns_neg1_OnThe_dst_Call_Return_CF_SEND_ERROR"); + UtTest_Add(Test_CF_CFDP_SendMd_Return_CF_SEND_SUCCESS, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendMd_SuccessReturns_CF_SEND_SUCCESS"); + "Test_CF_CFDP_SendMd_Return_CF_SEND_SUCCESS"); } void add_CF_CFDP_SendFd_tests(void) { - UtTest_Add(Test_CF_CFDP_SendFd_Returns_CF_SEND_ERROR_Because_len_GreaterThan_sizeof_pdu_pd_data_t, + UtTest_Add(Test_CF_CFDP_SendFd_When_len_GreaterThan_sizeof_pdu_pd_data_t_Return_CF_SEND_ERROR, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendFd_Returns_CF_SEND_ERROR_Because_len_GreaterThan_sizeof_pdu_pd_data_t"); - UtTest_Add(Test_CF_CFDP_SendFd_SuccessReturns_CF_SEND_SUCCESS, + "Test_CF_CFDP_SendFd_When_len_GreaterThan_sizeof_pdu_pd_data_t_Return_CF_SEND_ERROR"); + UtTest_Add(Test_CF_CFDP_SendFd_Return_CF_SEND_SUCCESS, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendFd_SuccessReturns_CF_SEND_SUCCESS"); + "Test_CF_CFDP_SendFd_Return_CF_SEND_SUCCESS"); } void add_CF_CFDP_FinishEofAck_tests(void) { - UtTest_Add(Test_CF_CFDP_FinishEofAck_SetsExpectedValues, + UtTest_Add(Test_CF_CFDP_FinishEofAck_SetExpectedValues, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_FinishEofAck_SetsExpectedValues"); + "Test_CF_CFDP_FinishEofAck_SetExpectedValues"); } void add_CF_CFDP_SendEof_tests(void) { - UtTest_Add(Test_CF_CFDP_SendEof_GetsNull_pdu_Return_CF_SEND_NO_MSG, + UtTest_Add(Test_CF_CFDP_SendEof_Get_NULL_pdu_Return_CF_SEND_NO_MSG, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendEof_GetsNull_pdu_Return_CF_SEND_NO_MSG"); + "Test_CF_CFDP_SendEof_Get_NULL_pdu_Return_CF_SEND_NO_MSG"); UtTest_Add(Test_CF_CFDP_SendEof_SuccessWithNoError, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, "Test_CF_CFDP_SendEof_SuccessWithNoError"); @@ -8889,41 +9032,41 @@ void add_CF_CFDP_SendEof_tests(void) void add_CF_CFDP_SendAck_tests(void) { - UtTest_Add(Test_CF_CFDP_SendAck_When_CF_CFDP_IsSender_Returns_false_GetsNull_ph_Returns_CF_SEND_NO_MSG, + UtTest_Add(Test_CF_CFDP_SendAck_When_CF_CFDP_IsSender_Returns_false_Get_NULL_ph_Return_CF_SEND_NO_MSG, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendAck_When_CF_CFDP_IsSender_Returns_false_GetsNull_ph_Returns_CF_SEND_NO_MSG"); - UtTest_Add(Test_CF_CFDP_SendAck_Asserts_WhenGiven_dir_code_Is_Not_PDU_EOF_Or_PDU_FIN, + "Test_CF_CFDP_SendAck_When_CF_CFDP_IsSender_Returns_false_Get_NULL_ph_Return_CF_SEND_NO_MSG"); + UtTest_Add(Test_CF_CFDP_SendAck_AssertsBecauseGiven_dir_code_Is_Not_PDU_EOF_Or_PDU_FIN, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendAck_Asserts_WhenGiven_dir_code_Is_Not_PDU_EOF_Or_PDU_FIN"); - UtTest_Add(Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_EOF_And_CF_CFDP_IsSender_Returns_true_GetsMsg_pdu_Returns_CF_SEND_NO_MSG, + "Test_CF_CFDP_SendAck_AssertsBecauseGiven_dir_code_Is_Not_PDU_EOF_Or_PDU_FIN"); + UtTest_Add(Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_EOF_And_CF_CFDP_IsSender_Returns_true_GetMsg_pdu_Return_CF_SEND_NO_MSG, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_EOF_And_CF_CFDP_IsSender_Returns_true_GetsMsg_pdu_Returns_CF_SEND_NO_MSG"); - UtTest_Add(Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_FIN_And_CF_CFDP_IsSender_Returns_true_GetsMsg_ph_Return_CF_SEND_SUCCESS, + "Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_EOF_And_CF_CFDP_IsSender_Returns_true_GetMsg_pdu_Return_CF_SEND_NO_MSG"); + UtTest_Add(Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_FIN_And_CF_CFDP_IsSender_Returns_true_GetMsg_ph_Return_CF_SEND_SUCCESS, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_FIN_And_CF_CFDP_IsSender_Returns_true_GetsMsg_ph_Return_CF_SEND_SUCCESS"); + "Test_CF_CFDP_SendAck_WhenGiven_dir_code_Is_PDU_FIN_And_CF_CFDP_IsSender_Returns_true_GetMsg_ph_Return_CF_SEND_SUCCESS"); } void add_CF_CFDP_SendFin_tests(void) { - UtTest_Add(Test_CF_CFDP_SendFin_GetsNull_ph_Return_CF_SEND_NO_MSG, + UtTest_Add(Test_CF_CFDP_SendFin_Get_NULL_ph_Return_CF_SEND_NO_MSG, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendFin_GetsNull_ph_Return_CF_SEND_NO_MSG"); - UtTest_Add(Test_CF_CFDP_SendFin_Given_cc_NotEqTo_CC_NO_ERROR_GetsNull_ph_Return_CF_SEND_SUCCESS, + "Test_CF_CFDP_SendFin_Get_NULL_ph_Return_CF_SEND_NO_MSG"); + UtTest_Add(Test_CF_CFDP_SendFin_Given_cc_NotEqTo_CC_NO_ERROR_GetNull_ph_Return_CF_SEND_SUCCESS, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendFin_Given_cc_NotEqTo_CC_NO_ERROR_GetsNull_ph_Return_CF_SEND_SUCCESS"); - UtTest_Add(Test_CF_CFDP_SendFin_Given_cc_EqTo_CC_NO_ERROR_GetsNull_ph_Return_CF_SEND_SUCCESS, + "Test_CF_CFDP_SendFin_Given_cc_NotEqTo_CC_NO_ERROR_GetNull_ph_Return_CF_SEND_SUCCESS"); + UtTest_Add(Test_CF_CFDP_SendFin_Given_cc_EqTo_CC_NO_ERROR_GetNull_ph_Return_CF_SEND_SUCCESS, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendFin_Given_cc_EqTo_CC_NO_ERROR_GetsNull_ph_Return_CF_SEND_SUCCESS"); + "Test_CF_CFDP_SendFin_Given_cc_EqTo_CC_NO_ERROR_GetNull_ph_Return_CF_SEND_SUCCESS"); } void add_CF_CFDP_SendNak_tests(void) { - UtTest_Add(Test_CF_CFDP_SendNak_GetsNull_ph_Return_CF_SEND_NO_MSG, + UtTest_Add(Test_CF_CFDP_SendNak_GetNull_ph_Return_CF_SEND_NO_MSG, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendNak_GetsNull_ph_Return_CF_SEND_NO_MSG"); - UtTest_Add(Test_CF_CFDP_SendNak_Asserts_CF_CFDP_GetClass_With_t_Eq_CLASS_2, + "Test_CF_CFDP_SendNak_GetNull_ph_Return_CF_SEND_NO_MSG"); + UtTest_Add(Test_CF_CFDP_SendNak_AssertsBecause_CF_CFDP_GetClass_With_t_Eq_CLASS_2, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_SendNak_Asserts_CF_CFDP_GetClass_With_t_Eq_CLASS_2"); + "Test_CF_CFDP_SendNak_AssertsBecause_CF_CFDP_GetClass_With_t_Eq_CLASS_2"); UtTest_Add(Test_CF_CFDP_SendNak_Success_Return_CF_SEND_SUCCESS, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, "Test_CF_CFDP_SendNak_Success_Return_CF_SEND_SUCCESS"); @@ -8931,12 +9074,12 @@ void add_CF_CFDP_SendNak_tests(void) void add_CF_CF_CFDP_RecvPh_tests(void) { - UtTest_Add(Test_CF_CFDP_RecvPh_Asserts_chan_num_GreaterThan_CF_NUM_CHANNELS, + UtTest_Add(Test_CF_CFDP_RecvPh_AssertsBecause_chan_num_GreaterThan_CF_NUM_CHANNELS, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvPh_Asserts_chan_num_GreaterThan_CF_NUM_CHANNELS"); - UtTest_Add(Test_CF_CFDP_RecvPh_Asserts_msg_in_Is_NULL, + "Test_CF_CFDP_RecvPh_AssertsBecause_chan_num_GreaterThan_CF_NUM_CHANNELS"); + UtTest_Add(Test_CF_CFDP_RecvPh_AssertsBecause_msg_in_Is_NULL, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvPh_Asserts_msg_in_Is_NULL"); + "Test_CF_CFDP_RecvPh_AssertsBecause_msg_in_Is_NULL"); UtTest_Add(Test_CF_CFDP_RecvPh_NumberOf_bytes_recieved_IsLessThan_hsize_SendEventCountErrorReturn_neg1, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, "Test_CF_CFDP_RecvPh_NumberOf_bytes_recieved_IsLessThan_hsize_SendEventCountErrorReturn_neg1"); @@ -8956,21 +9099,21 @@ void add_CF_CF_CFDP_RecvPh_tests(void) void add_CF_CFDP_RecvMd_tests(void) { - UtTest_Add(Test_CF_CFDP_RecvMd_Asserts_CF_AppData_engine_msg_in_Is_NULL, + UtTest_Add(Test_CF_CFDP_RecvMd_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvMd_Asserts_CF_AppData_engine_msg_in_Is_NULL"); - UtTest_Add(Test_CF_CFDP_RecvMd_Has_bytes_received_LessThan_sizof_ph_Plus_size_of_pdu_md_t_CountsErrorReturns_neg1, + "Test_CF_CFDP_RecvMd_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL"); + UtTest_Add(Test_CF_CFDP_RecvMd_Has_bytes_received_LessThan_sizof_ph_Plus_size_of_pdu_md_t_CountErrorReturn_neg1, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvMd_Has_bytes_received_LessThan_sizof_ph_Plus_size_of_pdu_md_t_CountsErrorReturns_neg1"); - UtTest_Add(Test_CF_CFDP_RecvMd_HasFirst_lv_ret_LessThan_0_SendsEventCountsErrorAndReturns_neg1, + "Test_CF_CFDP_RecvMd_Has_bytes_received_LessThan_sizof_ph_Plus_size_of_pdu_md_t_CountErrorReturn_neg1"); + UtTest_Add(Test_CF_CFDP_RecvMd_HasFirst_lv_ret_LessThan_0_SendsEventCountErrorAndReturn_neg1, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvMd_HasFirst_lv_ret_LessThan_0_SendsEventCountsErrorAndReturns_neg1"); - UtTest_Add(Test_CF_CFDP_RecvMd_HasSecond_lv_ret_LessThan_0_BecauseLengthEqSizeSendsEventAndReturns_neg1, + "Test_CF_CFDP_RecvMd_HasFirst_lv_ret_LessThan_0_SendsEventCountErrorAndReturn_neg1"); + UtTest_Add(Test_CF_CFDP_RecvMd_HasSecond_lv_ret_LessThan_0_BecauseLengthEqSizeSendEventAndReturn_neg1, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvMd_HasSecond_lv_ret_LessThan_0_BecauseLengthEqSizeSendsEventAndReturns_neg1"); - UtTest_Add(Test_CF_CFDP_RecvMd_SendsEventAndReturns_0_WhenNoErrorConditions, + "Test_CF_CFDP_RecvMd_HasSecond_lv_ret_LessThan_0_BecauseLengthEqSizeSendEventAndReturn_neg1"); + UtTest_Add(Test_CF_CFDP_RecvMd_WhenNoErrorConditions_SendEventAndReturn_0, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvMd_SendsEventAndReturns_0_WhenNoErrorConditions"); + "Test_CF_CFDP_RecvMd_WhenNoErrorConditions_SendEventAndReturn_0"); } void add_CF_CFDP_RecvFd_tests(void) @@ -8978,15 +9121,15 @@ void add_CF_CFDP_RecvFd_tests(void) UtTest_Add(Test_CF_CFDP_RecvFd_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, "Test_CF_CFDP_RecvFd_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL"); - UtTest_Add(Test_CF_CFDP_RecvFd_FailsAndSendsEventBecause_bytes_received_LessThan_sizeof_pdu_file_data_header_t_CountsErrorAndReturns_neg1, + UtTest_Add(Test_CF_CFDP_RecvFd_When_bytes_received_LessThan_sizeof_pdu_file_data_header_t_CountsErrorAndReturns_neg1_FailAndSendsEvent, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvFd_FailsAndSendsEventBecause_bytes_received_LessThan_sizeof_pdu_file_data_header_t_CountsErrorAndReturns_neg1"); - UtTest_Add(Test_CF_CFDP_RecvFd_Success_bytes_received_EqTo_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset, + "Test_CF_CFDP_RecvFd_When_bytes_received_LessThan_sizeof_pdu_file_data_header_t_CountsErrorAndReturns_neg1_FailAndSendsEvent"); + UtTest_Add(Test_CF_CFDP_RecvFd_When_bytes_received_EqTo_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset_Success, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvFd_Success_bytes_received_EqTo_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset"); - UtTest_Add(Test_CF_CFDP_RecvFd_Success_bytes_received_GreaterThan_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset, + "Test_CF_CFDP_RecvFd_When_bytes_received_EqTo_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset_Success"); + UtTest_Add(Test_CF_CFDP_RecvFd_When_bytes_received_GreaterThan_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset_Success, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvFd_Success_bytes_received_GreaterThan_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset"); + "Test_CF_CFDP_RecvFd_When_bytes_received_GreaterThan_sizeof_pdu_file_data_header_t_ByteSwaps_fd_fdh_offset_Success"); } void add_CF_CFDP_RecvEof_tests(void) @@ -8994,15 +9137,15 @@ void add_CF_CFDP_RecvEof_tests(void) UtTest_Add(Test_CF_CFDP_RecvEof_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, "Test_CF_CFDP_RecvEof_AssertsBecause_CF_AppData_engine_msg_in_Is_NULL"); - UtTest_Add(Test_CF_CFDP_RecvEof_Fails_bytes_received_LessThan_offsetof_pdu_eof_t_fault_location_Returns_neg1, + UtTest_Add(Test_CF_CFDP_RecvEof_When_bytes_received_LessThan_offsetof_pdu_eof_t_fault_location_Returns_neg1_Fail, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvEof_Fails_bytes_received_LessThan_offsetof_pdu_eof_t_fault_location_Returns_neg1"); - UtTest_Add(Test_CF_CFDP_RecvEof_BytesReceivedEq_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Returns_0, + "Test_CF_CFDP_RecvEof_When_bytes_received_LessThan_offsetof_pdu_eof_t_fault_location_Returns_neg1_Fail"); + UtTest_Add(Test_CF_CFDP_RecvEof_BytesReceivedEq_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Return_0, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvEof_BytesReceivedEq_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Returns_0"); - UtTest_Add(Test_CF_CFDP_RecvEof_BytesReceivedGreaterThan_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Returns_0, + "Test_CF_CFDP_RecvEof_BytesReceivedEq_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Return_0"); + UtTest_Add(Test_CF_CFDP_RecvEof_BytesReceivedGreaterThan_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Return_0, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_CF_CFDP_RecvEof_BytesReceivedGreaterThan_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Returns_0"); + "Test_CF_CFDP_RecvEof_BytesReceivedGreaterThan_offsetof_fault_location_Calls_cfdp_get_uint32_With_eof_crc_And_eof_size_Return_0"); } void add_CF_CFDP_RecvAck_tests(void) @@ -9136,6 +9279,9 @@ void add_CF_CFDP_ReceiveMessage_tests(void) UtTest_Add(Test_CF_CFDP_ReceiveMessage_CallTo_CF_CFDP_FindTransactionBySequenceNumber_Returns_nonNULL_Call_CF_CFDP_DispatchRecv_ThenSet_CF_AppData_engine_in_msg_To_NULL, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, "Test_CF_CFDP_ReceiveMessage_CallTo_CF_CFDP_FindTransactionBySequenceNumber_Returns_nonNULL_Call_CF_CFDP_DispatchRecv_ThenSet_CF_AppData_engine_in_msg_To_NULL"); + UtTest_Add(Test_CF_CFDP_ReceiveMessage_AssertsBecause_t_state_IsGreaterThan_CFDP_IDLE, + cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, + "Test_CF_CFDP_ReceiveMessage_AssertsBecause_t_state_IsGreaterThan_CFDP_IDLE"); UtTest_Add(Test_CF_CFDP_ReceiveMessage_CallTo_src_And_dst_AreNot_config_table_local_eid_SendEvenThenSet_CF_AppData_engine_in_msg_To_NULL, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, "Test_CF_CFDP_ReceiveMessage_CallTo_src_And_dst_AreNot_config_table_local_eid_SendEvenThenSet_CF_AppData_engine_in_msg_To_NULL"); @@ -9160,9 +9306,12 @@ void add_CF_CFDP_ReceiveMessage_tests(void) UtTest_Add(Test_CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_But_dst_IsEqTo_config_table_local_eid_And_q_size_CF_Q_RX_IsNotEqTo_CF_MAX_SIMULTANEOUS_RX_SendEventThenIncrement_counters_recv_dropped_AndSet_CF_AppData_engine_in_msg_To_NULL, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, "Test_CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_But_dst_IsEqTo_config_table_local_eid_And_q_size_CF_Q_RX_IsNotEqTo_CF_MAX_SIMULTANEOUS_RX_SendEventThenIncrement_counters_recv_dropped_AndSet_CF_AppData_engine_in_msg_To_NULL"); - UtTest_Add(Test_2CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_But_dst_IsEqTo_config_table_local_eid_And_q_size_CF_Q_RX_IsNotEqTo_CF_MAX_SIMULTANEOUS_RX_SendEventThenIncrement_counters_recv_dropped_AndSet_CF_AppData_engine_in_msg_To_NULL, + UtTest_Add(Test_CF_CFDP_ReceiveMessage_AssertsBecause_t_Is_NULL, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, - "Test_2CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_But_dst_IsEqTo_config_table_local_eid_And_q_size_CF_Q_RX_IsNotEqTo_CF_MAX_SIMULTANEOUS_RX_SendEventThenIncrement_counters_recv_dropped_AndSet_CF_AppData_engine_in_msg_To_NULL"); + "Test_CF_CFDP_ReceiveMessage_AssertsBecause_t_Is_NULL"); + // UtTest_Add(Test_2CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_But_dst_IsEqTo_config_table_local_eid_And_q_size_CF_Q_RX_IsNotEqTo_CF_MAX_SIMULTANEOUS_RX_SendEventThenIncrement_counters_recv_dropped_AndSet_CF_AppData_engine_in_msg_To_NULL, + // cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, + // "Test_2CF_CFDP_ReceiveMessage_CallTo_src_IsNotEqTo_config_table_local_eid_But_dst_IsEqTo_config_table_local_eid_And_q_size_CF_Q_RX_IsNotEqTo_CF_MAX_SIMULTANEOUS_RX_SendEventThenIncrement_counters_recv_dropped_AndSet_CF_AppData_engine_in_msg_To_NULL"); } void add_CF_CFDP_CycleTx__tests(void) @@ -9427,6 +9576,9 @@ void add_CF_CFDP_ResetTransaction_tests(void) UtTest_Add(Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t_history_dir_Is_CF_DIR_TX_And_t_flags_tx_cmd_tx_Is_1_And_keep_history_Is_non0_Call_CF_CList_InsertBack_Ex_With_CF_Q_HIST_ThenCall_CF_CList_InsertBack_And_CF_CFDP_FreeTransaction, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, "Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t_history_dir_Is_CF_DIR_TX_And_t_flags_tx_cmd_tx_Is_1_And_keep_history_Is_non0_Call_CF_CList_InsertBack_Ex_With_CF_Q_HIST_ThenCall_CF_CList_InsertBack_And_CF_CFDP_FreeTransaction"); + UtTest_Add(Test_CF_CFDP_ResetTransaction_AssertsBecause_t_p_num_ts_Is_0, + cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, + "Test_CF_CFDP_ResetTransaction_AssertsBecause_t_p_num_ts_Is_0"); UtTest_Add(Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t_history_dir_Is_CF_DIR_TX_And_t_p_Is_nonNULL_And_keep_history_Is_non0_Call_CF_CList_InsertBack_Ex_With_CF_Q_HIST_ThenCall_CF_CList_InsertBack_And_CF_CFDP_FreeTransaction, cf_cfdp_tests_Setup, cf_cfdp_tests_Teardown, "Test_CF_CFDP_ResetTransaction_CallTo_OS_ObjectIdDefined_Returns_false_And_t_history_dir_Is_CF_DIR_TX_And_t_p_Is_nonNULL_And_keep_history_Is_non0_Call_CF_CList_InsertBack_Ex_With_CF_Q_HIST_ThenCall_CF_CList_InsertBack_And_CF_CFDP_FreeTransaction"); diff --git a/unit-test/cf_chunk_tests.c b/unit-test/cf_chunk_tests.c index 8af2e9b0..a681a497 100644 --- a/unit-test/cf_chunk_tests.c +++ b/unit-test/cf_chunk_tests.c @@ -1,10 +1,7 @@ - /* cf testing includes */ #include "cf_test_utils.h" #include "cf_chunk.c" - - typedef struct { const chunks_t *cs; const chunk_t *c; @@ -12,7 +9,6 @@ typedef struct { } CF_PACK Dummy_compute_gap_fn_t_context_t; Dummy_compute_gap_fn_t_context_t context_Dummy_compute_gap_fn_t; - /******************************************************************************* ** ** cf_chunk_tests Setup and Teardown @@ -36,7 +32,6 @@ void cf_chunk_tests_Teardown(void) /* end cf_chunk_tests Setup and Teardown */ - /******************************************************************************* ** ** cf_chunk_tests Local Utility Functions @@ -63,7 +58,7 @@ void Dummy_compute_gap_fn_t(const chunks_t *cs, const chunk_t *c, void *opaque) ** *******************************************************************************/ -void Test_MAX_Returns_a_WhenItIsMaxValue(void) +void Test_MAX_WhenItIsMaxValue_Return_a(void) { /* Arrange */ int32 arg_a = Any_int32(); @@ -77,9 +72,9 @@ void Test_MAX_Returns_a_WhenItIsMaxValue(void) UtAssert_True(result == expectedResult, "\nMAX result was %d\n and should be %d\n which is > %d", result, expectedResult, arg_b); -} /* end Test_MAX_Returns_a_WhenItIsMaxValue */ +} /* end Test_MAX_WhenItIsMaxValue_Return_a */ -void Test_MAX_Returns_b_WhenItIsMaxValue(void) +void Test_MAX_WhenItIsMaxValue_Return_b(void) { /* Arrange */ int32 arg_b = Any_int32(); @@ -93,9 +88,9 @@ void Test_MAX_Returns_b_WhenItIsMaxValue(void) UtAssert_True(result == expectedResult, "\nMAX result was %d\n and should be %d\n which is > %d", result, expectedResult, arg_a); -} /* end Test_MAX_Returns_b_WhenItIsMaxValue */ +} /* end Test_MAX_WhenItIsMaxValue_Return_b */ -void Test_MAX_Returns_a_WhenItIsEqualTo_b(void) +void Test_MAX_WhenItIsEqualTo_b_Returns_a(void) { /* Arrange */ int32 arg_a = Any_int32(); @@ -109,7 +104,7 @@ void Test_MAX_Returns_a_WhenItIsEqualTo_b(void) UtAssert_True(result == expectedResult, "\nMAX result was %d\n and should be %d\n which is = %d", result, expectedResult, arg_a); -} /* end Test_MAX_Returns_a_WhenItIsEqualTo_b */ +} /* end Test_MAX_WhenItIsEqualTo_b_Returns_a */ /* end macro tests */ @@ -119,25 +114,25 @@ void Test_MAX_Returns_a_WhenItIsEqualTo_b(void) ** *******************************************************************************/ -/* TODO: memmove could be stubbed, but proving problematic. +/* NOTE: memmove could be stubbed, but proving problematic. * CF_Chunks_EraseRange tests will use the memmove call for now */ void Test_CF_Chunks_EraseRange_AssertsBecause_end_IsLessThan_start(void) { - /* Arrange */ - chunks_t dummy_chunks; - chunks_t* arg_chunks = &dummy_chunks; - index_t arg_start = Any_uint32_Except(UINT32_MAX); - index_t arg_end = Any_uint32_LessThan(arg_start); + // /* Arrange */ + // chunks_t dummy_chunks; + // chunks_t* arg_chunks = &dummy_chunks; + // index_t arg_start = Any_uint32_Except(UINT32_MAX); + // index_t arg_end = Any_uint32_LessThan(arg_start); - /* Act */ - //CF_Chunks_EraseRange(&Test_chunks, Test_start, Test_end); + // /* Act */ + // CF_Chunks_EraseRange(&Test_chunks, Test_start, Test_end); - /* Assert */ - UtAssert_Failed("CF_Assert issue - end>=start"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - end>=start"); } /* end Test_CF_Chunks_EraseRange_AssertsBecause_end_IsLessThan_start */ -/* TODO Test_CF_Chunks_EraseRange_AssertsBecause_end_EqTo_start not required but desired */ +/* NOTE: Test_CF_Chunks_EraseRange_AssertsBecause_end_EqTo_start not required but desired */ // void Test_CF_Chunks_EraseRange_AssertsBecause_end_EqTo_start(void) // { // /* Arrange */ @@ -150,10 +145,10 @@ void Test_CF_Chunks_EraseRange_AssertsBecause_end_IsLessThan_start(void) // //CF_Chunks_EraseRange(&Test_chunks, Test_start, Test_end); // /* Assert */ -// UtAssert_Failed("CF_Assert issue - end>=start"); +// UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - end>=start"); // } /* end Test_CF_Chunks_EraseRange_AssertsBecause_end_EqTo_start */ -void Test_CF_Chunks_EraseRange_When_start_Is_OneMoreThan_end_MovesOneChunk(void) +void Test_CF_Chunks_When_start_Is_OneMoreThan_end_MovesOneChunk_EraseRange(void) { /* Arrange */ chunk_t dummy_chunk_array[2]; @@ -180,9 +175,9 @@ void Test_CF_Chunks_EraseRange_When_start_Is_OneMoreThan_end_MovesOneChunk(void) /* Assert */ UtAssert_UINT32_EQ(arg_chunks->chunks[0].offset, dummy_end_offset); UtAssert_UINT32_EQ(arg_chunks->chunks[0].size, dummy_end_size); -} /* end Test_CF_Chunks_EraseRange_When_start_Is_OneMoreThan_end_MovesOneChunk */ +} /* end Test_CF_Chunks_When_start_Is_OneMoreThan_end_MovesOneChunk_EraseRange */ -void Test_CF_Chunks_EraseRange_When_start_IsLessThan_chunks_count_DoesNotChangeStart(void) +void Test_CF_Chunks_When_start_IsLessThan_chunks_count_DoesNotChangeStart_EraseRange(void) { /* Arrange */ chunk_t dummy_chunk_array[2]; @@ -209,7 +204,7 @@ void Test_CF_Chunks_EraseRange_When_start_IsLessThan_chunks_count_DoesNotChangeS /* Assert */ UtAssert_UINT32_EQ(arg_chunks->chunks[0].offset, dummy_start_offset); UtAssert_UINT32_EQ(arg_chunks->chunks[0].size, dummy_start_size); -} /* end Test_CF_Chunks_EraseRange_When_start_IsLessThan_chunks_count_DoesNotChangeStart */ +} /* end Test_CF_Chunks_When_start_IsLessThan_chunks_count_DoesNotChangeStart_EraseRange */ /* end CF_Chunks_EraseRange tests */ @@ -219,44 +214,44 @@ void Test_CF_Chunks_EraseRange_When_start_IsLessThan_chunks_count_DoesNotChangeS ** *******************************************************************************/ -/* TODO: memmove could be stubbed, but proving problematic. +/* NOTE: memmove could be stubbed, but proving problematic. * CF_Chunks_EraseChunk tests will use the memmove call for now */ -void Test_CF_Chunks_EraseChunk_FailsAssert_Given_chunks_count_IsEqTo_0(void) +void Test_CF_Chunks_EraseChunk_AssertsBecause_Given_chunks_count_IsEqTo_0(void) { - /* Arrange */ - chunks_t dummy_chunks; - chunks_t* arg_chunks = &dummy_chunks; - index_t arg_erase_index = Any_index_t(); + // /* Arrange */ + // chunks_t dummy_chunks; + // chunks_t* arg_chunks = &dummy_chunks; + // index_t arg_erase_index = Any_index_t(); - arg_chunks->count = 0; + // arg_chunks->count = 0; - /* Act */ - //CF_Chunks_EraseChunk(arg_chunks, arg_erase_index); + // /* Act */ + // CF_Chunks_EraseChunk(arg_chunks, arg_erase_index); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_Chunks_EraseChunk_FailsAssert_Given_chunks_count_IsEqTo_0 */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +} /* end Test_CF_Chunks_EraseChunk_AssertsBecause_Given_chunks_count_IsEqTo_0 */ -void Test_CF_Chunks_EraseChunk_FailsAssert_Given_erase_index_IsEqTo_chunks_count(void) +void Test_CF_Chunks_EraseChunk_AssertsBecause_Given_erase_index_IsEqTo_chunks_count(void) { - /* Arrange */ - chunks_t dummy_chunks; - chunks_t* arg_chunks = &dummy_chunks; - index_t arg_erase_index; + // /* Arrange */ + // chunks_t dummy_chunks; + // chunks_t* arg_chunks = &dummy_chunks; + // index_t arg_erase_index; - arg_chunks->count = 1; + // arg_chunks->count = 1; - arg_erase_index = 2; + // arg_erase_index = 2; - /* Act */ - //CF_Chunks_EraseChunk(arg_chunks, arg_erase_index); + // /* Act */ + // CF_Chunks_EraseChunk(arg_chunks, arg_erase_index); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_Chunks_EraseChunk_FailsAssert_Given_erase_index_IsEqTo_chunks_count */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +} /* end Test_CF_Chunks_EraseChunk_AssertsBecause_Given_erase_index_IsEqTo_chunks_count */ -void Test_CF_Chunks_EraseChunk_ErasesOneChunkWhenThereIsOnlyOneAndDecrements_count_To_0(void) +void Test_CF_Chunks_EraseChunk_WhenThereIsOnlyOneEraseOneChunkAndDecrement_count_To_0(void) { /* Arrange */ chunk_t dummy_start_chunk[1]; @@ -274,13 +269,13 @@ void Test_CF_Chunks_EraseChunk_ErasesOneChunkWhenThereIsOnlyOneAndDecrements_cou /* Assert */ UtAssert_UINT32_EQ(arg_chunks->count, 0); -} /* end Test_CF_Chunks_EraseChunk_ErasesOneChunkWhenThereIsOnlyOneAndDecrements_count_To_0 */ +} /* end Test_CF_Chunks_EraseChunk_WhenThereIsOnlyOneEraseOneChunkAndDecrement_count_To_0 */ -void Test_CF_Chunks_EraseChunk_ErasesOneChunkThatIsNotTheLastFrom_chunks_AndDecrements_count(void) +void Test_CF_Chunks_EraseChunk_EraseOneChunkThatIsNotTheLastFrom_chunks_AndDecrement_count(void) { /* Arrange */ uint8 intial_count = Any_uint8_LessThan(10) + 2; /* 2-11, reasonably small count for testing and not its normal uint32 */ - chunk_t dummy_chunk[11] = {0}; + chunk_t dummy_chunk[11] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_erase_index; @@ -319,7 +314,7 @@ void Test_CF_Chunks_EraseChunk_ErasesOneChunkThatIsNotTheLastFrom_chunks_AndDecr /* Assert */ UtAssert_UINT32_EQ(arg_chunks->count, intial_count - 1); - /* TODO: EXAMPLE: These for loops' output is probably a good indication of why these base outputs do not provide enough info */ + /* NOTE: EXAMPLE: These for loops' output is probably a good indication of why these base outputs do not provide enough info */ for(i = 0; i < arg_erase_index; ++i) { UtAssert_UINT32_EQ(dummy_chunk[i].offset, offsets[i]); /* NOTE: using UINT32_EQ because that is offset's underlying type */ @@ -332,21 +327,19 @@ void Test_CF_Chunks_EraseChunk_ErasesOneChunkThatIsNotTheLastFrom_chunks_AndDecr UtAssert_UINT32_EQ(dummy_chunk[i + arg_erase_index].size, updated_sizes[i]); /* NOTE: using UINT32_EQ because that is size's underlying type */ } -} /* end Test_CF_Chunks_EraseChunk_ErasesOneChunkWhenThereIsOnlyOneAndDecrements_count_To_0 */ +} /* end Test_CF_Chunks_EraseChunk_EraseOneChunkThatIsNotTheLastFrom_chunks_AndDecrement_count */ void Test_CF_Chunks_EraseChunk_ErasesLastChunkFrom_chunks_AndDecrements_count(void) { /* Arrange */ uint8 initial_count = Any_uint8_LessThan(10) + 2; /* 2-11, reasonably small count for testing and not its normal uint32 */ - chunk_t dummy_chunk[11] = {0}; + chunk_t dummy_chunk[11] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_erase_index = initial_count - 1; uint8 i = 0; chunk_offset_t offsets[11] = {0}; chunk_size_t sizes[11] = {0}; - chunk_offset_t updated_offsets[10] = {0}; - chunk_size_t updated_sizes[10] = {0}; arg_chunks->count = initial_count; arg_chunks->chunks = dummy_chunk; @@ -361,13 +354,6 @@ void Test_CF_Chunks_EraseChunk_ErasesLastChunkFrom_chunks_AndDecrements_count(vo offsets[i] = dummy_chunk[i].offset; sizes[i] = dummy_chunk[i].size; - /* chunk past erased will take the place of erase_index, etc. */ - if (i >= arg_erase_index + 1) - { - updated_offsets[i - arg_erase_index - 1] = dummy_chunk[i].offset; - updated_sizes[i - arg_erase_index - 1] = dummy_chunk[i].size; - } - } /* Act */ @@ -375,7 +361,7 @@ void Test_CF_Chunks_EraseChunk_ErasesLastChunkFrom_chunks_AndDecrements_count(vo /* Assert */ UtAssert_UINT32_EQ(arg_chunks->count, initial_count - 1); - /* TODO: EXAMPLE: These for loops' output is probably a good indication of why these base outputs do not provide enough info */ + /* NOTE: EXAMPLE: These for loops' output is probably a good indication of why these base outputs do not provide enough info */ for(i = 0; i < arg_erase_index; ++i) { UtAssert_UINT32_EQ(dummy_chunk[i].offset, offsets[i]); /* NOTE: using UINT32_EQ because that is offset's underlying type */ @@ -397,29 +383,29 @@ void Test_CF_Chunks_EraseChunk_ErasesLastChunkFrom_chunks_AndDecrements_count(vo ** *******************************************************************************/ -/* TODO: memmove should be wrapped for stubbing, but proving problematic. +/* NOTE: memmove should be wrapped for stubbing, but proving problematic. * CF_Chunks_InsertChunk tests will use the memmove call for now */ -void Test_CF_Chunks_InsertChunk_FailsAssert_Given_chunks_count_IsEqTo_chunks_CF_max_chunks(void) +void Test_CF_Chunks_InsertChunk_AssertsBecause_Given_chunks_count_IsEqTo_chunks_CF_max_chunks(void) { - /* Arrange */ - chunks_t dummy_chunks; - chunks_t* arg_chunks = &dummy_chunks; - index_t arg_index_before = Any_index_t(); - chunk_t arg_chunk = {0}; + // /* Arrange */ + // chunks_t dummy_chunks; + // chunks_t* arg_chunks = &dummy_chunks; + // index_t arg_index_before = Any_index_t(); + // chunk_t arg_chunk = {0}; - arg_chunks->count = Any_uint32(); - arg_chunks->CF_max_chunks = arg_chunks->count; + // arg_chunks->count = Any_uint32(); + // arg_chunks->CF_max_chunks = arg_chunks->count; - /* Act */ - //CF_Chunks_InsertChunk(arg_chunks, arg_index_before, arg_chunk); + // /* Act */ + // CF_Chunks_InsertChunk(arg_chunks, arg_index_before, arg_chunk); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_Chunks_InsertChunk_FailsAssert_Given_chunks_count_IsEqTo_chunks_CF_max_chunks */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +} /* end Test_CF_Chunks_InsertChunk_AssertsBecause_Given_chunks_count_IsEqTo_chunks_CF_max_chunks */ -/* TODO Test_CF_Chunks_InsertChunk_FailsAssert_Given_chunks_count_IsGreaterThan_chunks_CF_max_chunks not required but desired */ -// void Test_CF_Chunks_InsertChunk_FailsAssert_Given_chunks_count_IsGreaterThan_chunks_CF_max_chunks(void) +/* NOTE: Test_CF_Chunks_InsertChunk_AssertsBecause_Given_chunks_count_IsGreaterThan_chunks_CF_max_chunks not required but desired */ +// void Test_CF_Chunks_InsertChunk_AssertsBecause_Given_chunks_count_IsGreaterThan_chunks_CF_max_chunks(void) // { // /* Arrange */ // chunks_t dummy_chunks; @@ -435,10 +421,10 @@ void Test_CF_Chunks_InsertChunk_FailsAssert_Given_chunks_count_IsEqTo_chunks_CF_ // //CF_Chunks_InsertChunk(arg_chunks, arg_index_before, arg_chunk); // /* Assert */ -// UtAssert_Failed("CF_Assert issue"); -// } /* end Test_CF_Chunks_InsertChunk_FailsAssert_Given_chunks_count_IsGreaterThan_chunks_CF_max_chunks */ +// UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); +// } /* end Test_CF_Chunks_InsertChunk_AssertsBecause_Given_chunks_count_IsGreaterThan_chunks_CF_max_chunks */ -void Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoEmpty_chunks(void) +void Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoEmpty_chunks(void) { /* Arrange */ chunk_t initial_chunks[1]; @@ -464,13 +450,13 @@ void Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoEmpty_chunks(void) UtAssert_UINT32_EQ(arg_chunks->chunks[0].offset, dummy_chunk.offset); /* NOTE: using UINT32_EQ because that is offset's underlying type */ UtAssert_UINT32_EQ(arg_chunks->chunks[0].size, dummy_chunk.size); /* NOTE: using UINT32_EQ because that is size's underlying type */ UtAssert_UINT32_EQ(arg_chunks->count, 1); -} /* end Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoEmpty_chunks */ +} /* end Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoEmpty_chunks */ -void Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoStartOfSingle_chunks(void) +void Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoStartOfSingle_chunks(void) { /* Arrange */ chunk_t initial_start_chunk; - chunk_t initial_chunks[2] = {0}; + chunk_t initial_chunks[2] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_index_before = 0; @@ -499,13 +485,13 @@ void Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoStartOfSingle_chunks(void) UtAssert_UINT32_EQ(arg_chunks->chunks[1].offset, initial_start_chunk.offset); /* NOTE: using UINT32_EQ because that is offset's underlying type */ UtAssert_UINT32_EQ(arg_chunks->chunks[1].size, initial_start_chunk.size); /* NOTE: using UINT32_EQ because that is size's underlying type */ UtAssert_UINT32_EQ(arg_chunks->count, 2); -} /* end Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoStartOfSingle_chunks */ +} /* end Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoStartOfSingle_chunks */ -void Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoEndOfSingle_chunks(void) +void Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoEndOfSingle_chunks(void) { /* Arrange */ chunk_t initial_start_chunk; - chunk_t initial_chunks[2] = {0}; + chunk_t initial_chunks[2] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_index_before = 1; @@ -534,13 +520,13 @@ void Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoEndOfSingle_chunks(void) UtAssert_UINT32_EQ(arg_chunks->chunks[1].offset, dummy_chunk.offset); /* NOTE: using UINT32_EQ because that is offset's underlying type */ UtAssert_UINT32_EQ(arg_chunks->chunks[1].size, dummy_chunk.size); /* NOTE: using UINT32_EQ because that is size's underlying type */ UtAssert_UINT32_EQ(arg_chunks->count, 2); -} /* end Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoEndOfSingle_chunks */ +} /* end Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoEndOfSingle_chunks */ -void Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoSome_chunks(void) +void Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoSome_chunks(void) { /* Arrange */ index_t initial_count = Any_uint8_LessThan(10) + 1;/* 1-10, reasonably small count for testing and not its normal uint32 */ - chunk_t initial_chunks[11] = {0}; + chunk_t initial_chunks[11] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_index_before = 0; @@ -589,7 +575,7 @@ void Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoSome_chunks(void) UtAssert_UINT32_EQ(arg_chunks->chunks[i].offset, updated_offsets[i]); /* NOTE: using UINT32_EQ because that is offset's underlying type */ UtAssert_UINT32_EQ(arg_chunks->chunks[i].size, updated_sizes[i]); /* NOTE: using UINT32_EQ because that is size's underlying type */ } -} /* end Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoSome_chunks */ +} /* end Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoSome_chunks */ /* end CF_Chunks_InsertChunk tests */ @@ -599,7 +585,7 @@ void Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoSome_chunks(void) ** *******************************************************************************/ -void Test_CF_Chunks_FindInsertPosition_Given_chunks_IsEmptyReturns_0(void) +void Test_CF_Chunks_FindInsertPosition_Given_chunks_IsEmptyReturn_0(void) { /* Arrange */ chunks_t dummy_chunks; @@ -615,12 +601,12 @@ void Test_CF_Chunks_FindInsertPosition_Given_chunks_IsEmptyReturns_0(void) /* Assert */ UtAssert_UINT32_EQ(local_result, 0); -} /* end Test_CF_Chunks_InsertChunk_FailsAssert_Given_chunks_count_IsEqTo_chunks_CF_max_chunks */ +} /* end Test_CF_Chunks_FindInsertPosition_Given_chunks_IsEmptyReturn_0 */ -void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_LessThanItemOffsetReturns_0(void) +void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_LessThanItemOffsetReturn_0(void) { /* Arrange */ - chunk_t initial_chunks[1] = {0}; + chunk_t initial_chunks[1] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; chunk_t dummy_chunk = {0}; @@ -639,12 +625,12 @@ void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_off /* Assert */ UtAssert_UINT32_EQ(local_result, 0); -} /* end Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_LessThanItemOffsetReturns_0 */ +} /* end Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_LessThanItemOffsetReturn_0 */ -void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_EqToItemOffsetReturns_0(void) +void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_EqToItemOffsetReturn_0(void) { /* Arrange */ - chunk_t initial_chunks[1] = {0}; + chunk_t initial_chunks[1] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; chunk_t dummy_chunk = {0}; @@ -663,12 +649,12 @@ void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_off /* Assert */ UtAssert_UINT32_EQ(local_result, 0); -} /* end Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_EqToItemOffsetReturns_0 */ +} /* end Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_EqToItemOffsetReturn_0 */ -void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_GreaterThanOffsetReturns_1(void) +void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_GreaterThanOffsetReturn_1(void) { /* Arrange */ - chunk_t initial_chunks[1] = {0}; + chunk_t initial_chunks[1] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; chunk_t dummy_chunk = {0}; @@ -687,12 +673,12 @@ void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_off /* Assert */ UtAssert_UINT32_EQ(local_result, 1); -} /* end Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_GreaterThanOffsetReturns_1 */ +} /* end Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_GreaterThanOffsetReturn_1 */ -void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasTwoItemsAndGiven_chunk_offset_IsInBetweenTheirOffsetsReturns_1(void) +void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasTwoItemsAndGiven_chunk_offset_IsInBetweenTheirOffsetsReturn_1(void) { /* Arrange */ - chunk_t initial_chunks[2] = {0}; + chunk_t initial_chunks[2] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; chunk_t dummy_chunk = {0}; @@ -712,12 +698,12 @@ void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasTwoItemsAndGiven_chunk_of /* Assert */ UtAssert_UINT32_EQ(local_result, 1); -} /* end Test_CF_Chunks_FindInsertPosition_Given_chunks_HasTwoItemsAndGiven_chunk_offset_IsInBetweenTheirOffsetsReturns_1 */ +} /* end Test_CF_Chunks_FindInsertPosition_Given_chunks_HasTwoItemsAndGiven_chunk_offset_IsInBetweenTheirOffsetsReturn_1 */ -void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasAnyItemsAndReturnsCorrectExpectedPosition(void) +void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasAnyItemsAndReturnCorrectExpectedPosition(void) { /* Arrange */ - chunk_t initial_chunks[20] = {0}; /* 20 used as a reasonably fast size for the test, but is still illustrative */ + chunk_t initial_chunks[20] = { {0} }; /* 20 used as a reasonably fast size for the test, but is still illustrative */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; chunk_t dummy_chunk = {0}; @@ -747,7 +733,7 @@ void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasAnyItemsAndReturnsCorrect /* Assert */ UtAssert_UINT32_EQ(local_result, num_chunks_before); -} /* end Test_CF_Chunks_FindInsertPosition_Given_chunks_HasAnyItemsAndReturnsCorrectExpectedPosition */ +} /* end Test_CF_Chunks_FindInsertPosition_Given_chunks_HasAnyItemsAndReturnCorrectExpectedPosition */ /* end CF_Chunks_FindInsertPosition tests */ @@ -759,25 +745,25 @@ void Test_CF_Chunks_FindInsertPosition_Given_chunks_HasAnyItemsAndReturnsCorrect void Test_CF_Chunks_CombinePrevious_Asserts_i_GivenIsEqTo_chunks_CF_max_Chunks(void) { - /* Arrange */ - chunks_t dummy_chunks; - chunks_t* arg_chunks = &dummy_chunks; - index_t arg_i; - chunk_t dummy_chunk = {0}; - chunk_t* arg_chunk = &dummy_chunk; - index_t local_result; + // /* Arrange */ + // chunks_t dummy_chunks; + // chunks_t* arg_chunks = &dummy_chunks; + // index_t arg_i; + // chunk_t dummy_chunk = {0}; + // chunk_t* arg_chunk = &dummy_chunk; + // index_t local_result; - arg_chunks->CF_max_chunks = Any_uint32_Except(0); - arg_i = arg_chunks->CF_max_chunks; + // arg_chunks->CF_max_chunks = Any_uint32_Except(0); + // arg_i = arg_chunks->CF_max_chunks; - /* Act */ - //local_result = CF_Chunks_CombinePrevious(arg_chunks, arg_i, arg_chunk); + // /* Act */ + // local_result = CF_Chunks_CombinePrevious(arg_chunks, arg_i, arg_chunk); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); } /* end Test_CF_Chunks_CombinePrevious_Asserts_i_GivenIsEqTo_chunks_CF_max_Chunks */ -/* TODO Test_CF_Chunks_CombinePrevious_Asserts_i_GivenIsGreaterThan_chunks_CF_max_Chunks not required but desired */ +/* NOTE: Test_CF_Chunks_CombinePrevious_Asserts_i_GivenIsGreaterThan_chunks_CF_max_Chunks not required but desired */ // void Test_CF_Chunks_CombinePrevious_Asserts_i_GivenIsGreaterThan_chunks_CF_max_Chunks(void) // { // /* Arrange */ @@ -795,7 +781,7 @@ void Test_CF_Chunks_CombinePrevious_Asserts_i_GivenIsEqTo_chunks_CF_max_Chunks(v // //local_result = CF_Chunks_CombinePrevious(arg_chunks, arg_i, arg_chunk); // /* Assert */ -// UtAssert_Failed("CF_Assert issue"); +// UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); // } /* end Test_CF_Chunks_CombinePrevious_Asserts_i_GivenIsGreaterThan_chunks_CF_max_Chunks */ void Test_CF_Chunks_CombinePrevious_Given_i_Is_0_Return_0(void) @@ -865,7 +851,7 @@ void Test_CF_Chunks_CombinePrevious_GivenIndexMinusOne_chunks_chunks_ValueFor_pr { /* Arrange */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_i = Any_uint32_LessThan(dummy_chunks_count) + 1; /* arg_i gets +1 because the index is 0 based, but the CUT expects an i of min 1 which is the 0 element */ @@ -894,7 +880,7 @@ void Test_CF_Chunks_CombinePrevious_GivenIndexMinusOne_chunks_chunks_ValueFor_pr { /* Arrange */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_i = Any_uint32_LessThan(dummy_chunks_count) + 1; /* arg_i gets +1 because the index is 0 based, but the CUT expects an i of min 1 which is the 0 element */ @@ -924,7 +910,7 @@ void Test_CF_Chunks_CombinePrevious_GivenIndexMinusOne_chunks_chunks_ValueFor_pr { /* Arrange */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_i = Any_uint32_LessThan(dummy_chunks_count) + 1; /* arg_i gets +1 because the index is 0 based, but the CUT expects an i of min 1 which is the 0 element */ @@ -954,7 +940,7 @@ void Test_CF_Chunks_CombinePrevious_GivenIndexMinusOne_chunks_chunks_ValueFor_pr { /* Arrange */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_i = Any_uint32_LessThan(dummy_chunks_count) + 1; /* arg_i gets +1 because the index is 0 based, but the CUT expects an i of min 1 which is the 0 element */ @@ -984,7 +970,7 @@ void Test_CF_Chunks_CombinePrevious_GivenIndexMinusOne_chunks_chunks_ValueFor_pr { /* Arrange */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_i = Any_uint32_LessThan(dummy_chunks_count) + 1; /* arg_i gets +1 because the index is 0 based, but the CUT expects an i of min 1 which is the 0 element */ @@ -1019,10 +1005,9 @@ void Test_CF_Chunks_CombinePrevious_GivenIndexMinusOne_chunks_chunks_ValueFor_pr ** *******************************************************************************/ -void Test_CF_Chunks_CombineNext_Given_i_IsEqTo_Given_chunks_count_Returns_0(void) +void Test_CF_Chunks_CombineNext_Given_i_IsEqTo_Given_chunks_count_Return_0(void) { /* Arrange */ - chunk_t dummy_chunks_chunks; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_i; @@ -1038,34 +1023,34 @@ void Test_CF_Chunks_CombineNext_Given_i_IsEqTo_Given_chunks_count_Returns_0(void /* Assert */ UtAssert_UINT32_EQ(local_result, 0); -} /* end Test_CF_Chunks_CombineNext_Given_i_IsEqTo_Given_chunks_count_Returns_0 */ +} /* end Test_CF_Chunks_CombineNext_Given_i_IsEqTo_Given_chunks_count_Return_0 */ void Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_AssertsBecauseGiven_chunk_end_LessThanGiven_chunk_offset(void) { - /* Arrange */ - chunk_t dummy_chunks_chunks = {0}; - chunks_t dummy_chunks; - chunks_t* arg_chunks = &dummy_chunks; - index_t arg_i; - chunk_t dummy_chunk = {0}; - chunk_t* arg_chunk = &dummy_chunk; - int local_result = Any_int_Except(0); + // /* Arrange */ + // chunk_t dummy_chunks_chunks = {0}; + // chunks_t dummy_chunks; + // chunks_t* arg_chunks = &dummy_chunks; + // index_t arg_i; + // chunk_t dummy_chunk = {0}; + // chunk_t* arg_chunk = &dummy_chunk; + // int local_result = Any_int_Except(0); - arg_chunks->count = Any_uint32(); - arg_i = Any_uint32_Except(arg_chunks->count); + // arg_chunks->count = Any_uint32(); + // arg_i = Any_uint32_Except(arg_chunks->count); - /* Act */ - //local_result = CF_Chunks_CombineNext(arg_chunks, arg_i, arg_chunk); + // /* Act */ + // local_result = CF_Chunks_CombineNext(arg_chunks, arg_i, arg_chunk); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); } /* end Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_AssertsBecauseGiven_chunk_end_LessThanGiven_chunk_offset */ -void Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_Given_chunks_chunks_i_offset_IsGreaterThan_chunk_end_Returns_0(void) +void Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_Given_chunks_chunks_i_offset_IsGreaterThan_chunk_end_Return_0(void) { /* Arrange */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_i; @@ -1087,13 +1072,13 @@ void Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_Given_chunk /* Assert */ UtAssert_UINT32_EQ(local_result, 0); -} /* end Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_Given_chunks_chunks_i_offset_IsGreaterThan_chunk_end_Returns_0 */ +} /* end Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_Given_chunks_chunks_i_offset_IsGreaterThan_chunk_end_Return_0 */ -void Test_CF_Chunks_CombineNext_Given_chunks_chunks_offset_IsLessThan_chunk_end_CombinesChunksNotAtEndDoesNotEraseRangeReturns_1(void) +void Test_CF_Chunks_CombineNext_Given_chunks_chunks_offset_IsLessThan_chunk_end_CombinesChunksNotAtEndDoesNotEraseRangeReturn_1(void) { /* Arrange */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_i; @@ -1117,13 +1102,13 @@ void Test_CF_Chunks_CombineNext_Given_chunks_chunks_offset_IsLessThan_chunk_end_ /* Assert */ UtAssert_STUB_COUNT(CF_Chunks_EraseRange, 0); UtAssert_UINT32_EQ(local_result, 1); -} /* end Test_CF_Chunks_CombineNext_Given_chunks_chunks_offset_IsLessThan_chunk_end_CombinesChunksNotAtEndDoesNotEraseRangeReturns_1 */ +} /* end Test_CF_Chunks_CombineNext_Given_chunks_chunks_offset_IsLessThan_chunk_end_CombinesChunksNotAtEndDoesNotEraseRangeReturn_1 */ -void Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_BreaksBReplacesEverythingUntilEndAndCalls_CF_Chunks_EraseRange_ThenReturns_1(void) +void Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_BreaksBReplaceEverythingUntilEndAndCall_CF_Chunks_EraseRange_ThenReturn_1(void) { /* Arrange */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_i; @@ -1154,13 +1139,13 @@ void Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_BreaksBReplaces /* Assert */ UtAssert_UINT32_EQ(local_result, 1); -} /* end Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_BreaksBReplacesEverythingUntilEndAndCalls_CF_Chunks_EraseRange_ThenReturns_1 */ +} /* end Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_BreaksBReplaceEverythingUntilEndAndCall_CF_Chunks_EraseRange_ThenReturn_1 */ -void Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_ReplacesEverythingUntilEndAndCalls_CF_Chunks_EraseRange_ThenReturns_1(void) +void Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_ReplaceEverythingUntilEndAndCall_CF_Chunks_EraseRange_ThenReturn_1(void) { /* Arrange */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_i; @@ -1183,7 +1168,7 @@ void Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_ReplacesEveryth /* Assert */ UtAssert_UINT32_EQ(local_result, 1); -} /* end Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_ReplacesEverythingUntilEndAndCalls_CF_Chunks_EraseRange_ThenReturns_1 */ +} /* end Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_ReplaceEverythingUntilEndAndCall_CF_Chunks_EraseRange_ThenReturn_1 */ /* end CF_Chunks_CombineNext tests */ @@ -1193,13 +1178,11 @@ void Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_ReplacesEveryth ** *******************************************************************************/ -void Test_CF_Chunks_FindSmallestSize_Given_chunks_IsEmptyReturns_0(void) +void Test_CF_Chunks_FindSmallestSize_Given_chunks_IsEmptyReturn_0(void) { /* Arrange */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; - chunk_t dummy_chunk = {0}; - chunk_t* arg_chunk = &dummy_chunk; index_t local_result; arg_chunks->count = 0; @@ -1209,16 +1192,14 @@ void Test_CF_Chunks_FindSmallestSize_Given_chunks_IsEmptyReturns_0(void) /* Assert */ UtAssert_UINT32_EQ(local_result, 0); -} /* end Test_CF_Chunks_InsertChunk_FailsAssert_Given_chunks_count_IsEqTo_chunks_CF_max_chunks */ +} /* end Test_CF_Chunks_FindSmallestSize_Given_chunks_IsEmptyReturn_0 */ -void Test_CF_Chunks_FindSmallestSize_Given_chunks_HasOneChunkReturns_0(void) +void Test_CF_Chunks_FindSmallestSize_Given_chunks_HasOneChunkReturn_0(void) { /* Arrange */ - chunk_t initial_chunks[1] = {0}; + chunk_t initial_chunks[1] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; - chunk_t dummy_chunk = {0}; - chunk_t* arg_chunk = &dummy_chunk; index_t local_result; initial_chunks[0].size = Any_uint32(); @@ -1231,12 +1212,12 @@ void Test_CF_Chunks_FindSmallestSize_Given_chunks_HasOneChunkReturns_0(void) /* Assert */ UtAssert_UINT32_EQ(local_result, 0); -} /* end Test_CF_Chunks_FindSmallestSize_Given_chunks_HasOneChunkReturns_0 */ +} /* end Test_CF_Chunks_FindSmallestSize_Given_chunks_HasOneChunkReturn_0 */ void Test_CF_Chunks_FindSmallestSize_Given_chunks_HasTwoChunksReturnsCorrectIndexOfSmallest(void) { /* Arrange */ - chunk_t initial_chunks[2] = {0}; + chunk_t initial_chunks[2] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t expected_result; @@ -1269,7 +1250,7 @@ void Test_CF_Chunks_FindSmallestSize_Given_chunks_HasManyChunksReturnsCorrectInd { /* Arrange */ uint8 dummy_count = 25; - chunk_t initial_chunks[25] = {0}; /* 25 for initial_chunks is arbitrary, small for speed */ + chunk_t initial_chunks[25] = { {0} }; /* 25 for initial_chunks is arbitrary, small for speed */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t expected_result = Any_uint8_LessThan(25); @@ -1324,10 +1305,10 @@ void Test_CF_Chunks_Insert_CallTo_CF_Chunks_CombineNext_Returns_non0_CallTo_CF_C chunk_t dummy_chunk = {0}; chunk_t* arg_chunk = &dummy_chunk; - /* Arrange unstubbable: CF_Chunks_CombineNext to return 1 */ - /* Arrange unstubbable: CF_Chunks_CombinePrevious to return 0 */ + /* Arrange for CF_Chunks_CombineNext to return 1 */ + /* Arrange for CF_Chunks_CombinePrevious to return 0 */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; arg_chunks = &dummy_chunks; @@ -1348,7 +1329,6 @@ void Test_CF_Chunks_Insert_CallTo_CF_Chunks_CombineNext_Returns_non0_CallTo_CF_C CF_Chunks_Insert(arg_chunks, arg_i, arg_chunk); /* Assert */ - /* TODO: nothing good to verify, provides coverage only */ UtAssert_True(arg_chunks->count == initial_i + 1, "chunks->count is %u and should be 1 more than %u (value of i at call)", arg_chunks->count, initial_i); @@ -1362,10 +1342,10 @@ void Test_CF_Chunks_Insert_CombinesNextSuccessButCombinePreviousSuccessCalls_CF_ chunk_t dummy_chunk = {0}; chunk_t* arg_chunk = &dummy_chunk; - /* Arrange unstubbable: CF_Chunks_CombineNext to return 1 */ - /* Arrange unstubbable: CF_Chunks_CombinePrevious to return 1 */ + /* Arrange for CF_Chunks_CombineNext to return 1 */ + /* Arrange for CF_Chunks_CombinePrevious to return 1 */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; arg_chunks = &dummy_chunks; @@ -1382,8 +1362,6 @@ void Test_CF_Chunks_Insert_CombinesNextSuccessButCombinePreviousSuccessCalls_CF_ arg_chunks->chunks[arg_i].offset = 0; arg_chunks->chunks[arg_i].size = UINT32_MAX; /* size = 1 moves existing end to greater than chunk_end */ - /* Arrange unstubbable: CF_Chunks_EraseChunk - TODO: when able */ - /* Act */ CF_Chunks_Insert(arg_chunks, arg_i, arg_chunk); @@ -1403,7 +1381,7 @@ void Test_CF_Chunks_Insert_CallTo_CF_Chunks_CombineNext_Returns_0_CallTo_CF_Chun /* Arrange for CF_Chunks_CombineNext to return 0 and CF_Chunks_CombinePrevious to return 1 */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; arg_chunks = &dummy_chunks; @@ -1417,7 +1395,7 @@ void Test_CF_Chunks_Insert_CallTo_CF_Chunks_CombineNext_Returns_0_CallTo_CF_Chun arg_chunks->chunks = dummy_chunks_chunks; arg_chunks->chunks[arg_i - 1].offset = 9; - arg_chunks->chunks[arg_i - 1].size = 1; /* for prev_end to be 10, chunk_offset (5) < prev_end (10), but prev_end (10) < chunk_end (11) ) + arg_chunks->chunks[arg_i - 1].size = 1; /* for prev_end to be 10, chunk_offset (5) < prev_end (10), but prev_end (10) < chunk_end (11) ) */ /* Act */ CF_Chunks_Insert(arg_chunks, arg_i, arg_chunk); @@ -1439,7 +1417,7 @@ void Test_CF_Chunks_Insert_CallTo_CF_Chunks_CombineNext_Returns_0_CallTo_CF_Chun /* Arrange for CF_Chunks_CombineNext to return 0 and CF_Chunks_CombinePrevious to return 0 */ uint8 dummy_chunks_count = 10; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; arg_chunks = &dummy_chunks; @@ -1453,7 +1431,7 @@ void Test_CF_Chunks_Insert_CallTo_CF_Chunks_CombineNext_Returns_0_CallTo_CF_Chun arg_chunks->chunks = dummy_chunks_chunks; arg_chunks->chunks[arg_i - 1].offset = 9; - arg_chunks->chunks[arg_i - 1].size = 1; /* for prev_end to be 10, chunk_offset (5) < prev_end (10) and prev_end (10) = chunk_end (10) ) + arg_chunks->chunks[arg_i - 1].size = 1; /* for prev_end to be 10, chunk_offset (5) < prev_end (10) and prev_end (10) = chunk_end (10) ) */ /* Act */ CF_Chunks_Insert(arg_chunks, arg_i, arg_chunk); @@ -1475,7 +1453,7 @@ void Test_CF_Chunks_Insert_CallTo_CF_Chunks_CombineNext_Returns_0_CallTo_CF_Chun /* Arrange for CF_Chunks_CombineNext to return 0 and CF_Chunks_CombinePrevious to return 0 */ uint8 dummy_chunks_count = 3; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; arg_chunks = &dummy_chunks; @@ -1514,7 +1492,7 @@ void Test_CF_Chunks_Insert_CallTo_CF_Chunks_CombineNext_Returns_0_CallTo_CF_Chun /* Arrange for CF_Chunks_CombineNext to return 0 and CF_Chunks_CombinePrevious to return 0 */ uint8 dummy_chunks_count = 3; /* 10 for dummy_chunks_count is arbitrary, chosen for speed */ - chunk_t dummy_chunks_chunks[10] = {0}; /* 10 repeated for dummy_chunks for build ability */ + chunk_t dummy_chunks_chunks[10] = { {0} }; /* 10 repeated for dummy_chunks for build ability */ chunks_t dummy_chunks; arg_chunks = &dummy_chunks; @@ -1538,7 +1516,7 @@ void Test_CF_Chunks_Insert_CallTo_CF_Chunks_CombineNext_Returns_0_CallTo_CF_Chun CF_Chunks_Insert(arg_chunks, arg_i, arg_chunk); /* Assert */ - /* Assert for CF_Chunks_EraseChunk and CF_Chunks_InsertChunk (-1/+1 thus no change? TODO: better way to prove these ran)*/ + /* Assert for CF_Chunks_EraseChunk and CF_Chunks_InsertChunk (-1/+1 thus no change? NOTE: better way to prove these ran)*/ UtAssert_True(arg_chunks->count == dummy_chunks_count, "chunks->count is %u and should be %u (value before call)", arg_chunks->count, dummy_chunks_count); @@ -1553,89 +1531,89 @@ void Test_CF_Chunks_Insert_CallTo_CF_Chunks_CombineNext_Returns_0_CallTo_CF_Chun *******************************************************************************/ void Test_CF_Chunks_Add_Asserts_WhenGiven_offset_Plus_size_IsLessThanGiven_offset(void) { - /* Arrange */ - chunk_offset_t arg_offset = UINT32_MAX; - chunk_size_t arg_size = 1; - chunk_t initial_chunks[20] = {0}; /* 20 used as a reasonably fast size for the test, but is still illustrative */ - chunks_t dummy_chunks; - chunks_t* arg_chunks = &dummy_chunks; + // /* Arrange */ + // chunk_offset_t arg_offset = UINT32_MAX; + // chunk_size_t arg_size = 1; + // chunk_t initial_chunks[20] = { {0} }; /* 20 used as a reasonably fast size for the test, but is still illustrative */ + // chunks_t dummy_chunks; + // chunks_t* arg_chunks = &dummy_chunks; - /* Arrange unstubbable: CF_Chunks_FindInsertPosition */ - chunk_t dummy_chunk = {0}; - uint8 num_chunks_before = Any_uint8_LessThan(10); - uint8 num_chunks_after = Any_uint8_LessThan(10); - uint8 i = 0; + // /* Arrange for CF_Chunks_FindInsertPosition */ + // chunk_t dummy_chunk = {0}; + // uint8 num_chunks_before = Any_uint8_LessThan(10); + // uint8 num_chunks_after = Any_uint8_LessThan(10); + // uint8 i = 0; - dummy_chunk.offset = Any_uint32_BetweenInclusive(1, UINT32_MAX - 1); + // dummy_chunk.offset = Any_uint32_BetweenInclusive(1, UINT32_MAX - 1); - for(i = 0; i < num_chunks_before; ++i) - { - initial_chunks[i].offset = Any_uint32_LessThan(dummy_chunk.offset); - } + // for(i = 0; i < num_chunks_before; ++i) + // { + // initial_chunks[i].offset = Any_uint32_LessThan(dummy_chunk.offset); + // } - for(i = 0; i < num_chunks_after; ++i) - { - initial_chunks[i + num_chunks_before].offset = Any_uint32_GreaterThan(dummy_chunk.offset); - } + // for(i = 0; i < num_chunks_after; ++i) + // { + // initial_chunks[i + num_chunks_before].offset = Any_uint32_GreaterThan(dummy_chunk.offset); + // } - arg_chunks->count = num_chunks_before + num_chunks_after; - arg_chunks->chunks = initial_chunks; + // arg_chunks->count = num_chunks_before + num_chunks_after; + // arg_chunks->chunks = initial_chunks; - /* Act */ + // /* Act */ // CF_Chunks_Add(arg_chunks, arg_offset, arg_size); /* Assert */ - UtAssert_Failed("CF_Assert issue"); + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); } /* end Test_CF_Chunks_Add_Asserts_WhenGiven_offset_Plus_size_IsLessThanGiven_offset */ void Test_CF_Chunks_Add_Asserts_WhenInsertPositionIsNotEqualToGiven_chunks_count_And_chunk_offset_IsNotLessThanOrEqToGiven_chunks_i_offset(void) { - /* Arrange */ - chunk_offset_t arg_offset = 1; - chunk_size_t arg_size = 1; - chunk_t initial_chunks[20] = {0}; /* 20 used as a reasonably fast size for the test, but is still illustrative */ - chunks_t dummy_chunks; - chunks_t* arg_chunks = &dummy_chunks; + // /* Arrange */ + // chunk_offset_t arg_offset = 1; + // chunk_size_t arg_size = 1; + // chunk_t initial_chunks[20] = { {0} }; /* 20 used as a reasonably fast size for the test, but is still illustrative */ + // chunks_t dummy_chunks; + // chunks_t* arg_chunks = &dummy_chunks; - /* Arrange unstubbable: CF_Chunks_FindInsertPosition */ - chunk_t dummy_chunk = {0}; - uint8 num_chunks_before = Any_uint8_LessThan(10); - uint8 num_chunks_after = Any_uint8_LessThan(10); - uint8 i = 0; + // /* Arrange for CF_Chunks_FindInsertPosition */ + // chunk_t dummy_chunk = {0}; + // uint8 num_chunks_before = Any_uint8_LessThan(10); + // uint8 num_chunks_after = Any_uint8_LessThan(10); + // uint8 i = 0; - dummy_chunk.offset = Any_uint32_BetweenInclusive(1, UINT32_MAX - 1); + // dummy_chunk.offset = Any_uint32_BetweenInclusive(1, UINT32_MAX - 1); - for(i = 0; i < num_chunks_before; ++i) - { - initial_chunks[i].offset = Any_uint32_LessThan(dummy_chunk.offset); - } + // for(i = 0; i < num_chunks_before; ++i) + // { + // initial_chunks[i].offset = Any_uint32_LessThan(dummy_chunk.offset); + // } - for(i = 0; i < num_chunks_after; ++i) - { - initial_chunks[i + num_chunks_before].offset = Any_uint32_GreaterThan(dummy_chunk.offset); - } + // for(i = 0; i < num_chunks_after; ++i) + // { + // initial_chunks[i + num_chunks_before].offset = Any_uint32_GreaterThan(dummy_chunk.offset); + // } - arg_chunks->count = num_chunks_before + num_chunks_after; - arg_chunks->chunks = initial_chunks; + // arg_chunks->count = num_chunks_before + num_chunks_after; + // arg_chunks->chunks = initial_chunks; - /* Act */ - // TODO: unsure how to set this up to hit the assert. + // /* Act */ + // /* NOTE: unsure how to set this up to hit the assert. */ // CF_Chunks_Add(arg_chunks, arg_offset, arg_size); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); } /* end Test_CF_Chunks_Add_Asserts_WhenInsertPositionIsNotEqualToGiven_chunks_count_And_chunk_offset_IsNotLessThanOrEqToGiven_chunks_i_offset */ -void Test_CF_Chunks_Add_Calls_CF_Chunks_Insert_WhenNotAtEnd(void) +void Test_CF_Chunks_Add_WhenNotAtEndCall_CF_Chunks_Insert(void) { /* Arrange */ chunk_offset_t arg_offset = 0; chunk_size_t arg_size = 0; - chunk_t initial_chunks[20] = {0}; /* 20 used as a reasonably fast size for the test, but is still illustrative */ + chunk_t initial_chunks[20] = { {0} }; /* 20 used as a reasonably fast size for the test, but is still illustrative */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; - /* Arrange unstubbable: CF_Chunks_FindInsertPosition */ + /* Arrange for CF_Chunks_FindInsertPosition */ chunk_t dummy_chunk = {0}; uint8 num_chunks_before = Any_uint8_LessThan(10); uint8 num_chunks_after = Any_uint8_LessThan(10); @@ -1660,20 +1638,20 @@ void Test_CF_Chunks_Add_Calls_CF_Chunks_Insert_WhenNotAtEnd(void) CF_Chunks_Add(arg_chunks, arg_offset, arg_size); /* Assert */ - /* TODO: find a way to verify results in this test */ + /* NOTE: find a way to verify results in this test */ UtAssert_True(true, "Nothing is able to be asserted on here, success is measured by test not segfaulting and coverage check."); -} /* end Test_CF_Chunks_Add_Calls_CF_Chunks_Insert_WhenNotAtEnd */ +} /* end Test_CF_Chunks_Add_WhenNotAtEndCall_CF_Chunks_Insert */ -void Test_CF_Chunks_Add_Calls_CF_Chunks_Insert_WhenAtEnd(void) +void Test_CF_Chunks_Add_WhenAtEndCall_CF_Chunks_Insert(void) { /* Arrange */ chunk_offset_t arg_offset = 10; chunk_size_t arg_size = 5; - chunk_t initial_chunks[1] = {0}; /* 20 used as a reasonably fast size for the test, but is still illustrative */ + chunk_t initial_chunks[2] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; - /* Arrange unstubbable: CF_Chunks_FindInsertPosition */ + /* Arrange for CF_Chunks_FindInsertPosition */ initial_chunks->offset = 0; initial_chunks->size = 0; @@ -1684,9 +1662,9 @@ void Test_CF_Chunks_Add_Calls_CF_Chunks_Insert_WhenAtEnd(void) CF_Chunks_Add(arg_chunks, arg_offset, arg_size); /* Assert */ - /* TODO: find a way to verify results in this test */ + /* NOTE: find a way to verify results in this test */ UtAssert_True(true, "Nothing is able to be asserted on here, success is measured by test not segfaulting and coverage check."); -} /* end Test_CF_Chunks_Add_Calls_CF_Chunks_Insert_WhenAtEnd */ +} /* end Test_CF_Chunks_Add_WhenAtEndCall_CF_Chunks_Insert */ /* end CF_Chunks_Add tests */ @@ -1696,7 +1674,7 @@ void Test_CF_Chunks_Add_Calls_CF_Chunks_Insert_WhenAtEnd(void) ** *******************************************************************************/ -void Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsEqToGiven_size_Calls_CF_Chunks_EraseChunk(void) +void Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsEqToGiven_size_Call_CF_Chunks_EraseChunk(void) { /* Arrange */ chunks_t dummy_chunks; @@ -1704,7 +1682,6 @@ void Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsEqT chunk_offset_t initial_chunks_chunks_offset = Any_uint32(); chunk_size_t arg_size = Any_uint32_Except(0); chunk_t dummy_chunks_chunks; - const chunk_t* local_result; arg_chunks->count = 1; arg_chunks->chunks = &dummy_chunks_chunks; @@ -1719,9 +1696,9 @@ void Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsEqT UtAssert_UINT32_EQ(arg_chunks->count, 0); UtAssert_UINT32_EQ(arg_chunks->chunks[0].offset, initial_chunks_chunks_offset); UtAssert_UINT32_EQ(arg_chunks->chunks[0].size, 0); -} /* end Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsEqToGiven_size_Calls_CF_Chunks_EraseChunk */ +} /* end Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsEqToGiven_size_Call_CF_Chunks_EraseChunk */ -void Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsSmallerThanGiven_size_Calls_CF_Chunks_EraseChunk(void) +void Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsSmallerThanGiven_size_Call_CF_Chunks_EraseChunk(void) { /* Arrange */ chunks_t dummy_chunks; @@ -1730,7 +1707,6 @@ void Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsSma chunk_size_t arg_size = Any_uint32_Except(UINT32_MAX - 1) + 2; /* from 2 to UINT_32_MAX */ chunk_size_t dummy_chunk_size = Any_uint32_LessThan(arg_size); chunk_t dummy_chunks_chunks; - const chunk_t* local_result; arg_chunks->count = 1; arg_chunks->chunks = &dummy_chunks_chunks; @@ -1745,9 +1721,9 @@ void Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsSma UtAssert_UINT32_EQ(arg_chunks->count, 0); UtAssert_UINT32_EQ(arg_chunks->chunks[0].offset, initial_chunks_chunks_offset); UtAssert_UINT32_EQ(arg_chunks->chunks[0].size, 0); -} /* end Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsSmallerThanGiven_size_Calls_CF_Chunks_EraseChunk */ +} /* end Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsSmallerThanGiven_size_Call_CF_Chunks_EraseChunk */ -void Test_CF_Chunks_RemoveFromFirst_When_chunks_size_IsGreaterThanGiven_size_AddsGiven_size_To_chunks_chunks_0_offset_AndSets_chunks_chunks_size_To_0(void) +void Test_CF_Chunks_RemoveFromFirst_When_chunks_size_IsGreaterThanGiven_size_AddGiven_size_To_chunks_chunks_0_offset_AndSet_chunks_chunks_size_To_0(void) { /* Arrange */ chunks_t dummy_chunks; @@ -1755,10 +1731,7 @@ void Test_CF_Chunks_RemoveFromFirst_When_chunks_size_IsGreaterThanGiven_size_Add chunk_offset_t initial_chunks_chunks_offset = Any_uint32(); chunk_size_t arg_size = Any_uint32_Except(0); /* from 2 to UINT_32_MAX */ chunk_size_t dummy_chunk_size = Any_uint32_GreaterThan(arg_size); - // chunk_size_t arg_size = Any_uint32_Except(0); - // chunk_size_t dummy_chunk_size = Any_uint32_LessThan(arg_size); chunk_t dummy_chunks_chunks; - const chunk_t* local_result; arg_chunks->count = 1; arg_chunks->chunks = &dummy_chunks_chunks; @@ -1772,7 +1745,7 @@ void Test_CF_Chunks_RemoveFromFirst_When_chunks_size_IsGreaterThanGiven_size_Add UtAssert_UINT32_EQ(arg_chunks->count, 1); UtAssert_UINT32_EQ(arg_chunks->chunks[0].offset, initial_chunks_chunks_offset + arg_size); UtAssert_UINT32_EQ(arg_chunks->chunks[0].size, dummy_chunk_size - arg_size); -} /* end Test_CF_Chunks_RemoveFromFirst_When_chunks_size_IsGreaterThanGiven_size_AddsGiven_size_To_chunks_chunks_0_offset_AndSets_chunks_chunks_size_To_0 */ +} /* end Test_CF_Chunks_RemoveFromFirst_When_chunks_size_IsGreaterThanGiven_size_AddGiven_size_To_chunks_chunks_0_offset_AndSet_chunks_chunks_size_To_0 */ /* end CF_Chunks_RemoveFromFirst tests */ @@ -1782,7 +1755,7 @@ void Test_CF_Chunks_RemoveFromFirst_When_chunks_size_IsGreaterThanGiven_size_Add ** *******************************************************************************/ -void Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_0_Returns_NULL(void) +void Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_0_Return_NULL(void) { /* Arrange */ chunks_t dummy_chunks; @@ -1796,9 +1769,9 @@ void Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_0_Returns_NULL(void) /* Assert */ UtAssert_NULL(local_result); -} /* end Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_0_Returns_NULL */ +} /* end Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_0_Return_NULL */ -void Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_1_ReturnsOnlyChunk(void) +void Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_1_ReturnOnlyChunk(void) { /* Arrange */ chunks_t dummy_chunks = {0}; @@ -1815,9 +1788,9 @@ void Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_1_ReturnsOnlyChunk(v /* Assert */ UtAssert_ADDRESS_EQ(local_result, &arg_chunks->chunks[0]); UtAssert_ADDRESS_EQ(local_result, &only_chunk); -} /* end Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_1_ReturnsOnlyChunk */ +} /* end Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_1_ReturnOnlyChunk */ -void Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_Any_index_tReturnsFirstChunk(void) +void Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_Any_index_t_ReturnFirstChunk(void) { /* Arrange */ chunks_t dummy_chunks = {0}; @@ -1834,7 +1807,7 @@ void Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_Any_index_tReturnsFi /* Assert */ UtAssert_ADDRESS_EQ(local_result, &arg_chunks->chunks[0]); UtAssert_ADDRESS_EQ(local_result, &first_chunk); -} /* end Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_Any_index_tReturnsFirstChunk */ +} /* end Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_Any_index_t_ReturnFirstChunk */ /* CF_Chunks_GetFirstChunk tests */ @@ -1846,27 +1819,26 @@ void Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_Any_index_tReturnsFi void Test_CF_Chunks_Init_AssertsBecauseGiven_CF_max_chunks_Is_0(void) { - /* Arrange */ - chunks_t dummy_chunks; - chunks_t* arg_chunks = &dummy_chunks; - index_t arg_CF_max_chunks = Any_uint16() + 2; /* 2-65537, uint16 is used instead of index_t to have a reasonably decent size for the test without being too large (segfault) */ - chunk_t* arg_chunks_mem; + // /* Arrange */ + // chunks_t dummy_chunks; + // chunks_t* arg_chunks = &dummy_chunks; + // index_t arg_CF_max_chunks = Any_uint16() + 2; /* 2-65537, uint16 is used instead of index_t to have a reasonably decent size for the test without being too large (segfault) */ + // chunk_t* arg_chunks_mem; - /* Act */ + // /* Act */ // CF_Chunks_Init(arg_chunks, arg_CF_max_chunks, arg_chunks_mem); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); } /* end Test_CF_Chunks_Init_AssertsBecauseGiven_CF_max_chunks_Is_0 */ -void Test_CF_Chunks_Init_SetsGiven_chunks_CF_max_chunks_ToGiven_CF_max_chunks(void) +void Test_CF_Chunks_Init_SetGiven_chunks_CF_max_chunks_ToGiven_CF_max_chunks(void) { /* Arrange */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_CF_max_chunks = Any_uint16() + 2; /* 2-65537, uint8 is used instead of index_t to have a reasonably decent size for the test without being too large (segfault) */ - chunk_t* arg_chunks_mem[arg_CF_max_chunks]; - const chunk_t* local_result; + chunk_t arg_chunks_mem[arg_CF_max_chunks]; arg_chunks->count = 0; @@ -1879,8 +1851,9 @@ void Test_CF_Chunks_Init_SetsGiven_chunks_CF_max_chunks_ToGiven_CF_max_chunks(vo /* Assert Unstubbable - CF_ChunksReset */ UtAssert_ZERO(arg_chunks->count); UtAssert_MemCmpValue(arg_chunks->chunks, 0x00, sizeof(*arg_chunks->chunks) * arg_CF_max_chunks, - "The chunks, %u bytes (sizeof(*chunks->chunks)*chunks->CF_max_chunks), were all set to 0", sizeof(chunk_t)*arg_CF_max_chunks); -} /* end Test_CF_Chunks_Init_SetsGiven_chunks_CF_max_chunks_ToGiven_CF_max_chunks */ + "The chunks, %lu bytes (sizeof(*chunks->chunks)*chunks->CF_max_chunks), were all set to 0", + sizeof(chunk_t)*arg_CF_max_chunks); +} /* end Test_CF_Chunks_Init_SetGiven_chunks_CF_max_chunks_ToGiven_CF_max_chunks */ /* CF_Chunks_Init tests */ @@ -1890,14 +1863,13 @@ void Test_CF_Chunks_Init_SetsGiven_chunks_CF_max_chunks_ToGiven_CF_max_chunks(vo ** *******************************************************************************/ -void Test_CF_ChunksReset_Sets_count_To_0_Keeps_CF_max_chunks_AndMemsets_chunks_ToAll_0(void) +void Test_CF_ChunksReset_Set_count_To_0_Keeps_CF_max_chunks_AndMemsets_chunks_ToAll_0(void) { /* Arrange */ chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t initial_CF_max_chunks = Any_uint16() + 2; /* 2-65537, uint8 is used instead of index_t to have a reasonably decent size for the test without being too large (segfault) */ chunk_t dummy_chunks_chunks[initial_CF_max_chunks]; - const chunk_t* local_result; arg_chunks->count = Any_index_t(); arg_chunks->CF_max_chunks = initial_CF_max_chunks; @@ -1910,69 +1882,70 @@ void Test_CF_ChunksReset_Sets_count_To_0_Keeps_CF_max_chunks_AndMemsets_chunks_T UtAssert_ZERO(arg_chunks->count); UtAssert_UINT32_EQ(arg_chunks->CF_max_chunks, initial_CF_max_chunks); UtAssert_MemCmpValue(arg_chunks->chunks, 0x00, sizeof(chunk_t)*initial_CF_max_chunks, - "The chunks, %u bytes (sizeof(chunk_t)*chunks->CF_max_chunks), were all set to 0", sizeof(chunk_t)*initial_CF_max_chunks); -} /* end Test_CF_ChunksReset_Sets_count_To_0_Keeps_CF_max_chunks_AndMemsets_chunks_ToAll_0 */ + "The chunks, %lu bytes (sizeof(chunk_t)*chunks->CF_max_chunks), were all set to 0", + sizeof(chunk_t)*initial_CF_max_chunks); +} /* end Test_CF_ChunksReset_Set_count_To_0_Keeps_CF_max_chunks_AndMemsets_chunks_ToAll_0 */ /* CF_ChunksReset tests */ /******************************************************************************* ** -** CF_Chunks_ComputeGaps tests (large) - Full coverage - TODO: This is not a great example of good unit testing. In the quest for speed and full coverage, liberties with values were taken to find ones that achieved the desired coverage in the CUT. Values should be more robust and be more indicative of the kind of values that will actually be encountered during operation. Not enough time could be spent on deciphering intent and the creator of that intent is no longer available. +** CF_Chunks_ComputeGaps tests (large) - Full coverage - NOTE: This is not a great example of good unit testing. In the quest for speed and full coverage, liberties with values were taken to find ones that achieved the desired coverage in the CUT. Values should be more robust and be more indicative of the kind of values that will actually be encountered during operation. Not enough time could be spent on deciphering intent and the creator of that intent is no longer available. ** *******************************************************************************/ void Test_CF_Chunks_ComputeGaps_AssertsBecauseGiven_total_Is_0(void) { - /* Arrange */ - chunks_t dummy_chunks; - chunks_t* arg_chunks = &dummy_chunks; - index_t arg_max_gaps = Any_uint32(); - chunk_size_t arg_total = 0; - chunk_offset_t arg_start = Any_uint32(); - compute_gap_fn_t arg_compute_gap_fn = Dummy_compute_gap_fn_t; - void* arg_opaque = ut_default_ptr; + // /* Arrange */ + // chunks_t dummy_chunks; + // chunks_t* arg_chunks = &dummy_chunks; + // index_t arg_max_gaps = Any_uint32(); + // chunk_size_t arg_total = 0; + // chunk_offset_t arg_start = Any_uint32(); + // compute_gap_fn_t arg_compute_gap_fn = Dummy_compute_gap_fn_t; + // void* arg_opaque = NULL; - /* Act */ + // /* Act */ // CF_Chunks_ComputeGaps(arg_chunks, arg_max_gaps, arg_total, arg_start, arg_compute_gap_fn, arg_opaque); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); } /* end Test_CF_Chunks_ComputeGaps_AssertsBecauseGiven_total_Is_0 */ void Test_CF_Chunks_ComputeGaps_AssertsBecauseGiven_start_IsGreaterThanGiven_total(void) { - /* Arrange */ - chunks_t dummy_chunks; - chunks_t* arg_chunks = &dummy_chunks; - index_t arg_max_gaps = Any_uint32(); - chunk_size_t arg_total = Any_uint32_Except(UINT32_MAX - 1) + 1; /* from 1 to (UINT32_MAX - 1) */ - chunk_offset_t arg_start = Any_uint32_GreaterThan(arg_total); - compute_gap_fn_t arg_compute_gap_fn = Dummy_compute_gap_fn_t; - void* arg_opaque = ut_default_ptr; + // /* Arrange */ + // chunks_t dummy_chunks; + // chunks_t* arg_chunks = &dummy_chunks; + // index_t arg_max_gaps = Any_uint32(); + // chunk_size_t arg_total = Any_uint32_Except(UINT32_MAX - 1) + 1; /* from 1 to (UINT32_MAX - 1) */ + // chunk_offset_t arg_start = Any_uint32_GreaterThan(arg_total); + // compute_gap_fn_t arg_compute_gap_fn = Dummy_compute_gap_fn_t; + // void* arg_opaque = NULL; - /* Act */ + // /* Act */ // CF_Chunks_ComputeGaps(arg_chunks, arg_max_gaps, arg_total, arg_start, arg_compute_gap_fn, arg_opaque); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); } /* end Test_CF_Chunks_ComputeGaps_AssertsBecauseGiven_start_IsGreaterThanGiven_total */ void Test_CF_Chunks_ComputeGaps_AssertsBecauseGiven_start_IsEqToGiven_total(void) { - /* Arrange */ - chunks_t dummy_chunks; - chunks_t* arg_chunks = &dummy_chunks; - index_t arg_max_gaps = Any_uint32(); - chunk_size_t arg_total = Any_uint32_Except(UINT32_MAX) + 1; /* from 1 to UINT32_MAX */ - chunk_offset_t arg_start = arg_total; - compute_gap_fn_t arg_compute_gap_fn = Dummy_compute_gap_fn_t; - void* arg_opaque = ut_default_ptr; + // /* Arrange */ + // chunks_t dummy_chunks; + // chunks_t* arg_chunks = &dummy_chunks; + // index_t arg_max_gaps = Any_uint32(); + // chunk_size_t arg_total = Any_uint32_Except(UINT32_MAX) + 1; /* from 1 to UINT32_MAX */ + // chunk_offset_t arg_start = arg_total; + // compute_gap_fn_t arg_compute_gap_fn = Dummy_compute_gap_fn_t; + // void* arg_opaque = NULL; - /* Act */ + // /* Act */ // CF_Chunks_ComputeGaps(arg_chunks, arg_max_gaps, arg_total, arg_start, arg_compute_gap_fn, arg_opaque); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); } /* end Test_CF_Chunks_ComputeGaps_AssertsBecauseGiven_start_IsGreaterThanGiven_total */ void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_0_And_compute_gap_fn_Is_NULL_And_start_IsOneLessThan_total_Return_1(void) @@ -1984,7 +1957,7 @@ void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_0_And_compute_gap_fn_Is_NU chunk_size_t arg_total = Any_uint32_Except(UINT32_MAX) + 1; /* from 1 to UINT32_MAX */ chunk_offset_t arg_start = arg_total - 1; compute_gap_fn_t arg_compute_gap_fn = NULL; - void* arg_opaque = ut_default_ptr; + void* arg_opaque = NULL; arg_chunks->count = 0; @@ -2005,7 +1978,7 @@ void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_0_And_compute_gap_fn_Is_NU chunk_size_t arg_total = Any_uint32_Except(UINT32_MAX) + 1; /* from 1 to UINT32_MAX */ chunk_offset_t arg_start = Any_uint32_LessThan(arg_total); compute_gap_fn_t arg_compute_gap_fn = NULL; - void* arg_opaque = ut_default_ptr; + void* arg_opaque = NULL; arg_chunks->count = 0; @@ -2026,7 +1999,7 @@ void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_0_And_compute_gap_fn_IsNot chunk_size_t arg_total = Any_uint32_Except(UINT32_MAX) + 1; /* from 1 to UINT32_MAX */ chunk_offset_t arg_start = Any_uint32_LessThan(arg_total); compute_gap_fn_t arg_compute_gap_fn = Dummy_compute_gap_fn_t; - void* arg_opaque = ut_default_ptr; + void* arg_opaque = NULL; Dummy_compute_gap_fn_t_context_t context_Dummy_compute_gap_fn_t; arg_chunks->count = 0; @@ -2038,26 +2011,26 @@ void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_0_And_compute_gap_fn_IsNot /* Assert */ UtAssert_STUB_COUNT(Dummy_compute_gap_fn_t, 1); - UtAssert_ADDRESS_EQ(context_Dummy_compute_gap_fn_t.cs, arg_chunks); + UtAssert_True(context_Dummy_compute_gap_fn_t.cs == arg_chunks, "context_Dummy_compute_gap_fn_t.cs == arg_chunks"); UtPrintf("Stub count check is destroying the memory at context_Dummy_compute_gap_fn_t.c (ha ha, not a filename, 'c' is the variable name)"); - // TODO: values pointed to by contexts are out of scope and this is now an issue because any get stub count is killing access to values set by CUT and given to stubs via pointer (it may actually be in UT_GetStubEntry used by getting the stub count) + // NOTE: values pointed to by contexts are out of scope and this is now an issue because any get stub count is killing access to values set by CUT and given to stubs via pointer (it may actually be in UT_GetStubEntry used by getting the stub count) // UtAssert_UINT32_EQ(context_Dummy_compute_gap_fn_t.c->offset, 0); // UtAssert_UINT32_EQ(context_Dummy_compute_gap_fn_t.c->size, arg_total); - UtAssert_ADDRESS_EQ(context_Dummy_compute_gap_fn_t.opaque, arg_opaque); + UtAssert_True(context_Dummy_compute_gap_fn_t.opaque == arg_opaque, "context_Dummy_compute_gap_fn_t.opaque == arg_opaque"); UtAssert_UINT32_EQ(result, 1); } /* end Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_0_And_compute_gap_fn_IsNot_NULL_Call_compute_gap_fn_ThenReturn_1 */ void Test_CF_Chunks_ComputeGaps_Given_max_gaps_Is_0_Return_0(void) { /* Arrange */ - chunks_t dummy_chunks_chunks[1] = {0}; + chunk_t dummy_chunks_chunks[1] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_max_gaps = 0; chunk_size_t arg_total = Any_uint32_Except(UINT32_MAX) + 1; /* from 1 to UINT32_MAX */ chunk_offset_t arg_start = Any_uint32_LessThan(arg_total); compute_gap_fn_t arg_compute_gap_fn = Dummy_compute_gap_fn_t; - void* arg_opaque = ut_default_ptr; + void* arg_opaque = NULL; Dummy_compute_gap_fn_t_context_t context_Dummy_compute_gap_fn_t; arg_chunks->count = 1; @@ -2079,14 +2052,14 @@ void Test_CF_Chunks_ComputeGaps_Given_max_gaps_Is_0_Return_0(void) void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_gap_start_IsEqTo_total_BreakAndReturn_0(void) { /* Arrange */ - chunks_t dummy_chunks_chunks[1] = {0}; + chunk_t dummy_chunks_chunks[1] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_max_gaps = Any_uint32(); chunk_size_t arg_total = Any_uint32_Except(UINT32_MAX) + 1; /* from 1 to UINT32_MAX */ chunk_offset_t arg_start = Any_uint32_LessThan(arg_total); compute_gap_fn_t arg_compute_gap_fn = Dummy_compute_gap_fn_t; - void* arg_opaque = ut_default_ptr; + void* arg_opaque = NULL; Dummy_compute_gap_fn_t_context_t context_Dummy_compute_gap_fn_t; arg_chunks->count = 1; @@ -2108,14 +2081,14 @@ void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_gap_start_IsEqTo_tot void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_gap_start_IsGreaterThan_total_BreakAndReturn_0(void) { /* Arrange */ - chunks_t dummy_chunks_chunks[1] = {0}; + chunk_t dummy_chunks_chunks[1] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_max_gaps = Any_uint32(); chunk_size_t arg_total = Any_uint32_Except(UINT32_MAX) + 1; /* from 1 to UINT32_MAX */ chunk_offset_t arg_start = Any_uint32_LessThan(arg_total); compute_gap_fn_t arg_compute_gap_fn = Dummy_compute_gap_fn_t; - void* arg_opaque = ut_default_ptr; + void* arg_opaque = NULL; chunk_offset_t dummy_gap_start = Any_uint32_GreaterThan(arg_total); Dummy_compute_gap_fn_t_context_t context_Dummy_compute_gap_fn_t; @@ -2137,14 +2110,14 @@ void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_gap_start_IsGreaterT void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_gap_start_IsLessThan_total_And_compute_gap_fn_Is_NULL_Return_1(void) { /* Arrange */ - chunks_t dummy_chunks_chunks[1] = {0}; + chunk_t dummy_chunks_chunks[1] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_max_gaps = UINT32_MAX; /* UINT32_MAX used to show this will not come into play for this test */ chunk_size_t arg_total; chunk_offset_t arg_start = 0; compute_gap_fn_t arg_compute_gap_fn = Dummy_compute_gap_fn_t; - void* arg_opaque = ut_default_ptr; + void* arg_opaque = NULL; Dummy_compute_gap_fn_t_context_t context_Dummy_compute_gap_fn_t; arg_chunks->count = 1; @@ -2168,14 +2141,14 @@ void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_gap_start_IsLessThan void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_c_offset_Plus_c_size_IsEqToStart_And_compute_gap_fn_Is_NULL_Return_1(void) { /* Arrange */ - chunks_t dummy_chunks_chunks[1] = {0}; + chunk_t dummy_chunks_chunks[1] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_max_gaps = UINT32_MAX; /* UINT32_MAX used to show this will not come into play for this test */ chunk_size_t arg_total; chunk_offset_t arg_start; compute_gap_fn_t arg_compute_gap_fn = Dummy_compute_gap_fn_t; - void* arg_opaque = ut_default_ptr; + void* arg_opaque = NULL; Dummy_compute_gap_fn_t_context_t context_Dummy_compute_gap_fn_t; arg_chunks->count = 1; @@ -2201,14 +2174,14 @@ void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_c_offset_Plus_c_size void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_c_offset_Plus_c_size_IsLessThanStart_And_started_Is_0_ButNextLoop_started_Is_1_And_compute_gap_fn_Is_NULL_Return_1(void) { /* Arrange */ - chunks_t dummy_chunks_chunks[2] = {0, 0}; + chunk_t dummy_chunks_chunks[2] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_max_gaps = UINT32_MAX; /* UINT32_MAX used to show this will not come into play for this test */ chunk_size_t arg_total; chunk_offset_t arg_start; compute_gap_fn_t arg_compute_gap_fn = NULL; - void* arg_opaque = ut_default_ptr; + void* arg_opaque = NULL; Dummy_compute_gap_fn_t_context_t context_Dummy_compute_gap_fn_t; arg_chunks->count = 2; @@ -2236,14 +2209,14 @@ void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_c_offset_Plus_c_size void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_c_offset_Plus_c_size_IsLessThanStart_And_started_Is_0_ButASubsequentLoop_started_Is_1_And_compute_gap_fn_Is_NULL_ReturnNumberOfLoops(void) { /* Arrange */ - chunks_t dummy_chunks_chunks[3] = {0, 0, 0}; + chunk_t dummy_chunks_chunks[3] = { {0} }; chunks_t dummy_chunks; chunks_t* arg_chunks = &dummy_chunks; index_t arg_max_gaps = UINT32_MAX; /* UINT32_MAX used to show this will not come into play for this test */ chunk_size_t arg_total; chunk_offset_t arg_start; compute_gap_fn_t arg_compute_gap_fn = NULL; - void* arg_opaque = ut_default_ptr; + void* arg_opaque = NULL; Dummy_compute_gap_fn_t_context_t context_Dummy_compute_gap_fn_t; arg_chunks->count = 3; @@ -2274,9 +2247,9 @@ void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_c_offset_Plus_c_size /******************************************************************************* ** -** Test Add functions +** cf_chunk_tests UtTest_Add groups ** -** TODO: Tests commented out are edge case CF_Assert fail tests that are not +** NOTE: Tests commented out are edge case CF_Assert fail tests that are not ** required to mark the fail because there is another test doing that. ** These tests should be used if the CF_Assert issue is solved. ** @@ -2284,15 +2257,15 @@ void Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_c_offset_Plus_c_size void add_macro_tests(void) { - UtTest_Add(Test_MAX_Returns_a_WhenItIsMaxValue, + UtTest_Add(Test_MAX_WhenItIsMaxValue_Return_a, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_MAX_Returns_a_WhenItIsMaxValue"); - UtTest_Add(Test_MAX_Returns_b_WhenItIsMaxValue, + "Test_MAX_WhenItIsMaxValue_Return_a"); + UtTest_Add(Test_MAX_WhenItIsMaxValue_Return_b, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_MAX_Returns_b_WhenItIsMaxValue"); - UtTest_Add(Test_MAX_Returns_a_WhenItIsEqualTo_b, + "Test_MAX_WhenItIsMaxValue_Return_b"); + UtTest_Add(Test_MAX_WhenItIsEqualTo_b_Returns_a, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_MAX_Returns_a_WhenItIsEqualTo_b"); + "Test_MAX_WhenItIsEqualTo_b_Returns_a"); } /* end add_macro_tests */ void add_CF_Chunks_EraseRange_tests(void) @@ -2303,28 +2276,28 @@ void add_CF_Chunks_EraseRange_tests(void) // UtTest_Add(Test_CF_Chunks_EraseRange_AssertsBecause_end_EqTo_start, // cf_chunk_tests_Setup, cf_chunk_tests_Teardown, // "Test_CF_Chunks_EraseRange_AssertsBecause_end_EqTo_start"); - UtTest_Add(Test_CF_Chunks_EraseRange_When_start_Is_OneMoreThan_end_MovesOneChunk, + UtTest_Add(Test_CF_Chunks_When_start_Is_OneMoreThan_end_MovesOneChunk_EraseRange, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_EraseRange_When_start_Is_OneMoreThan_end_MovesOneChunk"); - UtTest_Add(Test_CF_Chunks_EraseRange_When_start_IsLessThan_chunks_count_DoesNotChangeStart, + "Test_CF_Chunks_When_start_Is_OneMoreThan_end_MovesOneChunk_EraseRange"); + UtTest_Add(Test_CF_Chunks_When_start_IsLessThan_chunks_count_DoesNotChangeStart_EraseRange, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_EraseRange_When_start_IsLessThan_chunks_count_DoesNotChangeStart"); + "Test_CF_Chunks_When_start_IsLessThan_chunks_count_DoesNotChangeStart_EraseRange"); } /* end add_CF_Chunks_EraseRange_tests */ void add_CF_Chunks_EraseChunk_tests(void) { - UtTest_Add(Test_CF_Chunks_EraseChunk_FailsAssert_Given_chunks_count_IsEqTo_0, + UtTest_Add(Test_CF_Chunks_EraseChunk_AssertsBecause_Given_chunks_count_IsEqTo_0, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_EraseChunk_FailsAssert_Given_chunks_count_IsEqTo_0"); - UtTest_Add(Test_CF_Chunks_EraseChunk_FailsAssert_Given_erase_index_IsEqTo_chunks_count, + "Test_CF_Chunks_EraseChunk_AssertsBecause_Given_chunks_count_IsEqTo_0"); + UtTest_Add(Test_CF_Chunks_EraseChunk_AssertsBecause_Given_erase_index_IsEqTo_chunks_count, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_EraseChunk_FailsAssert_Given_erase_index_IsEqTo_chunks_count"); - UtTest_Add(Test_CF_Chunks_EraseChunk_ErasesOneChunkWhenThereIsOnlyOneAndDecrements_count_To_0, + "Test_CF_Chunks_EraseChunk_AssertsBecause_Given_erase_index_IsEqTo_chunks_count"); + UtTest_Add(Test_CF_Chunks_EraseChunk_WhenThereIsOnlyOneEraseOneChunkAndDecrement_count_To_0, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_EraseChunk_ErasesOneChunkWhenThereIsOnlyOneAndDecrements_count_To_0"); - UtTest_Add(Test_CF_Chunks_EraseChunk_ErasesOneChunkThatIsNotTheLastFrom_chunks_AndDecrements_count, + "Test_CF_Chunks_EraseChunk_WhenThereIsOnlyOneEraseOneChunkAndDecrement_count_To_0"); + UtTest_Add(Test_CF_Chunks_EraseChunk_EraseOneChunkThatIsNotTheLastFrom_chunks_AndDecrement_count, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_EraseChunk_ErasesOneChunkThatIsNotTheLastFrom_chunks_AndDecrements_count"); + "Test_CF_Chunks_EraseChunk_EraseOneChunkThatIsNotTheLastFrom_chunks_AndDecrement_count"); UtTest_Add(Test_CF_Chunks_EraseChunk_ErasesLastChunkFrom_chunks_AndDecrements_count, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, "Test_CF_Chunks_EraseChunk_ErasesLastChunkFrom_chunks_AndDecrements_count"); @@ -2332,50 +2305,48 @@ void add_CF_Chunks_EraseChunk_tests(void) void add_CF_Chunks_InsertChunk_tests(void) { - UtTest_Add(Test_CF_Chunks_InsertChunk_FailsAssert_Given_chunks_count_IsEqTo_chunks_CF_max_chunks, + UtTest_Add(Test_CF_Chunks_InsertChunk_AssertsBecause_Given_chunks_count_IsEqTo_chunks_CF_max_chunks, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_InsertChunk_FailsAssert_Given_chunks_count_IsEqTo_chunks_CF_max_chunks"); - // UtTest_Add(Test_CF_Chunks_InsertChunk_FailsAssert_Given_chunks_count_IsGreaterThan_chunks_CF_max_chunks, + "Test_CF_Chunks_InsertChunk_AssertsBecause_Given_chunks_count_IsEqTo_chunks_CF_max_chunks"); + // UtTest_Add(Test_CF_Chunks_InsertChunk_AssertsBecause_Given_chunks_count_IsGreaterThan_chunks_CF_max_chunks, // cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - // "Test_CF_Chunks_InsertChunk_FailsAssert_Given_chunks_count_IsGreaterThan_chunks_CF_max_chunks"); - UtTest_Add(Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoEmpty_chunks, + // "Test_CF_Chunks_InsertChunk_AssertsBecause_Given_chunks_count_IsGreaterThan_chunks_CF_max_chunks"); + UtTest_Add(Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoEmpty_chunks, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoEmpty_chunks"); - UtTest_Add(Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoStartOfSingle_chunks, + "Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoEmpty_chunks"); + UtTest_Add(Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoStartOfSingle_chunks, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoStartOfSingle_chunks"); - UtTest_Add(Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoEndOfSingle_chunks, + "Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoStartOfSingle_chunks"); + UtTest_Add(Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoEndOfSingle_chunks, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoEndOfSingle_chunks"); - UtTest_Add(Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoSome_chunks, + "Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoEndOfSingle_chunks"); + UtTest_Add(Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoSome_chunks, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_InsertChunk_PutsGiven_chunk_IntoSome_chunks"); + "Test_CF_Chunks_InsertChunk_PutGiven_chunk_IntoSome_chunks"); } /* end add_CF_Chunks_InsertChunk_tests */ void add_CF_Chunks_FindInsertPosition_tests(void) { - UtTest_Add(Test_CF_Chunks_FindInsertPosition_Given_chunks_IsEmptyReturns_0, + UtTest_Add(Test_CF_Chunks_FindInsertPosition_Given_chunks_IsEmptyReturn_0, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_FindInsertPosition_Given_chunks_IsEmptyReturns_0"); - UtTest_Add(Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_LessThanItemOffsetReturns_0, + "Test_CF_Chunks_FindInsertPosition_Given_chunks_IsEmptyReturn_0"); + UtTest_Add(Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_LessThanItemOffsetReturn_0, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_LessThanItemOffsetReturns_0"); - UtTest_Add(Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_EqToItemOffsetReturns_0, + "Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_LessThanItemOffsetReturn_0"); + UtTest_Add(Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_EqToItemOffsetReturn_0, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_EqToItemOffsetReturns_0"); - UtTest_Add(Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_GreaterThanOffsetReturns_1, + "Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_EqToItemOffsetReturn_0"); + UtTest_Add(Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_GreaterThanOffsetReturn_1, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_GreaterThanOffsetReturns_1"); - UtTest_Add(Test_CF_Chunks_FindInsertPosition_Given_chunks_HasTwoItemsAndGiven_chunk_offset_IsInBetweenTheirOffsetsReturns_1, + "Test_CF_Chunks_FindInsertPosition_Given_chunks_HasOneItemAndGiven_chunk_offset_GreaterThanOffsetReturn_1"); + UtTest_Add(Test_CF_Chunks_FindInsertPosition_Given_chunks_HasTwoItemsAndGiven_chunk_offset_IsInBetweenTheirOffsetsReturn_1, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_FindInsertPosition_Given_chunks_HasTwoItemsAndGiven_chunk_offset_IsInBetweenTheirOffsetsReturns_1"); - UtTest_Add(Test_CF_Chunks_FindInsertPosition_Given_chunks_HasAnyItemsAndReturnsCorrectExpectedPosition, + "Test_CF_Chunks_FindInsertPosition_Given_chunks_HasTwoItemsAndGiven_chunk_offset_IsInBetweenTheirOffsetsReturn_1"); + UtTest_Add(Test_CF_Chunks_FindInsertPosition_Given_chunks_HasAnyItemsAndReturnCorrectExpectedPosition, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_FindInsertPosition_Given_chunks_HasAnyItemsAndReturnsCorrectExpectedPosition"); + "Test_CF_Chunks_FindInsertPosition_Given_chunks_HasAnyItemsAndReturnCorrectExpectedPosition"); } /* end add_CF_Chunks_FindInsertPosition_tests */ - - void add_CF_Chunks_CombinePrevious_tests(void) { UtTest_Add(Test_CF_Chunks_CombinePrevious_Asserts_i_GivenIsEqTo_chunks_CF_max_Chunks, @@ -2412,34 +2383,34 @@ void add_CF_Chunks_CombinePrevious_tests(void) void add_CF_Chunks_CombineNext_tests(void) { - UtTest_Add(Test_CF_Chunks_CombineNext_Given_i_IsEqTo_Given_chunks_count_Returns_0, + UtTest_Add(Test_CF_Chunks_CombineNext_Given_i_IsEqTo_Given_chunks_count_Return_0, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_CombineNext_Given_i_IsEqTo_Given_chunks_count_Returns_0"); + "Test_CF_Chunks_CombineNext_Given_i_IsEqTo_Given_chunks_count_Return_0"); UtTest_Add(Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_AssertsBecauseGiven_chunk_end_LessThanGiven_chunk_offset, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, "Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_AssertsBecauseGiven_chunk_end_LessThanGiven_chunk_offset"); - UtTest_Add(Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_Given_chunks_chunks_i_offset_IsGreaterThan_chunk_end_Returns_0, + UtTest_Add(Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_Given_chunks_chunks_i_offset_IsGreaterThan_chunk_end_Return_0, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_Given_chunks_chunks_i_offset_IsGreaterThan_chunk_end_Returns_0"); - UtTest_Add(Test_CF_Chunks_CombineNext_Given_chunks_chunks_offset_IsLessThan_chunk_end_CombinesChunksNotAtEndDoesNotEraseRangeReturns_1, + "Test_CF_Chunks_CombineNext_Given_i_IsNotEqTo_Given_chunks_count_Given_chunks_chunks_i_offset_IsGreaterThan_chunk_end_Return_0"); + UtTest_Add(Test_CF_Chunks_CombineNext_Given_chunks_chunks_offset_IsLessThan_chunk_end_CombinesChunksNotAtEndDoesNotEraseRangeReturn_1, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_CombineNext_Given_chunks_chunks_offset_IsLessThan_chunk_end_CombinesChunksNotAtEndDoesNotEraseRangeReturns_1"); - UtTest_Add(Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_BreaksBReplacesEverythingUntilEndAndCalls_CF_Chunks_EraseRange_ThenReturns_1, + "Test_CF_Chunks_CombineNext_Given_chunks_chunks_offset_IsLessThan_chunk_end_CombinesChunksNotAtEndDoesNotEraseRangeReturn_1"); + UtTest_Add(Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_BreaksBReplaceEverythingUntilEndAndCall_CF_Chunks_EraseRange_ThenReturn_1, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_BreaksBReplacesEverythingUntilEndAndCalls_CF_Chunks_EraseRange_ThenReturns_1"); - UtTest_Add(Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_ReplacesEverythingUntilEndAndCalls_CF_Chunks_EraseRange_ThenReturns_1, + "Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_BreaksBReplaceEverythingUntilEndAndCall_CF_Chunks_EraseRange_ThenReturn_1"); + UtTest_Add(Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_ReplaceEverythingUntilEndAndCall_CF_Chunks_EraseRange_ThenReturn_1, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_ReplacesEverythingUntilEndAndCalls_CF_Chunks_EraseRange_ThenReturns_1"); + "Test_CF_Chunks_CombineNext_Given_i_IsEqToGiven_chunks_count_ReplaceEverythingUntilEndAndCall_CF_Chunks_EraseRange_ThenReturn_1"); } /* end add_CF_Chunks_CombineNext_tests */ void add_CF_Chunks_FindSmallestSize_tests(void) { - UtTest_Add(Test_CF_Chunks_FindSmallestSize_Given_chunks_IsEmptyReturns_0, + UtTest_Add(Test_CF_Chunks_FindSmallestSize_Given_chunks_IsEmptyReturn_0, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_FindSmallestSize_Given_chunks_IsEmptyReturns_0"); - UtTest_Add(Test_CF_Chunks_FindSmallestSize_Given_chunks_HasOneChunkReturns_0, + "Test_CF_Chunks_FindSmallestSize_Given_chunks_IsEmptyReturn_0"); + UtTest_Add(Test_CF_Chunks_FindSmallestSize_Given_chunks_HasOneChunkReturn_0, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_FindSmallestSize_Given_chunks_HasOneChunkReturns_0"); + "Test_CF_Chunks_FindSmallestSize_Given_chunks_HasOneChunkReturn_0"); UtTest_Add(Test_CF_Chunks_FindSmallestSize_Given_chunks_HasTwoChunksReturnsCorrectIndexOfSmallest, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, "Test_CF_Chunks_FindSmallestSize_Given_chunks_HasTwoChunksReturnsCorrectIndexOfSmallest"); @@ -2478,38 +2449,38 @@ void add_CF_Chunks_Add_tests(void) UtTest_Add(Test_CF_Chunks_Add_Asserts_WhenInsertPositionIsNotEqualToGiven_chunks_count_And_chunk_offset_IsNotLessThanOrEqToGiven_chunks_i_offset, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, "Test_CF_Chunks_Add_Asserts_WhenInsertPositionIsNotEqualToGiven_chunks_count_And_chunk_offset_IsNotLessThanOrEqToGiven_chunks_i_offset"); - UtTest_Add(Test_CF_Chunks_Add_Calls_CF_Chunks_Insert_WhenNotAtEnd, + UtTest_Add(Test_CF_Chunks_Add_WhenNotAtEndCall_CF_Chunks_Insert, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_Add_Calls_CF_Chunks_Insert_WhenNotAtEnd"); - UtTest_Add(Test_CF_Chunks_Add_Calls_CF_Chunks_Insert_WhenAtEnd, + "Test_CF_Chunks_Add_WhenNotAtEndCall_CF_Chunks_Insert"); + UtTest_Add(Test_CF_Chunks_Add_WhenAtEndCall_CF_Chunks_Insert, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_Add_Calls_CF_Chunks_Insert_WhenAtEnd"); + "Test_CF_Chunks_Add_WhenAtEndCall_CF_Chunks_Insert"); } /* end add_CF_Chunks_Add_tests */ void add_CF_Chunks_RemoveFromFirst_tests(void) { - UtTest_Add(Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsEqToGiven_size_Calls_CF_Chunks_EraseChunk, + UtTest_Add(Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsEqToGiven_size_Call_CF_Chunks_EraseChunk, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsEqToGiven_size_Calls_CF_Chunks_EraseChunk"); - UtTest_Add(Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsSmallerThanGiven_size_Calls_CF_Chunks_EraseChunk, + "Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsEqToGiven_size_Call_CF_Chunks_EraseChunk"); + UtTest_Add(Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsSmallerThanGiven_size_Call_CF_Chunks_EraseChunk, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsSmallerThanGiven_size_Calls_CF_Chunks_EraseChunk"); - UtTest_Add(Test_CF_Chunks_RemoveFromFirst_When_chunks_size_IsGreaterThanGiven_size_AddsGiven_size_To_chunks_chunks_0_offset_AndSets_chunks_chunks_size_To_0, + "Test_CF_Chunks_RemoveFromFirst_When_chunks_HasOnlyOneChunkAndIts_size_IsSmallerThanGiven_size_Call_CF_Chunks_EraseChunk"); + UtTest_Add(Test_CF_Chunks_RemoveFromFirst_When_chunks_size_IsGreaterThanGiven_size_AddGiven_size_To_chunks_chunks_0_offset_AndSet_chunks_chunks_size_To_0, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_RemoveFromFirst_When_chunks_size_IsGreaterThanGiven_size_AddsGiven_size_To_chunks_chunks_0_offset_AndSets_chunks_chunks_size_To_0"); + "Test_CF_Chunks_RemoveFromFirst_When_chunks_size_IsGreaterThanGiven_size_AddGiven_size_To_chunks_chunks_0_offset_AndSet_chunks_chunks_size_To_0"); } /* end add_CF_Chunks_RemoveFromFirst_tests */ void add_CF_Chunks_GetFirstChunk_tests(void) { - UtTest_Add(Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_0_Returns_NULL, + UtTest_Add(Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_0_Return_NULL, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_0_Returns_NULL"); - UtTest_Add(Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_1_ReturnsOnlyChunk, + "Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_0_Return_NULL"); + UtTest_Add(Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_1_ReturnOnlyChunk, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_1_ReturnsOnlyChunk"); - UtTest_Add(Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_Any_index_tReturnsFirstChunk, + "Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_1_ReturnOnlyChunk"); + UtTest_Add(Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_Any_index_t_ReturnFirstChunk, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_Any_index_tReturnsFirstChunk"); + "Test_CF_Chunks_GetFirstChunk_WhenGiven_chunks_count_Is_Any_index_t_ReturnFirstChunk"); } /* end add_CF_Chunks_GetFirstChunk_tests */ void add_CF_Chunks_Init_tests(void) @@ -2517,16 +2488,16 @@ void add_CF_Chunks_Init_tests(void) UtTest_Add(Test_CF_Chunks_Init_AssertsBecauseGiven_CF_max_chunks_Is_0, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, "Test_CF_Chunks_Init_AssertsBecauseGiven_CF_max_chunks_Is_0"); - UtTest_Add(Test_CF_Chunks_Init_SetsGiven_chunks_CF_max_chunks_ToGiven_CF_max_chunks, + UtTest_Add(Test_CF_Chunks_Init_SetGiven_chunks_CF_max_chunks_ToGiven_CF_max_chunks, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_Chunks_Init_SetsGiven_chunks_CF_max_chunks_ToGiven_CF_max_chunks"); + "Test_CF_Chunks_Init_SetGiven_chunks_CF_max_chunks_ToGiven_CF_max_chunks"); } /* end add_CF_Chunks_Init_tests */ void add_CF_ChunksReset_tests(void) { - UtTest_Add(Test_CF_ChunksReset_Sets_count_To_0_Keeps_CF_max_chunks_AndMemsets_chunks_ToAll_0, + UtTest_Add(Test_CF_ChunksReset_Set_count_To_0_Keeps_CF_max_chunks_AndMemsets_chunks_ToAll_0, cf_chunk_tests_Setup, cf_chunk_tests_Teardown, - "Test_CF_ChunksReset_Sets_count_To_0_Keeps_CF_max_chunks_AndMemsets_chunks_ToAll_0"); + "Test_CF_ChunksReset_Set_count_To_0_Keeps_CF_max_chunks_AndMemsets_chunks_ToAll_0"); } /* end add_CF_ChunksReset_tests */ void add_CF_Chunks_ComputeGaps_tests(void) @@ -2572,13 +2543,14 @@ void add_CF_Chunks_ComputeGaps_tests(void) "Test_CF_Chunks_ComputeGaps_Given_chunks_count_Is_1_And_c_offset_Plus_c_size_IsLessThanStart_And_started_Is_0_ButASubsequentLoop_started_Is_1_And_compute_gap_fn_Is_NULL_ReturnNumberOfLoops"); } /* end add_CF_Chunks_ComputeGaps_tests */ +/* end cf_chunk_tests UtTest_Add groups */ + /******************************************************************************* ** ** cf_chunk_tests UtTest_Setup ** *******************************************************************************/ - void UtTest_Setup(void) { TestUtil_InitializeRandomSeed(); diff --git a/unit-test/cf_clist_tests.c b/unit-test/cf_clist_tests.c index 02e55e88..ab4e8583 100644 --- a/unit-test/cf_clist_tests.c +++ b/unit-test/cf_clist_tests.c @@ -1,15 +1,13 @@ - /* cf testing includes */ -#include "cf_clist.c" #include "cf_test_utils.h" - +#include "cf_clist.c" /******************************************************************************* ** ** cf_clist_tests local utility functions ** *******************************************************************************/ -/* TODO: these copy from local usages may need changed to context */ + int Dummy_clist_fn_t(clist_node node, void*context) { UT_Stub_CopyFromLocal(UT_KEY(Dummy_clist_fn_t), &node, sizeof(node)); @@ -32,12 +30,10 @@ int Hook_clist_fn_t(clist_node node, void*context) /* UT_DEFAULT_IMPL returns uint32 */ return (int) UT_DEFAULT_IMPL(Hook_clist_fn_t); } - typedef struct { clist_node node; void* context; } CF_PACK Dummy_clist_fn_t_context_t; - typedef struct { clist_node node; void* context; @@ -61,15 +57,13 @@ void cf_clist_tests_Teardown(void) /* end cf_clist_tests Setup and Teardown */ - /******************************************************************************* ** ** CF_CList_InitNode tests ** *******************************************************************************/ - -void Test_CF_CList_InitNode_PointsNodeToItselfAsNextAndPrev(void) +void Test_CF_CList_InitNode_PointNodeToItselfAsNextAndPrev(void) { /* Arrange */ clist_node_t test_node; @@ -81,14 +75,10 @@ void Test_CF_CList_InitNode_PointsNodeToItselfAsNextAndPrev(void) CF_CList_InitNode(&test_node); /* Assert */ - UtAssert_True(test_node.prev == &test_node, - "CF_CList_InitNode pointed test_node->prev to %p which is itself %p", - test_node.prev, &test_node); - UtAssert_True(test_node.next == &test_node, - "CF_CList_InitNode pointed test_node->next to %p which is itself %p", - test_node.next, &test_node); + UtAssert_ADDRESS_EQ(test_node.prev, &test_node); + UtAssert_ADDRESS_EQ(test_node.next, &test_node); -} /* Test_CF_CList_InitNode_PointsNodeToItselfAsNextAndPrev */ +} /* Test_CF_CList_InitNode_PointNodeToItselfAsNextAndPrev */ /******************************************************************************* ** @@ -96,39 +86,39 @@ void Test_CF_CList_InitNode_PointsNodeToItselfAsNextAndPrev(void) ** *******************************************************************************/ -void Test_CF_CList_InsertFront_FailsAssertHeadIsNull(void) +void Test_CF_CList_InsertFront_AssertsBecauseHeadIs_NULL(void) { - /* Arrange */ - /* Act */ - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end CF_CList_InsertFront_FailsAssertHeadIsNull */ + // /* Arrange */ + // /* Act */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - head"); +} /* end Test_CF_CList_InsertFront_AssertsBecauseHeadIs_NULL */ -void Test_CF_CList_InsertFront_FailsAssertNodeIsNull(void) +void Test_CF_CList_InsertFront_AssertsBecauseNodeIs_NULL(void) { - /* Arrange */ - /* Act */ - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_InsertFront_FailsAssertNodeIsNull */ + // /* Arrange */ + // /* Act */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert- node"); +} /* end Test_CF_CList_InsertFront_AssertsBecauseNodeIs_NULL */ -void Test_CF_CList_InsertFront_FailsAssertNodeNextDoesNotPointToItself(void) +void Test_CF_CList_InsertFront_AssertsBecauseNodeNextDoesNotPointToItself(void) { - /* Arrange */ - /* Act */ - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_InsertFront_FailsAssertNodeNextDoesNotPointToItself */ + // /* Arrange */ + // /* Act */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - node->next==node"); +} /* end Test_CF_CList_InsertFront_AssertsBecauseNodeNextDoesNotPointToItself */ -void Test_CF_CList_InsertFront_FailsAssertNodePrevDoesNotPointToItself(void) +void Test_CF_CList_InsertFront_AssertsBecauseNodePrevDoesNotPointToItself(void) { - /* Arrange */ - /* Act */ - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_InsertFront_FailsAssertNodePrevDoesNotPointToItself */ + // /* Arrange */ + // /* Act */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - node->prev==node"); +} /* end Test_CF_CList_InsertFront_AssertsBecauseNodePrevDoesNotPointToItself */ -void Test_CF_CList_InsertFront_InsertsNodeIntoEmptyList(void) +void Test_CF_CList_InsertFront_InsertNodeIntoEmptyList(void) { /* Arrange */ clist_node dummy_head = NULL; @@ -143,12 +133,10 @@ void Test_CF_CList_InsertFront_InsertsNodeIntoEmptyList(void) CF_CList_InsertFront(arg_head, arg_node); /* Assert */ - UtAssert_True(*arg_head == arg_node, - "head is now %p and should have been changed to %p (node)", - *arg_head, arg_node); -} /* end CF_CList_InsertFront_InsertsNodeIntoEmptyList */ + UtAssert_ADDRESS_EQ(*arg_head, arg_node); +} /* end CF_CList_InsertFront_InsertNodeIntoEmptyList */ -void Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOther(void) +void Test_CF_CList_InsertFront_WhenHeadIsOnlyNodeAndTheyPointToEachOtherInsertNode(void) { /* Arrange */ clist_node_t dummy_head_node; @@ -167,25 +155,15 @@ void Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOt CF_CList_InsertFront(arg_head, arg_node); /* Assert */ - UtAssert_True(arg_node->prev == &dummy_head_node, - "node->prev is now %p and should have been changed to %p (last)", - arg_node->prev, &dummy_head_node); - UtAssert_True(arg_node->next == &dummy_head_node, - "node->next is now %p and should have been changed to %p (*head before call)", - arg_node->next, &dummy_head_node); - UtAssert_True(dummy_head_node.prev == arg_node, - "original head.prev is now %p and should have been changed to %p (node)", - dummy_head_node.prev, arg_node); - UtAssert_True(dummy_head_node.next == arg_node, - "original head.next is now %p should have been changed to %p (node)", - dummy_head_node.next, arg_node); - UtAssert_True(*arg_head == arg_node, - "head is now %p and should have been changed to %p (node)", - *arg_head, arg_node); - -} /* end Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOther */ - -void Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodes(void) + UtAssert_ADDRESS_EQ(arg_node->prev, &dummy_head_node); + UtAssert_ADDRESS_EQ(arg_node->next, &dummy_head_node); + UtAssert_ADDRESS_EQ(dummy_head_node.prev, arg_node); + UtAssert_ADDRESS_EQ(dummy_head_node.next, arg_node); + UtAssert_ADDRESS_EQ(*arg_head, arg_node); + +} /* end Test_CF_CList_InsertFront_WhenHeadIsOnlyNodeAndTheyPointToEachOtherInsertNode */ + +void Test_CF_CList_InsertFront_WhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodesInsertNode(void) { /* Arrange */ clist_node_t dummy_head_node; @@ -208,31 +186,17 @@ void Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOneOfTwoNodesAndTheyPointToC CF_CList_InsertFront(arg_head, arg_node); /* Assert */ - UtAssert_True(arg_node->prev == &dummy_last_node, - "node->prev is now %p and should have been changed to %p (last)", - arg_node->prev, &dummy_last_node); - UtAssert_True(arg_node->next == &dummy_head_node, - "node->next is now %p and should have been changed to %p (*head before call)", - arg_node->next, &dummy_head_node); - UtAssert_True(dummy_head_node.prev == arg_node, - "original head.prev is now %p and should have been changed to %p (node)", - dummy_head_node.prev, arg_node); - UtAssert_True(dummy_head_node.next == &dummy_last_node, - "original head.next is %p and should not have changed from %p (last)", - dummy_head_node.next, &dummy_last_node); - UtAssert_True(dummy_last_node.prev == &dummy_head_node, - "last.prev is %p and should not have changed from %p (*head before call)", - dummy_head_node.next, &dummy_last_node); - UtAssert_True(dummy_last_node.next == arg_node, - "last.next is %p and should have been change to %p (node)", - dummy_head_node.next, &dummy_last_node); - UtAssert_True(*arg_head == arg_node, - "head is now %p and should have been changed to %p (node)", - *arg_head, arg_node); - -} /* end Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOther */ - -void Test_CF_CList_InsertFront_InsertsNodeWhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodes(void) + UtAssert_ADDRESS_EQ(arg_node->prev, &dummy_last_node); + UtAssert_ADDRESS_EQ(arg_node->next, &dummy_head_node); + UtAssert_ADDRESS_EQ(dummy_head_node.prev, arg_node); + UtAssert_ADDRESS_EQ(dummy_head_node.next, &dummy_last_node); + UtAssert_ADDRESS_EQ(dummy_last_node.prev, &dummy_head_node); + UtAssert_ADDRESS_EQ(dummy_last_node.next, arg_node); + UtAssert_ADDRESS_EQ(*arg_head, arg_node); + +} /* end Test_CF_CList_InsertFront_WhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodesInsertNode */ + +void Test_CF_CList_InsertFront_WhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodesInsertNode(void) { /* Arrange */ clist_node_t dummy_head_node; @@ -280,27 +244,13 @@ void Test_CF_CList_InsertFront_InsertsNodeWhenNodeListIsGreaterThanTwoNodesAndTh CF_CList_InsertFront(arg_head, arg_node); /* Assert */ - UtAssert_True(arg_node->prev == &dummy_last_node, - "node->prev is now %p and should have been changed to %p (last)", - arg_node->prev, &dummy_last_node); - UtAssert_True(arg_node->next == &dummy_head_node, - "node->next is now %p and should have been changed to %p (*head before call)", - arg_node->next, &dummy_head_node); - UtAssert_True(dummy_head_node.prev == arg_node, - "original head.prev is now %p and should have been changed to %p (node)", - dummy_head_node.prev, arg_node); - UtAssert_True(dummy_head_node.next == dummy_second_node, - "original head.next is %p and should not have changed from %p (second)", - dummy_head_node.next, dummy_second_node); - UtAssert_True(dummy_last_node.prev == dummy_next_to_last_node, - "last.prev is %p and should not have changed from %p (next to last)", - dummy_last_node.prev, dummy_next_to_last_node); - UtAssert_True(dummy_last_node.next == arg_node, - "last.next is %p and should have been change to %p (node)", - dummy_last_node.next, arg_node); - UtAssert_True(*arg_head == arg_node, - "head is now %p and should have been changed to %p (node)", - *arg_head, arg_node); + UtAssert_ADDRESS_EQ(arg_node->prev, &dummy_last_node); + UtAssert_ADDRESS_EQ(arg_node->next, &dummy_head_node); + UtAssert_ADDRESS_EQ(dummy_head_node.prev, arg_node); + UtAssert_ADDRESS_EQ(dummy_head_node.next, dummy_second_node); + UtAssert_ADDRESS_EQ(dummy_last_node.prev, dummy_next_to_last_node); + UtAssert_ADDRESS_EQ(dummy_last_node.next, arg_node); + UtAssert_ADDRESS_EQ(*arg_head, arg_node); /* removes all malloc nodes - arg_node head (not malloc) -> next is old head (not malloc) -> next is second node (malloc) */ clist_node free_up_node = arg_node->next->next; @@ -312,7 +262,7 @@ void Test_CF_CList_InsertFront_InsertsNodeWhenNodeListIsGreaterThanTwoNodesAndTh free(old_free_up_node); } -} /* end Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOther */ +} /* end Test_CF_CList_InsertFront_WhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodesInsertNode */ /******************************************************************************* ** @@ -320,39 +270,39 @@ void Test_CF_CList_InsertFront_InsertsNodeWhenNodeListIsGreaterThanTwoNodesAndTh ** *******************************************************************************/ -void Test_CF_CList_InsertBack_FailsAssertHeadIsNull(void) +void Test_CF_CList_InsertBack_AssertsBecauseHeadIs_NULL(void) { /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_InsertBack_FailsAssertHeadIsNull */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - head"); +} /* end Test_CF_CList_InsertBack_AssertsBecauseHeadIs_NULL */ -void Test_CF_CList_InsertBack_FailsAssertNodeIsNull(void) +void Test_CF_CList_InsertBack_AssertsBecauseNodeIs_NULL(void) { /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_InsertBack_FailsAssertNodeIsNull */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - node"); +} /* end Test_CF_CList_InsertBack_AssertsBecauseNodeIs_NULL */ -void Test_CF_CList_InsertBack_FailsAssertNodeNextDoesNotPointToItself(void) +void Test_CF_CList_InsertBack_AssertsBecauseNodeNextDoesNotPointToItself(void) { /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_InsertBack_FailsAssertNodeNextDoesNotPointToItself */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - node->next==node"); +} /* end Test_CF_CList_InsertBack_AssertsBecauseNodeNextDoesNotPointToItself */ -void Test_CF_CList_InsertBack_FailsAssertNodePrevDoesNotPointToItself(void) +void Test_CF_CList_InsertBack_AssertsBecauseNodePrevDoesNotPointToItself(void) { /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_InsertBack_FailsAssertNodePrevDoesNotPointToItself */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - node->prev==node"); +} /* end Test_CF_CList_InsertBack_AssertsBecauseNodePrevDoesNotPointToItself */ -void Test_CF_CList_InsertBack_InsertsNodeIntoEmptyList(void) +void Test_CF_CList_InsertBack_InsertNodeIntoEmptyList(void) { /* Arrange */ clist_node dummy_head = NULL; @@ -367,12 +317,10 @@ void Test_CF_CList_InsertBack_InsertsNodeIntoEmptyList(void) CF_CList_InsertBack(arg_head, arg_node); /* Assert */ - UtAssert_True(*arg_head == arg_node, - "head is now %p and should have been changed to %p (node)", - *arg_head, arg_node); -} /* end CF_CList_InsertFront_InsertsNodeIntoEmptyList */ + UtAssert_ADDRESS_EQ(*arg_head, arg_node); +} /* end Test_CF_CList_InsertBack_InsertNodeIntoEmptyList */ -void Test_CF_CList_InsertBack_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOther(void) +void Test_CF_CList_InsertBack_WhenHeadIsOnlyNodeAndTheyPointToEachOtherInsertNode(void) { /* Arrange */ clist_node_t dummy_head_node; @@ -391,25 +339,15 @@ void Test_CF_CList_InsertBack_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOth CF_CList_InsertBack(arg_head, arg_node); /* Assert */ - UtAssert_True(arg_node->prev == &dummy_head_node, - "node->prev is now %p and should have been changed to %p (last before call)", - arg_node->prev, &dummy_head_node); - UtAssert_True(arg_node->next == &dummy_head_node, - "node->next is now %p and should have been changed to %p (*head)", - arg_node->next, &dummy_head_node); - UtAssert_True(dummy_head_node.prev == arg_node, - "original head.prev is now %p and should have been changed to %p (node)", - dummy_head_node.prev, arg_node); - UtAssert_True(dummy_head_node.next == arg_node, - "original head.next is now %p should have been changed to %p (node)", - dummy_head_node.next, arg_node); - UtAssert_True(*arg_head == dummy_head, - "head is %p and should not have changed from %p (*head)", - *arg_head, dummy_head); - -} /* end Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOther */ - -void Test_CF_CList_InsertBack_InsertsNodeWhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodes(void) + UtAssert_ADDRESS_EQ(arg_node->prev, &dummy_head_node); + UtAssert_ADDRESS_EQ(arg_node->next, &dummy_head_node); + UtAssert_ADDRESS_EQ(dummy_head_node.prev, arg_node); + UtAssert_ADDRESS_EQ(dummy_head_node.next, arg_node); + UtAssert_ADDRESS_EQ(*arg_head, dummy_head); + +} /* end Test_CF_CList_InsertBack_WhenHeadIsOnlyNodeAndTheyPointToEachOtherInsertNode */ + +void Test_CF_CList_InsertBack_WhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodesInsertNode(void) { /* Arrange */ clist_node_t dummy_head_node; @@ -432,31 +370,17 @@ void Test_CF_CList_InsertBack_InsertsNodeWhenHeadIsOneOfTwoNodesAndTheyPointToCo CF_CList_InsertBack(arg_head, arg_node); /* Assert */ - UtAssert_True(arg_node->prev == &dummy_last_node, - "node->prev is now %p and should have been changed to %p (last before call)", - arg_node->prev, &dummy_last_node); - UtAssert_True(arg_node->next == &dummy_head_node, - "node->next is now %p and should have been changed to %p (*head)", - arg_node->next, &dummy_head_node); - UtAssert_True(dummy_head_node.prev == arg_node, - "original head.prev is now %p and should have been changed to %p (node)", - dummy_head_node.prev, arg_node); - UtAssert_True(dummy_head_node.next == &dummy_last_node, - "original head.next is %p and should not have changed from %p (last before call)", - dummy_head_node.next, &dummy_last_node); - UtAssert_True(dummy_last_node.prev == &dummy_head_node, - "last.prev is %p and should not have changed from %p (*head)", - dummy_head_node.next, &dummy_last_node); - UtAssert_True(dummy_last_node.next == arg_node, - "last.next is %p and should have been change to %p (node)", - dummy_head_node.next, &dummy_last_node); - UtAssert_True(*arg_head == dummy_head, - "head is %p and should not have changed from %p (*head)", - *arg_head, dummy_head); - -} /* end Test_CF_CList_InsertBack_InsertsNodeWhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodes */ - -void Test_CF_CList_InsertBack_InsertsNodeWhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodes(void) + UtAssert_ADDRESS_EQ(arg_node->prev, &dummy_last_node); + UtAssert_ADDRESS_EQ(arg_node->next, &dummy_head_node); + UtAssert_ADDRESS_EQ(dummy_head_node.prev, arg_node); + UtAssert_ADDRESS_EQ(dummy_head_node.next, &dummy_last_node); + UtAssert_ADDRESS_EQ(dummy_last_node.prev, &dummy_head_node); + UtAssert_ADDRESS_EQ(dummy_last_node.next, arg_node); + UtAssert_ADDRESS_EQ(*arg_head, dummy_head); + +} /* end Test_CF_CList_InsertBack_WhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodesInsertNode */ + +void Test_CF_CList_InsertBack_WhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodesInsertNode(void) { /* Arrange */ clist_node_t dummy_head_node; @@ -504,27 +428,13 @@ void Test_CF_CList_InsertBack_InsertsNodeWhenNodeListIsGreaterThanTwoNodesAndThe CF_CList_InsertBack(arg_head, arg_node); /* Assert */ - UtAssert_True(arg_node->prev == &dummy_last_node, - "node->prev is now %p and should have been changed to %p (last before call)", - arg_node->prev, &dummy_last_node); - UtAssert_True(arg_node->next == &dummy_head_node, - "node->next is now %p and should have been changed to %p (*head)", - arg_node->next, &dummy_head_node); - UtAssert_True(dummy_head_node.prev == arg_node, - "original head.prev is now %p and should have been changed to %p (node)", - dummy_head_node.prev, arg_node); - UtAssert_True(dummy_head_node.next == dummy_second_node, - "original head.next is %p and should not have changed from %p (second)", - dummy_head_node.next, dummy_second_node); - UtAssert_True(dummy_last_node.prev == dummy_next_to_last_node, - "last.prev is %p and should not have changed from %p (next to last)", - dummy_last_node.prev, dummy_next_to_last_node); - UtAssert_True(dummy_last_node.next == arg_node, - "last.next is %p and should have been change to %p (node)", - dummy_last_node.next, arg_node); - UtAssert_True(*arg_head == dummy_head, - "head is %p and should not have changed from %p (*head)", - *arg_head, dummy_head); + UtAssert_ADDRESS_EQ(arg_node->prev, &dummy_last_node); + UtAssert_ADDRESS_EQ(arg_node->next, &dummy_head_node); + UtAssert_ADDRESS_EQ(dummy_head_node.prev, arg_node); + UtAssert_ADDRESS_EQ(dummy_head_node.next, dummy_second_node); + UtAssert_ADDRESS_EQ(dummy_last_node.prev, dummy_next_to_last_node); + UtAssert_ADDRESS_EQ(dummy_last_node.next, arg_node); + UtAssert_ADDRESS_EQ(*arg_head, dummy_head); /* removes all malloc nodes */ clist_node free_up_node = dummy_head->next; @@ -536,7 +446,7 @@ void Test_CF_CList_InsertBack_InsertsNodeWhenNodeListIsGreaterThanTwoNodesAndThe free(old_free_up_node); } -} /* end Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOther */ +} /* end Test_CF_CList_InsertBack_WhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodesInsertNode */ /******************************************************************************* ** @@ -544,15 +454,15 @@ void Test_CF_CList_InsertBack_InsertsNodeWhenNodeListIsGreaterThanTwoNodesAndThe ** *******************************************************************************/ -void Test_CF_CList_Pop_FailsAssert_head_IsNull(void) +void Test_CF_CList_Pop_AssertsBecause_head_Is_NULL(void) { /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_Pop_FailsAssert_head_IsNull */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - head"); +} /* end Test_CF_CList_Pop_AssertsBecause_head_Is_NULL */ -void Test_CF_CList_Pop_SuccessReturnsNullBecauseListIsEmpty(void) +void Test_CF_CList_Pop_WhenListIsEmptySuccessReturn_NULL(void) { /* Arrange */ clist_node dummy_head = NULL; @@ -563,12 +473,10 @@ void Test_CF_CList_Pop_SuccessReturnsNullBecauseListIsEmpty(void) local_result = CF_CList_Pop(arg_head); /* Assert */ - UtAssert_True(local_result == NULL, - "CF_CList_Pop returned %p and should be %p (NULL, list was empty)", - local_result, NULL); -} /* end Test_CF_CList_Pop_SuccessReturnsNullBecauseListIsEmpty */ + UtAssert_ADDRESS_EQ(local_result, NULL); +} /* end Test_CF_CList_Pop_WhenListIsEmptySuccessReturn_NULL */ -void Test_CF_CList_Pop_SuccessPopsHeadNodeAndReturns_head_WhenItIsOnlyNode(void) +void Test_CF_CList_Pop_WhenItIsOnlyNodePopHeadNodeAndReturn_head_(void) { /* Arrange */ clist_node_t dummy_head_node; @@ -584,12 +492,10 @@ void Test_CF_CList_Pop_SuccessPopsHeadNodeAndReturns_head_WhenItIsOnlyNode(void) local_result = CF_CList_Pop(arg_head); /* Assert */ - UtAssert_True(local_result == &dummy_head_node, - "CF_CList_Pop returned %p and should be %p (head)", - local_result, &dummy_head_node); -} /* end Test_CF_CList_Pop_SuccessPopsHeadNodeAndReturns_head_WhenItIsOnlyNode */ + UtAssert_ADDRESS_EQ(local_result, &dummy_head_node); +} /* end Test_CF_CList_Pop_WhenItIsOnlyNodePopHeadNodeAndReturn_head_ */ -void Test_CF_CList_Pop_SuccessPopsHeadNodeAndReturns_head_WhenListIsAnySizeGreaterThanOne(void) +void Test_CF_CList_Pop_WhenListIsAnySizeGreaterThanOneSuccessPopsHeadNodeAndReturns_head(void) { /* Arrange */ clist_node_t dummy_head_node; @@ -634,9 +540,7 @@ void Test_CF_CList_Pop_SuccessPopsHeadNodeAndReturns_head_WhenListIsAnySizeGreat local_result = CF_CList_Pop(arg_head); /* Assert */ - UtAssert_True(local_result == &dummy_head_node, - "CF_CList_Pop returned %p and should be %p (head)", - local_result, &dummy_head_node); + UtAssert_ADDRESS_EQ(local_result, &dummy_head_node); /* removes all malloc nodes */ clist_node free_up_node = dummy_second_node; @@ -647,7 +551,7 @@ void Test_CF_CList_Pop_SuccessPopsHeadNodeAndReturns_head_WhenListIsAnySizeGreat free_up_node = old_free_up_node->next; free(old_free_up_node); } -} /* end Test_CF_CList_Pop_SuccessPopsHeadNodeAndReturns_head_WhenItIsOnlyNode */ +} /* end Test_CF_CList_Pop_WhenListIsAnySizeGreaterThanOneSuccessPopsHeadNodeAndReturns_head */ /******************************************************************************* ** @@ -655,32 +559,31 @@ void Test_CF_CList_Pop_SuccessPopsHeadNodeAndReturns_head_WhenListIsAnySizeGreat ** *******************************************************************************/ -void Test_CF_CList_Remove_FailsAssertHeadPointedAtValueIsNull(void) +void Test_CF_CList_Remove_AssertsBecauseHeadIs_NULL(void) { /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_Remove_FailsAssertHeadPointedAtValueIsNull */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - head"); +} /* end Test_CF_CList_Remove_AssertsBecauseHeadIs_NULL */ -void Test_CF_CList_Remove_FailsAssertNodeIsNull(void) +void Test_CF_CList_Remove_AssertsBecauseNodeIs_NULL(void) { /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_Remove_FailsAssertNodeIsNull */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - node"); +} /* end Test_CF_CList_Remove_AssertsBecauseNodeIs_NULL */ -void Test_CF_CList_Remove_FailsAssertHeadIsNull(void) +void Test_CF_CList_Remove_AssertsBecauseHeadPointedAtValueIs_NULL(void) { /* Arrange */ /* Act */ /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_Remove_FailsAssertHeadIsNull */ - + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - *head"); +} /* end Test_CF_CList_Remove_AssertsBecauseHeadPointedAtValueIs_NULL */ -void Test_CF_ClistRemove_FailsAssertHeadPointedAtValueIsNotNode(void) +void Test_CF_ClistRemove_AssertsBecauseHeadPointedAtValueIsNotNode(void) { /* Arrange */ clist_node_t dummy_node; @@ -693,11 +596,10 @@ void Test_CF_ClistRemove_FailsAssertHeadPointedAtValueIsNotNode(void) //CF_CList_Remove(arg_head, arg_node); /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_ClistRemove_FailsAssertHeadPointedAtValueIsNotNode */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - node==*head"); +} /* end Test_CF_ClistRemove_AssertsBecauseHeadPointedAtValueIsNotNode */ - -void Test_CF_ClistRemove_SetsHeadToNullWhenOnlyNode(void) +void Test_CF_ClistRemove_WhenOnlyNodeSetHeadTo_NULL(void) { /* Arrange */ clist_node_t dummy_node; @@ -711,19 +613,13 @@ void Test_CF_ClistRemove_SetsHeadToNullWhenOnlyNode(void) CF_CList_Remove(arg_head, arg_node); /* Assert */ - UtAssert_True(*arg_head == NULL, - "*head is %p and should be %p (NULL)", - *arg_head, NULL); + UtAssert_ADDRESS_EQ(*arg_head, NULL); /* Assert for CF_CList_InitNode - note this cannot be verified because node state does not change */ - UtAssert_True(dummy_node.prev == &dummy_node, - "CF_CList_InitNode set node->prev to %p and should be %p (node before call)", - dummy_node.prev, &dummy_node); - UtAssert_True(dummy_node.next == &dummy_node, - "CF_CList_InitNode set node->next to %p and should be %p (node before call)", - dummy_node.next, &dummy_node); -} /* end Test_CF_ClistRemove_SetsHeadToNullWhenOnlyNode */ - -void Test_CF_ClistRemove_SetsHeadToPointToItselWhenOnlyTwoNodesAndLastIsRemoved(void) + UtAssert_ADDRESS_EQ(dummy_node.prev, &dummy_node); + UtAssert_ADDRESS_EQ(dummy_node.next, &dummy_node); +} /* end Test_CF_ClistRemove_WhenOnlyNodeSetHeadTo_NULL */ + +void Test_CF_ClistRemove_WhenOnlyTwoNodesAndLastIsRemovedSetHeadToPointToItself(void) { /* Arrange */ clist_node_t dummy_head_node; @@ -742,25 +638,15 @@ void Test_CF_ClistRemove_SetsHeadToPointToItselWhenOnlyTwoNodesAndLastIsRemoved( CF_CList_Remove(arg_head, arg_node); /* Assert */ - UtAssert_True(*arg_head == &dummy_head_node, - "*head is %p and should be %p (head)", - *arg_head, &dummy_head_node); - UtAssert_True(dummy_head->prev == dummy_head, - "CF_CList_InitNode set head->prev to %p and should be %p (head)", - dummy_head->prev, dummy_head); - UtAssert_True(dummy_head->next == dummy_head, - "CF_CList_InitNode set head->next to %p and should be %p (head)", - dummy_head->next, dummy_head); + UtAssert_ADDRESS_EQ(*arg_head, &dummy_head_node); + UtAssert_ADDRESS_EQ(dummy_head->prev, dummy_head); + UtAssert_ADDRESS_EQ(dummy_head->next, dummy_head); /* Assert for CF_CList_InitNode - note this cannot be verified because node state does not change */ - UtAssert_True(arg_node->prev == arg_node, - "CF_CList_InitNode set node->prev to %p and should be %p (node)", - arg_node->prev, arg_node); - UtAssert_True(arg_node->next == arg_node, - "CF_CList_InitNode set node->next to %p and should be %p (node)", - arg_node->next, arg_node); -} /* end Test_CF_ClistRemove_SetsHeadToPointToItselWhenOnlyTwoNodesAndLastIsRemoved */ - -void Test_CF_ClistRemove_RemovingHeadSetsSecondNodeToHeadAndUpdatesLastNode(void) + UtAssert_ADDRESS_EQ(arg_node->prev, arg_node); + UtAssert_ADDRESS_EQ(arg_node->next, arg_node); +} /* end Test_CF_ClistRemove_WhenOnlyTwoNodesAndLastIsRemovedSetHeadToPointToItself */ + +void Test_CF_ClistRemove_RemovingHeadSetSecondNodeToHeadAndUpdateLastNode(void) { /* Arrange */ clist_node_t dummy_head_node; @@ -804,22 +690,12 @@ void Test_CF_ClistRemove_RemovingHeadSetsSecondNodeToHeadAndUpdatesLastNode(void CF_CList_Remove(arg_head, arg_node); /* Assert */ - UtAssert_True(*arg_head == dummy_second_node, - "*head is %p and should be %p (second node)", - *arg_head, dummy_second_node); - UtAssert_True((*arg_head)->prev == &dummy_last_node, - "*head->prev is %p and should have been changed to %p (last node)", - (*arg_head)->prev, &dummy_last_node); - UtAssert_True(dummy_last_node.next == dummy_second_node, - "last.next is %p and should have been changed to %p (second node)", - *arg_head, dummy_second_node); + UtAssert_ADDRESS_EQ(*arg_head, dummy_second_node); + UtAssert_ADDRESS_EQ((*arg_head)->prev, &dummy_last_node); + UtAssert_ADDRESS_EQ(dummy_last_node.next, dummy_second_node); /* Assert for CF_CList_InitNode */ - UtAssert_True(dummy_head_node.prev == &dummy_head_node, - "CF_CList_InitNode set node->prev to %p and should be %p (node before call)", - dummy_head_node.prev, &dummy_head_node); - UtAssert_True(dummy_head_node.next == &dummy_head_node, - "CF_CList_InitNode set node->next to %p and should be %p (node before call)", - dummy_head_node.next, &dummy_head_node); + UtAssert_ADDRESS_EQ(dummy_head_node.prev, &dummy_head_node); + UtAssert_ADDRESS_EQ(dummy_head_node.next, &dummy_head_node); /* removes all malloc nodes */ /* dummy_head is old second node (head removed) which was malloc'd */ @@ -831,9 +707,9 @@ void Test_CF_ClistRemove_RemovingHeadSetsSecondNodeToHeadAndUpdatesLastNode(void free_up_node = old_free_up_node->next; free(old_free_up_node); } -} /* end Test_CF_ClistRemove_RemovingHeadSetsSecondNodeToHeadAndUpdatesLastNode */ +} /* end Test_CF_ClistRemove_RemovingHeadSetSecondNodeToHeadAndUpdateLastNode */ -void Test_CF_ClistRemove_RemovingLastPointsHeadAndNextToLastToEachOther(void) +void Test_CF_ClistRemove_RemovingLastPointHeadAndNextToLastToEachOther(void) { /* Arrange */ clist_node_t dummy_head_node; @@ -877,22 +753,12 @@ void Test_CF_ClistRemove_RemovingLastPointsHeadAndNextToLastToEachOther(void) CF_CList_Remove(arg_head, arg_node); /* Assert */ - UtAssert_True(*arg_head == dummy_head, - "*head is %p and should not have changed from %p (*head before call)", - *arg_head, dummy_head); - UtAssert_True((*arg_head)->prev == dummy_next_to_last_node, - "*head->prev is %p and should have been changed to %p (next to last node)", - (*arg_head)->prev, dummy_next_to_last_node); - UtAssert_True(dummy_next_to_last_node->next == dummy_head, - "new last.next is %p and should have been changed to %p (*head)", - dummy_next_to_last_node->next, dummy_head); + UtAssert_ADDRESS_EQ(*arg_head, dummy_head); + UtAssert_ADDRESS_EQ((*arg_head)->prev, dummy_next_to_last_node); + UtAssert_ADDRESS_EQ(dummy_next_to_last_node->next, dummy_head); /* Assert for CF_CList_InitNode */ - UtAssert_True(dummy_last_node.prev == &dummy_last_node, - "CF_CList_InitNode set node->prev to %p and should be %p (node before call)", - dummy_last_node.prev, &dummy_last_node); - UtAssert_True(dummy_last_node.next == &dummy_last_node, - "CF_CList_InitNode set node->next to %p and should be %p (node before call)", - dummy_last_node.next, &dummy_last_node); + UtAssert_ADDRESS_EQ(dummy_last_node.prev, &dummy_last_node); + UtAssert_ADDRESS_EQ(dummy_last_node.next, &dummy_last_node); /* removes all malloc nodes */ clist_node free_up_node = dummy_head->next; @@ -903,7 +769,7 @@ void Test_CF_ClistRemove_RemovingLastPointsHeadAndNextToLastToEachOther(void) free_up_node = old_free_up_node->next; free(old_free_up_node); } -} /* end Test_CF_ClistRemove_RemovingLastPointsHeadAndNextToLastToEachOther */ +} /* end Test_CF_ClistRemove_RemovingLastPointHeadAndNextToLastToEachOther */ void Test_CF_ClistRemove_RemovingAnyNodeHasNodesPrevAndNextPointToEachOther(void) { @@ -961,22 +827,12 @@ void Test_CF_ClistRemove_RemovingAnyNodeHasNodesPrevAndNextPointToEachOther(void CF_CList_Remove(arg_head, arg_node); /* Assert */ - UtAssert_True(*arg_head == dummy_head, - "*head is %p and should not have changed from %p (*head before call)", - *arg_head, dummy_head); - UtAssert_True(dummy_removed_node_prev->next == dummy_removed_node_next, - "removed node's previous node next is %p and should have been changed to %p (node->next before call)", - dummy_removed_node_prev->next, dummy_removed_node_next); - UtAssert_True(dummy_removed_node_next->prev == dummy_removed_node_prev, - "removed node's next node prev is %p and should have been changed to %p (node->prev before call)", - dummy_removed_node_next->prev, dummy_removed_node_prev); + UtAssert_ADDRESS_EQ(*arg_head, dummy_head); + UtAssert_ADDRESS_EQ(dummy_removed_node_prev->next, dummy_removed_node_next); + UtAssert_ADDRESS_EQ(dummy_removed_node_next->prev, dummy_removed_node_prev); /* Assert for CF_CList_InitNode */ - UtAssert_True(dummy_removed_node->prev == dummy_removed_node, - "CF_CList_InitNode set node->prev to %p and should be %p (node before call)", - dummy_removed_node->prev, dummy_removed_node); - UtAssert_True(dummy_removed_node->next == dummy_removed_node, - "CF_CList_InitNode set node->next to %p and should be %p (node before call)", - dummy_removed_node->next, dummy_removed_node); + UtAssert_ADDRESS_EQ(dummy_removed_node->prev, dummy_removed_node); + UtAssert_ADDRESS_EQ(dummy_removed_node->next, dummy_removed_node); /* removes all malloc nodes */ clist_node free_up_node = dummy_head->next; @@ -990,51 +846,41 @@ void Test_CF_ClistRemove_RemovingAnyNodeHasNodesPrevAndNextPointToEachOther(void free(old_free_up_node); } -} /* end Test_CF_ClistRemove_RemovingLastPointsHeadAndNextToLastToEachOther */ +} /* end Test_CF_ClistRemove_RemovingAnyNodeHasNodesPrevAndNextPointToEachOther */ -/* TODO: Test_CF_CList_Remove_ReceivesBad_node_Because_next_PointsTo_node_But_prev_DoesNot is not curently running because there is doubt that a bad node can make it to this function - revisit when this is determined */ void Test_CF_CList_Remove_ReceivesBad_node_Because_next_PointsTo_node_But_prev_DoesNot(void) { - /* Arrange */ - clist_node_t dummy_head_node; - clist_node dummy_head = &dummy_head_node; - clist_node* arg_head = &dummy_head; - clist_node_t dummy_last_node; - clist_node arg_node = &dummy_last_node; - - dummy_head->prev = dummy_head; - dummy_head->next = dummy_head; - - /* setting bad node */ - arg_node->prev = dummy_head; - arg_node->next = arg_node; - - /* Act */ - CF_CList_Remove(arg_head, arg_node); - - /* Assert */ - UtAssert_Failed("Odd behavior - Is this desired?\n" + // /* Arrange */ + // clist_node_t dummy_head_node; + // clist_node dummy_head = &dummy_head_node; + // clist_node* arg_head = &dummy_head; + // clist_node_t dummy_last_node; + // clist_node arg_node = &dummy_last_node; + + // dummy_head->prev = dummy_head; + // dummy_head->next = dummy_head; + + // /* setting bad node */ + // arg_node->prev = dummy_head; + // arg_node->next = arg_node; + + // /* Act */ + // CF_CList_Remove(arg_head, arg_node); + + // /* Assert */ + // UtAssert_ADDRESS_EQ(*arg_head, &dummy_head_node); + // UtAssert_ADDRESS_EQ(dummy_head->prev, dummy_head); + // UtAssert_ADDRESS_EQ(dummy_head->next, dummy_head); + // /* Assert for CF_CList_InitNode - note this cannot be verified because node state does not change */ + // UtAssert_ADDRESS_EQ(arg_node->prev, arg_node); + // UtAssert_ADDRESS_EQ(arg_node->next, arg_node); + UtAssert_MIR("JIRA: GSFCCFS-1719 Odd behavior - Is this desired?\n" "A bad node is passed to CF_CList_Remove, but it carries on unaware\n" "This was found because branch 3 of if((node->next==node)&&(node->prev==node))\n" "can only be covered by this type of test, node->next == node, node-prev != node"); - UtAssert_True(*arg_head == &dummy_head_node, - "*head is %p and should be %p (head)", - *arg_head, &dummy_head_node); - UtAssert_True(dummy_head->prev == dummy_head, - "CF_CList_InitNode set head->prev to %p and should be %p (head)", - dummy_head->prev, dummy_head); - UtAssert_True(dummy_head->next == dummy_head, - "CF_CList_InitNode set head->next to %p and should be %p (head)", - dummy_head->next, dummy_head); - /* Assert for CF_CList_InitNode - note this cannot be verified because node state does not change */ - UtAssert_True(arg_node->prev == arg_node, - "CF_CList_InitNode set node->prev to %p and should be %p (node)", - arg_node->prev, arg_node); - UtAssert_True(arg_node->next == arg_node, - "CF_CList_InitNode set node->next to %p and should be %p (node)", - arg_node->next, arg_node); } /* end Test_CF_CList_Remove_ReceivesBad_node_Because_next_PointsTo_node_But_prev_DoesNot */ +/* end CF_CList_Remove tests */ /******************************************************************************* ** @@ -1042,7 +888,7 @@ void Test_CF_CList_Remove_ReceivesBad_node_Because_next_PointsTo_node_But_prev_D ** *******************************************************************************/ -void Test_CF_CList_InsertAfter_FailsAssert_head_IsNull(void) +void Test_CF_CList_InsertAfter_AssertsBecause_head_Is_NULL(void) { /* Arrange */ // clist_node* arg_head = NULL; @@ -1053,10 +899,10 @@ void Test_CF_CList_InsertAfter_FailsAssert_head_IsNull(void) //CF_CList_InsertAfter(arg_head, arg_start, arg_after); /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end CF_CList_InsertAfter_FailsAssert_head_IsNull */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - head"); +} /* end CF_CList_InsertAfter_AssertsBecause_head_Is_NULL */ -void Test_CF_CList_InsertAfter_FailsAssertValueAt_head_IsNull(void) +void Test_CF_CList_InsertAfter_AssertsBecauseValueAt_head_Is_NULL(void) { /* Arrange */ // clist_node dummy_head = NULL; @@ -1068,10 +914,10 @@ void Test_CF_CList_InsertAfter_FailsAssertValueAt_head_IsNull(void) //CF_CList_InsertAfter(arg_head, arg_start, arg_after); /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_InsertAfter_FailsAssertValueAt_head_IsNull */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - *head"); +} /* end Test_CF_CList_InsertAfter_AssertsBecauseValueAt_head_Is_NULL */ -void Test_CF_CList_InsertAfter_FailsAssert_start_IsNull(void) +void Test_CF_CList_InsertAfter_AssertsBecause_start_Is_NULL(void) { /* Arrange */ // clist_node_t dummy_head_node; @@ -1084,10 +930,10 @@ void Test_CF_CList_InsertAfter_FailsAssert_start_IsNull(void) //CF_CList_InsertAfter(arg_head, arg_start, arg_after); /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_InsertAfter_FailsAssert_start_IsNull */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - start"); +} /* end Test_CF_CList_InsertAfter_AssertsBecause_start_Is_NULL */ -void Test_CF_CList_InsertAfter_FailsAssert_start_IsEqTo_after(void) +void Test_CF_CList_InsertAfter_AssertsBecause_start_IsEqTo_after(void) { /* Arrange */ // clist_node_t dummy_head_node; @@ -1101,10 +947,10 @@ void Test_CF_CList_InsertAfter_FailsAssert_start_IsEqTo_after(void) //CF_CList_InsertAfter(arg_head, arg_start, arg_after); /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* end Test_CF_CList_InsertAfter_FailsAssert_start_IsNull */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - start!=after"); +} /* end Test_CF_CList_InsertAfter_AssertsBecause_start_Is_NULL */ -void Test_CF_CList_InsertAfter_Success_after_IsInsertedAfter_start_WhenOnlyOneNode(void) +void Test_CF_CList_InsertAfter_WhenOnlyOneNodeSuccess_after_IsInsertedAfter_start(void) { /* Arrange */ clist_node_t dummy_head_node; @@ -1124,21 +970,13 @@ void Test_CF_CList_InsertAfter_Success_after_IsInsertedAfter_start_WhenOnlyOneNo CF_CList_InsertAfter(arg_head, arg_start, arg_after); /* Assert */ - UtAssert_True(dummy_head->prev == arg_after, - "CF_CList_InsertAfter set head->prev to %p and should be %p (after)", - dummy_head->prev, arg_after); - UtAssert_True(dummy_head->next == arg_after, - "CF_CList_InsertAfter set head->next to %p and should be %p (after)", - dummy_head->next, arg_after); - UtAssert_True(arg_after->prev == dummy_head, - "CF_CList_InsertAfter set after->prev to %p and should be %p (head)", - arg_after->prev, dummy_head); - UtAssert_True(arg_after->next == dummy_head, - "CF_CList_InsertAfter set after->next to %p and should be %p (head)", - arg_after->next, dummy_head); -} /* end Test_CF_CList_InsertAfter_Success_after_IsInsertedAfter_start_WhenOnlyOneNode */ - -void Test_CF_CList_InsertAfter_Success_after_IsInsertedAfter_start_WhenAnyNode(void) + UtAssert_ADDRESS_EQ(dummy_head->prev, arg_after); + UtAssert_ADDRESS_EQ(dummy_head->next, arg_after); + UtAssert_ADDRESS_EQ(arg_after->prev, dummy_head); + UtAssert_ADDRESS_EQ(arg_after->next, dummy_head); +} /* end Test_CF_CList_InsertAfter_WhenOnlyOneNodeSuccess_after_IsInsertedAfter_start */ + +void Test_CF_CList_InsertAfter_WhenAnyNodeSuccess_after_IsInsertedAfter_start(void) { /* Arrange */ /* Arrange */ @@ -1198,18 +1036,10 @@ void Test_CF_CList_InsertAfter_Success_after_IsInsertedAfter_start_WhenAnyNode(v CF_CList_InsertAfter(arg_head, arg_start, arg_after); /* Assert */ - UtAssert_True(arg_after->next == dummy_after_next, - "CF_CList_InsertAfter set after->next to %p and should be %p (old start->next)", - arg_after->next, dummy_after_next); - UtAssert_True(arg_start->next == arg_after, - "CF_CList_InsertAfter set start->next to %p and should be %p (after)", - arg_start->next, arg_after); - UtAssert_True(arg_after->prev == arg_start, - "CF_CList_InsertAfter set after->prev to %p and should be %p (start)", - arg_after->prev, arg_start); - UtAssert_True(dummy_after_next->prev == arg_after, - "CF_CList_InsertAfter set after->next->prev to %p and should be %p (after)", - dummy_after_next->prev, arg_after); + UtAssert_ADDRESS_EQ(arg_after->next, dummy_after_next); + UtAssert_ADDRESS_EQ(arg_start->next, arg_after); + UtAssert_ADDRESS_EQ(arg_after->prev, arg_start); + UtAssert_ADDRESS_EQ(dummy_after_next->prev, arg_after); /* removes all malloc nodes */ clist_node free_up_node = dummy_head->next; @@ -1226,7 +1056,7 @@ void Test_CF_CList_InsertAfter_Success_after_IsInsertedAfter_start_WhenAnyNode(v free_up_node = old_free_up_node->next; free(old_free_up_node); } -} /* end Test_CF_CList_InsertAfter_Success_after_IsInsertedAfter_start_WhenAnyNode */ +} /* end Test_CF_CList_InsertAfter_WhenAnyNodeSuccess_after_IsInsertedAfter_start */ /* end CF_CList_InsertAfter tests */ @@ -1236,7 +1066,7 @@ void Test_CF_CList_InsertAfter_Success_after_IsInsertedAfter_start_WhenAnyNode(v ** *******************************************************************************/ -void Test_CF_CList_Traverse_DoesNothing_start_IsNull(void) +void Test_CF_CList_Traverse_When_start_Is_NULL_DoNothing(void) { /* Arrange */ clist_node arg_start = NULL; @@ -1249,9 +1079,9 @@ void Test_CF_CList_Traverse_DoesNothing_start_IsNull(void) /* Assert */ UtAssert_STUB_COUNT(Dummy_clist_fn_t, 0); -} /* end CF_CList_Traverse_DoesNothing_start_IsNull */ +} /* end Test_CF_CList_Traverse_When_start_Is_NULL_DoNothing */ -void Test_CF_CList_Traverse_ErrorsOutFirst_fn_CallFailsWhenListIsMoreThanOneNode(void) +void Test_CF_CList_Traverse_WhenListIsMoreThanOneNodeErrorOutFirst_fn_CallFails(void) { /* Arrange */ clist_node_t dummy_start; @@ -1273,15 +1103,11 @@ void Test_CF_CList_Traverse_ErrorsOutFirst_fn_CallFailsWhenListIsMoreThanOneNode /* Assert */ UtAssert_STUB_COUNT(Dummy_clist_fn_t, 1); - UtAssert_True(context_Dummy_clist_fn_t.node == arg_start, - "fn received node %p and should be %p (start)", - context_Dummy_clist_fn_t.node, arg_start); - UtAssert_True(context_Dummy_clist_fn_t.context == arg_context, - "fn received context %p and should be %p (context)", - context_Dummy_clist_fn_t.context, arg_context); -} /* end Test_CF_CList_Traverse_ErrorsOutFirst_fn_CallFailsWhenListIsMoreThanOneNode */ - -void Test_CF_CList_Traverse_SuccessWhenListIsOneNode(void) + UtAssert_True(context_Dummy_clist_fn_t.node == arg_start, "context_Dummy_clist_fn_t.node == arg_start"); + UtAssert_True(context_Dummy_clist_fn_t.context == arg_context, "context_Dummy_clist_fn_t.context == arg_context"); +} /* end Test_CF_CList_Traverse_WhenListIsMoreThanOneNodeErrorOutFirst_fn_CallFails */ + +void Test_CF_CList_Traverse_WhenListIsOneNodeSuccess(void) { /* Arrange */ clist_node_t dummy_start; @@ -1303,15 +1129,11 @@ void Test_CF_CList_Traverse_SuccessWhenListIsOneNode(void) /* Assert */ UtAssert_STUB_COUNT(Dummy_clist_fn_t, 1); - UtAssert_True(context_Dummy_clist_fn_t.node == arg_start, - "fn received node %p and should be %p (start)", - context_Dummy_clist_fn_t.node, arg_start); - UtAssert_True(context_Dummy_clist_fn_t.context == arg_context, - "fn received context %p and should be %p (context)", - context_Dummy_clist_fn_t.context, arg_context); -} /* end Test_CF_CList_Traverse_SuccessWhenListIsOneNode */ - -/* TODO: Test_CF_CList_Traverse_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_ThatForcesIt may need redesigned, or maybe the production code */ + UtAssert_True(context_Dummy_clist_fn_t.node == arg_start, "context_Dummy_clist_fn_t.node == arg_start"); + UtAssert_True(context_Dummy_clist_fn_t.context == arg_context, "context_Dummy_clist_fn_t.context == arg_context"); +} /* end Test_CF_CList_Traverse_WhenListIsOneNodeSuccess */ + +/* NOTE: Test_CF_CList_Traverse_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_ThatForcesIt may need redesigned, or maybe the production code */ void Test_CF_CList_Traverse_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_ThatForcesIt(void) { /* Arrange */ @@ -1334,16 +1156,11 @@ void Test_CF_CList_Traverse_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_Th /* Assert */ UtAssert_STUB_COUNT(Hook_clist_fn_t, 1); - UtAssert_True(context_Hook_clist_fn_t.node == arg_start, - "fn received node %p and should be %p (start)", - context_Hook_clist_fn_t.node, arg_start); - UtAssert_True(context_Hook_clist_fn_t.context == arg_context, - "fn received context %p and should be %p (context)", - context_Hook_clist_fn_t.context, arg_context); + UtAssert_True(context_Hook_clist_fn_t.node == arg_start, "context_Hook_clist_fn_t.node == arg_start"); + UtAssert_True(context_Hook_clist_fn_t.context == arg_context, "context_Hook_clist_fn_t.context == arg_context"); } /* end Test_CF_CList_Traverse_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_ThatForcesIt */ - -void Test_CF_CList_Traverse_ErrorIn_fn_CallWhenListIsManyNodes(void) +void Test_CF_CList_Traverse_WhenListIsManyNodesErrorIn_fn_Call(void) { /* Arrange */ clist_node arg_start; @@ -1397,22 +1214,14 @@ void Test_CF_CList_Traverse_ErrorIn_fn_CallWhenListIsManyNodes(void) /* Assert */ UtAssert_STUB_COUNT(Dummy_clist_fn_t, error_location + 1); - UtAssert_True(context_Dummy_clist_fn_t[0].node == arg_start, - "fn received node %p and should be %p (start)", - context_Dummy_clist_fn_t[0].node, arg_start); - UtAssert_True(context_Dummy_clist_fn_t[0].context == arg_context, - "fn received context %p and should be %p (context)", - context_Dummy_clist_fn_t[0].context, arg_context); + UtAssert_True(context_Dummy_clist_fn_t[0].node == arg_start, "context_Dummy_clist_fn_t[0].node == arg_start"); + UtAssert_True(context_Dummy_clist_fn_t[0].context == arg_context, "context_Dummy_clist_fn_t[0].context == arg_context"); clist_node expected_node = arg_start->next; for(i = 1; i <= error_location; ++i) { - UtAssert_True(context_Dummy_clist_fn_t[i].node == expected_node, - "fn received node %p and should be %p (node %u)", - context_Dummy_clist_fn_t[i].node, expected_node, i + 1); - UtAssert_True(context_Dummy_clist_fn_t[i].context == arg_context, - "fn received context %p and should be %p (node %u)", - context_Dummy_clist_fn_t[i].context, arg_context, i + 1); + UtAssert_True(context_Dummy_clist_fn_t[i].node == expected_node, "context_Dummy_clist_fn_t[i].node == expected_node"); + UtAssert_True(context_Dummy_clist_fn_t[i].context == arg_context, "context_Dummy_clist_fn_t[i].context == arg_context"); expected_node = expected_node->next; } @@ -1425,9 +1234,9 @@ void Test_CF_CList_Traverse_ErrorIn_fn_CallWhenListIsManyNodes(void) free_up_node = old_free_up_node->next; free(old_free_up_node); } -} /* end Test_CF_CList_Traverse_SuccessWhenListIsManyNodes */ +} /* end Test_CF_CList_Traverse_WhenListIsManyNodesErrorIn_fn_Call */ -void Test_CF_CList_Traverse_SuccessWhenListIsManyNodes(void) +void Test_CF_CList_Traverse_WhenListIsManyNodesSuccess(void) { /* Arrange */ clist_node arg_start; @@ -1479,22 +1288,14 @@ void Test_CF_CList_Traverse_SuccessWhenListIsManyNodes(void) /* Assert */ UtAssert_STUB_COUNT(Dummy_clist_fn_t, list_size); - UtAssert_True(context_Dummy_clist_fn_t[0].node == arg_start, - "fn received node %p and should be %p (start)", - context_Dummy_clist_fn_t[0].node, arg_start); - UtAssert_True(context_Dummy_clist_fn_t[0].context == arg_context, - "fn received context %p and should be %p (context)", - context_Dummy_clist_fn_t[0].context, arg_context); + UtAssert_True(context_Dummy_clist_fn_t[0].node == arg_start, "context_Dummy_clist_fn_t[0].node == arg_start"); + UtAssert_True(context_Dummy_clist_fn_t[0].context == arg_context, "context_Dummy_clist_fn_t[0].context == arg_context"); clist_node expected_node = arg_start->next; for(i = 1; i < list_size; ++i) { - UtAssert_True(context_Dummy_clist_fn_t[i].node == expected_node, - "fn received node %p and should be %p (node %u)", - context_Dummy_clist_fn_t[i].node, expected_node, i); - UtAssert_True(context_Dummy_clist_fn_t[i].context == arg_context, - "fn received context %p and should be %p (node %u)", - context_Dummy_clist_fn_t[i].context, arg_context, i); + UtAssert_True(context_Dummy_clist_fn_t[i].node == expected_node, "context_Dummy_clist_fn_t[i].node == expected_node"); + UtAssert_True(context_Dummy_clist_fn_t[i].context == arg_context, "context_Dummy_clist_fn_t[i].context == arg_context"); expected_node = expected_node->next; } @@ -1507,7 +1308,7 @@ void Test_CF_CList_Traverse_SuccessWhenListIsManyNodes(void) free_up_node = old_free_up_node->next; free(old_free_up_node); } -} /* end Test_CF_CList_Traverse_SuccessWhenListIsManyNodes */ +} /* end Test_CF_CList_Traverse_WhenListIsManyNodesSuccess */ @@ -1517,7 +1318,7 @@ void Test_CF_CList_Traverse_SuccessWhenListIsManyNodes(void) ** *******************************************************************************/ -void Test_CF_CList_Traverse_R_DoesNothing_end_IsNull(void) +void Test_CF_CList_Traverse_R_When_end_Is_NULL_DoNothing(void) { /* Arrange */ clist_node arg_end = NULL; @@ -1530,9 +1331,9 @@ void Test_CF_CList_Traverse_R_DoesNothing_end_IsNull(void) /* Assert */ UtAssert_STUB_COUNT(Dummy_clist_fn_t, 0); -} /* end Test_CF_CList_Traverse_R_DoesNothing_end_IsNull */ +} /* end Test_CF_CList_Traverse_R_When_end_Is_NULL_DoNothing */ -void Test_CF_CList_Traverse_R_DoesNothing_end_prev_IsNull(void) +void Test_CF_CList_Traverse_R_When_end_prev_Is_NULLDoNothing(void) { /* Arrange */ clist_node_t dummy_end; @@ -1549,9 +1350,9 @@ void Test_CF_CList_Traverse_R_DoesNothing_end_prev_IsNull(void) /* Assert */ UtAssert_STUB_COUNT(Dummy_clist_fn_t, 0); -} /* end Test_CF_CList_Traverse_R_DoesNothing_end_prev_IsNull */ +} /* end Test_CF_CList_Traverse_R_When_end_prev_Is_NULLDoNothing */ -void Test_CF_CList_Traverse_R_ErrorsOutFirst_fn_CallFailsWhenListIsMoreThanOneNode(void) +void Test_CF_CList_Traverse_R_WhenListIsMoreThanOneNodeErrorOutFirst_fn_CallFails(void) { /* Arrange */ clist_node_t dummy_end; @@ -1575,13 +1376,9 @@ void Test_CF_CList_Traverse_R_ErrorsOutFirst_fn_CallFailsWhenListIsMoreThanOneNo /* Assert */ UtAssert_STUB_COUNT(Dummy_clist_fn_t, 1); - UtAssert_True(context_Dummy_clist_fn_t.node == dummy_end_prev, - "fn received node %p and should be %p (end->prev)", - context_Dummy_clist_fn_t.node, dummy_end_prev); - UtAssert_True(context_Dummy_clist_fn_t.context == arg_context, - "fn received context %p and should be %p (context)", - context_Dummy_clist_fn_t.context, arg_context); -} /* end Test_CF_CList_Traverse_R_ErrorsOutFirst_fn_CallFailsWhenListIsMoreThanOneNode */ + UtAssert_True(context_Dummy_clist_fn_t.node == dummy_end_prev, "context_Dummy_clist_fn_t.node == dummy_end_prev"); + UtAssert_True(context_Dummy_clist_fn_t.context == arg_context, "context_Dummy_clist_fn_t.context == arg_context"); +} /* end Test_CF_CList_Traverse_R_WhenListIsMoreThanOneNodeErrorOutFirst_fn_CallFails */ void Test_CF_CList_Traverse_R_PassedIn_end_IsTheOnlyNode_fn_Returned_non0(void) { @@ -1605,12 +1402,8 @@ void Test_CF_CList_Traverse_R_PassedIn_end_IsTheOnlyNode_fn_Returned_non0(void) /* Assert */ UtAssert_STUB_COUNT(Dummy_clist_fn_t, 1); - UtAssert_True(context_Dummy_clist_fn_t.node == arg_end, - "fn received node %p and should be %p (end->prev)", - context_Dummy_clist_fn_t.node, arg_end); - UtAssert_True(context_Dummy_clist_fn_t.context == arg_context, - "fn received context %p and should be %p (context)", - context_Dummy_clist_fn_t.context, arg_context); + UtAssert_True(context_Dummy_clist_fn_t.node == arg_end, "context_Dummy_clist_fn_t.node == arg_end"); + UtAssert_True(context_Dummy_clist_fn_t.context == arg_context, "context_Dummy_clist_fn_t.context == arg_context"); } /* end Test_CF_CList_Traverse_R_PassedIn_end_IsTheOnlyNode_fn_Returned_non0 */ void Test_CF_CList_Traverse_R_PassedIn_end_IsNotTheOnlyNode_fn_Returned_non0_Original_end_UsedLast(void) @@ -1637,18 +1430,10 @@ void Test_CF_CList_Traverse_R_PassedIn_end_IsNotTheOnlyNode_fn_Returned_non0_Ori /* Assert */ UtAssert_STUB_COUNT(Dummy_clist_fn_t, 2); - UtAssert_True(context_Dummy_clist_fn_t[0].node == &dummy_node, - "fn call 1 received node %p and should be %p (passed in end->prev)", - context_Dummy_clist_fn_t[0].node, &dummy_node); - UtAssert_True(context_Dummy_clist_fn_t[0].context == arg_context, - "fn call 1 received context %p and should be %p (context)", - context_Dummy_clist_fn_t[0].context, arg_context); - UtAssert_True(context_Dummy_clist_fn_t[1].node == arg_end, - "fn call 2 received node %p and should be %p (original end->prev)", - context_Dummy_clist_fn_t[1].node, arg_end); - UtAssert_True(context_Dummy_clist_fn_t[1].context == arg_context, - "fn call 2 received context %p and should be %p (context)", - context_Dummy_clist_fn_t[1].context, arg_context); + UtAssert_True(context_Dummy_clist_fn_t[0].node == &dummy_node, "context_Dummy_clist_fn_t[0].node == &dummy_node"); + UtAssert_True(context_Dummy_clist_fn_t[0].context == arg_context, "context_Dummy_clist_fn_t[0].context == arg_context"); + UtAssert_True(context_Dummy_clist_fn_t[1].node == arg_end, "context_Dummy_clist_fn_t[1].node == arg_end"); + UtAssert_True(context_Dummy_clist_fn_t[1].context == arg_context, "context_Dummy_clist_fn_t[1].context == arg_context"); } /* end Test_CF_CList_Traverse_R_PassedIn_end_IsNotTheOnlyNode_fn_Returned_non0_Original_end_UsedLast */ void Test_CF_CList_Traverse_R_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_ThatForcesIt(void) @@ -1673,12 +1458,8 @@ void Test_CF_CList_Traverse_R_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_ /* Assert */ UtAssert_STUB_COUNT(Hook_clist_fn_t, 1); - UtAssert_True(context_Hook_clist_fn_t.node == arg_end, - "fn received node %p and should be %p (end->prev)", - context_Hook_clist_fn_t.node, arg_end); - UtAssert_True(context_Hook_clist_fn_t.context == arg_context, - "fn received context %p and should be %p (context)", - context_Hook_clist_fn_t.context, arg_context); + UtAssert_True(context_Hook_clist_fn_t.node == arg_end, "context_Hook_clist_fn_t.node == arg_end"); + UtAssert_True(context_Hook_clist_fn_t.context == arg_context, "context_Hook_clist_fn_t.context == arg_context"); } /* end Test_CF_CList_Traverse_R_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_ThatForcesIt */ @@ -1691,173 +1472,172 @@ void Test_CF_CList_Traverse_R_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_ void add_CF_CList_InitNode_tests(void) { - UtTest_Add(Test_CF_CList_InitNode_PointsNodeToItselfAsNextAndPrev, + UtTest_Add(Test_CF_CList_InitNode_PointNodeToItselfAsNextAndPrev, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InitNode_PointsNodeToItselfAsNextAndPrev"); -} + "Test_CF_CList_InitNode_PointNodeToItselfAsNextAndPrev"); +} /* end add_CF_CList_InitNode_tests */ void add_CF_CList_InsertFront_tests(void) { - UtTest_Add(Test_CF_CList_InsertFront_FailsAssertHeadIsNull, + UtTest_Add(Test_CF_CList_InsertFront_AssertsBecauseHeadIs_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertFront_FailsAssertHeadIsNull"); - UtTest_Add(Test_CF_CList_InsertFront_FailsAssertNodeIsNull, + "Test_CF_CList_InsertFront_AssertsBecauseHeadIs_NULL"); + UtTest_Add(Test_CF_CList_InsertFront_AssertsBecauseNodeIs_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertFront_FailsAssertNodeIsNull"); - UtTest_Add(Test_CF_CList_InsertFront_FailsAssertNodeNextDoesNotPointToItself, + "Test_CF_CList_InsertFront_AssertsBecauseNodeIs_NULL"); + UtTest_Add(Test_CF_CList_InsertFront_AssertsBecauseNodeNextDoesNotPointToItself, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertFront_FailsAssertNodeNextDoesNotPointToItself"); - UtTest_Add(Test_CF_CList_InsertFront_FailsAssertNodePrevDoesNotPointToItself, + "Test_CF_CList_InsertFront_AssertsBecauseNodeNextDoesNotPointToItself"); + UtTest_Add(Test_CF_CList_InsertFront_AssertsBecauseNodePrevDoesNotPointToItself, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertFront_FailsAssertNodePrevDoesNotPointToItself"); - UtTest_Add(Test_CF_CList_InsertFront_InsertsNodeIntoEmptyList, + "Test_CF_CList_InsertFront_AssertsBecauseNodePrevDoesNotPointToItself"); + UtTest_Add(Test_CF_CList_InsertFront_InsertNodeIntoEmptyList, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertFront_InsertsNodeIntoEmptyList"); - UtTest_Add(Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOther, + "Test_CF_CList_InsertFront_InsertNodeIntoEmptyList"); + UtTest_Add(Test_CF_CList_InsertFront_WhenHeadIsOnlyNodeAndTheyPointToEachOtherInsertNode, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOther"); - UtTest_Add(Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodes, + "Test_CF_CList_InsertFront_WhenHeadIsOnlyNodeAndTheyPointToEachOtherInsertNode"); + UtTest_Add(Test_CF_CList_InsertFront_WhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodesInsertNode, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertFront_InsertsNodeWhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodes"); - UtTest_Add(Test_CF_CList_InsertFront_InsertsNodeWhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodes, + "Test_CF_CList_InsertFront_WhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodesInsertNode"); + UtTest_Add(Test_CF_CList_InsertFront_WhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodesInsertNode, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertFront_InsertsNodeWhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodes"); -} + "Test_CF_CList_InsertFront_WhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodesInsertNode"); +} /* end add_CF_CList_InsertFront_tests */ void add_CF_CList_InsertBack_tests(void) { - UtTest_Add(Test_CF_CList_InsertBack_FailsAssertHeadIsNull, + UtTest_Add(Test_CF_CList_InsertBack_AssertsBecauseHeadIs_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertBack_FailsAssertHeadIsNull"); - UtTest_Add(Test_CF_CList_InsertBack_FailsAssertNodeIsNull, + "Test_CF_CList_InsertBack_AssertsBecauseHeadIs_NULL"); + UtTest_Add(Test_CF_CList_InsertBack_AssertsBecauseNodeIs_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertBack_FailsAssertNodeIsNull"); - UtTest_Add(Test_CF_CList_InsertBack_FailsAssertNodeNextDoesNotPointToItself, + "Test_CF_CList_InsertBack_AssertsBecauseNodeIs_NULL"); + UtTest_Add(Test_CF_CList_InsertBack_AssertsBecauseNodeNextDoesNotPointToItself, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertBack_FailsAssertNodeNextDoesNotPointToItself"); - UtTest_Add(Test_CF_CList_InsertBack_FailsAssertNodePrevDoesNotPointToItself, + "Test_CF_CList_InsertBack_AssertsBecauseNodeNextDoesNotPointToItself"); + UtTest_Add(Test_CF_CList_InsertBack_AssertsBecauseNodePrevDoesNotPointToItself, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertBack_FailsAssertNodePrevDoesNotPointToItself"); - UtTest_Add(Test_CF_CList_InsertBack_InsertsNodeIntoEmptyList, + "Test_CF_CList_InsertBack_AssertsBecauseNodePrevDoesNotPointToItself"); + UtTest_Add(Test_CF_CList_InsertBack_InsertNodeIntoEmptyList, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertBack_InsertsNodeIntoEmptyList"); - UtTest_Add(Test_CF_CList_InsertBack_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOther, + "Test_CF_CList_InsertBack_InsertNodeIntoEmptyList"); + UtTest_Add(Test_CF_CList_InsertBack_WhenHeadIsOnlyNodeAndTheyPointToEachOtherInsertNode, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertBack_InsertsNodeWhenHeadIsOnlyNodeAndTheyPointToEachOther"); - UtTest_Add(Test_CF_CList_InsertBack_InsertsNodeWhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodes, + "Test_CF_CList_InsertBack_WhenHeadIsOnlyNodeAndTheyPointToEachOtherInsertNode"); + UtTest_Add(Test_CF_CList_InsertBack_WhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodesInsertNode, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertBack_InsertsNodeWhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodes"); - UtTest_Add(Test_CF_CList_InsertBack_InsertsNodeWhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodes, + "Test_CF_CList_InsertBack_WhenHeadIsOneOfTwoNodesAndTheyPointToCorrectNodesInsertNode"); + UtTest_Add(Test_CF_CList_InsertBack_WhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodesInsertNode, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertBack_InsertsNodeWhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodes"); -} + "Test_CF_CList_InsertBack_WhenNodeListIsGreaterThanTwoNodesAndTheyPointToCorrectNodesInsertNode"); +} /* end add_CF_CList_InsertBack_tests */ void add_CF_CList_Pop_tests(void) { - UtTest_Add(Test_CF_CList_Pop_FailsAssert_head_IsNull, + UtTest_Add(Test_CF_CList_Pop_AssertsBecause_head_Is_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Pop_FailsAssert_head_IsNull"); - UtTest_Add(Test_CF_CList_Pop_SuccessReturnsNullBecauseListIsEmpty, + "Test_CF_CList_Pop_AssertsBecause_head_Is_NULL"); + UtTest_Add(Test_CF_CList_Pop_WhenListIsEmptySuccessReturn_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Pop_SuccessReturnsNullBecauseListIsEmpty"); - UtTest_Add(Test_CF_CList_Pop_SuccessPopsHeadNodeAndReturns_head_WhenItIsOnlyNode, + "Test_CF_CList_Pop_WhenListIsEmptySuccessReturn_NULL"); + UtTest_Add(Test_CF_CList_Pop_WhenItIsOnlyNodePopHeadNodeAndReturn_head_, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Pop_SuccessPopsHeadNodeAndReturns_head_WhenItIsOnlyNode"); - UtTest_Add(Test_CF_CList_Pop_SuccessPopsHeadNodeAndReturns_head_WhenListIsAnySizeGreaterThanOne, + "Test_CF_CList_Pop_WhenItIsOnlyNodePopHeadNodeAndReturn_head_"); + UtTest_Add(Test_CF_CList_Pop_WhenListIsAnySizeGreaterThanOneSuccessPopsHeadNodeAndReturns_head, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Pop_SuccessPopsHeadNodeAndReturns_head_WhenListIsAnySizeGreaterThanOne"); -} + "Test_CF_CList_Pop_WhenListIsAnySizeGreaterThanOneSuccessPopsHeadNodeAndReturns_head"); +} /* end add_CF_CList_Pop_tests */ void add_CF_CList_Remove_tests(void) { - UtTest_Add(Test_CF_CList_Remove_FailsAssertHeadPointedAtValueIsNull, + UtTest_Add(Test_CF_CList_Remove_AssertsBecauseHeadIs_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Remove_FailsAssertHeadPointedAtValueIsNull"); - UtTest_Add(Test_CF_CList_Remove_FailsAssertNodeIsNull, + "Test_CF_CList_Remove_AssertsBecauseHeadIs_NULL"); + UtTest_Add(Test_CF_CList_Remove_AssertsBecauseNodeIs_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Remove_FailsAssertNodeIsNull"); - UtTest_Add(Test_CF_CList_Remove_FailsAssertHeadIsNull, + "Test_CF_CList_Remove_AssertsBecauseNodeIs_NULL"); + UtTest_Add(Test_CF_CList_Remove_AssertsBecauseHeadPointedAtValueIs_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Remove_FailsAssertHeadIsNull"); - UtTest_Add(Test_CF_ClistRemove_FailsAssertHeadPointedAtValueIsNotNode, + "Test_CF_CList_Remove_AssertsBecauseHeadPointedAtValueIs_NULL"); + UtTest_Add(Test_CF_ClistRemove_AssertsBecauseHeadPointedAtValueIsNotNode, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_ClistRemove_FailsAssertHeadPointedAtValueIsNotNode"); - UtTest_Add(Test_CF_ClistRemove_SetsHeadToNullWhenOnlyNode, + "Test_CF_ClistRemove_AssertsBecauseHeadPointedAtValueIsNotNode"); + UtTest_Add(Test_CF_ClistRemove_WhenOnlyNodeSetHeadTo_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_ClistRemove_SetsHeadToNullWhenOnlyNode"); - UtTest_Add(Test_CF_ClistRemove_SetsHeadToPointToItselWhenOnlyTwoNodesAndLastIsRemoved, + "Test_CF_ClistRemove_WhenOnlyNodeSetHeadTo_NULL"); + UtTest_Add(Test_CF_ClistRemove_WhenOnlyTwoNodesAndLastIsRemovedSetHeadToPointToItself, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_ClistRemove_SetsHeadToPointToItselWhenOnlyTwoNodesAndLastIsRemoved"); - UtTest_Add(Test_CF_ClistRemove_RemovingHeadSetsSecondNodeToHeadAndUpdatesLastNode, + "Test_CF_ClistRemove_WhenOnlyTwoNodesAndLastIsRemovedSetHeadToPointToItself"); + UtTest_Add(Test_CF_ClistRemove_RemovingHeadSetSecondNodeToHeadAndUpdateLastNode, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_ClistRemove_RemovingHeadSetsSecondNodeToHeadAndUpdatesLastNode"); - UtTest_Add(Test_CF_ClistRemove_RemovingLastPointsHeadAndNextToLastToEachOther, + "Test_CF_ClistRemove_RemovingHeadSetSecondNodeToHeadAndUpdateLastNode"); + UtTest_Add(Test_CF_ClistRemove_RemovingLastPointHeadAndNextToLastToEachOther, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_ClistRemove_RemovingLastPointsHeadAndNextToLastToEachOther"); + "Test_CF_ClistRemove_RemovingLastPointHeadAndNextToLastToEachOther"); UtTest_Add(Test_CF_ClistRemove_RemovingAnyNodeHasNodesPrevAndNextPointToEachOther, cf_clist_tests_Setup, cf_clist_tests_Teardown, "Test_CF_ClistRemove_RemovingAnyNodeHasNodesPrevAndNextPointToEachOther"); - /* TODO: Re-examine Test_CF_CList_Remove_ReceivesBad_node_Because_next_PointsTo_node_But_prev_DoesNot */ - // UtTest_Add(Test_CF_CList_Remove_ReceivesBad_node_Because_next_PointsTo_node_But_prev_DoesNot, - // cf_clist_tests_Setup, cf_clist_tests_Teardown, - // "Test_CF_CList_Remove_ReceivesBad_node_Because_next_PointsTo_node_But_prev_DoesNot"); -} + UtTest_Add(Test_CF_CList_Remove_ReceivesBad_node_Because_next_PointsTo_node_But_prev_DoesNot, + cf_clist_tests_Setup, cf_clist_tests_Teardown, + "Test_CF_CList_Remove_ReceivesBad_node_Because_next_PointsTo_node_But_prev_DoesNot"); +} /* end add_CF_CList_Remove_tests */ void add_CF_CList_InsertAfter_tests(void) { - UtTest_Add(Test_CF_CList_InsertAfter_FailsAssert_head_IsNull, + UtTest_Add(Test_CF_CList_InsertAfter_AssertsBecause_head_Is_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertAfter_FailsAssert_head_IsNull"); - UtTest_Add(Test_CF_CList_InsertAfter_FailsAssertValueAt_head_IsNull, + "Test_CF_CList_InsertAfter_AssertsBecause_head_Is_NULL"); + UtTest_Add(Test_CF_CList_InsertAfter_AssertsBecauseValueAt_head_Is_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertAfter_FailsAssert_head_IsNull"); - UtTest_Add(Test_CF_CList_InsertAfter_FailsAssert_start_IsNull, + "Test_CF_CList_InsertAfter_AssertsBecause_head_Is_NULL"); + UtTest_Add(Test_CF_CList_InsertAfter_AssertsBecause_start_Is_NULL, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertAfter_FailsAssert_head_IsNull"); - UtTest_Add(Test_CF_CList_InsertAfter_FailsAssert_start_IsEqTo_after, + "Test_CF_CList_InsertAfter_AssertsBecause_head_Is_NULL"); + UtTest_Add(Test_CF_CList_InsertAfter_AssertsBecause_start_IsEqTo_after, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertAfter_FailsAssert_head_IsNull"); - UtTest_Add(Test_CF_CList_InsertAfter_Success_after_IsInsertedAfter_start_WhenOnlyOneNode, + "Test_CF_CList_InsertAfter_AssertsBecause_head_Is_NULL"); + UtTest_Add(Test_CF_CList_InsertAfter_WhenOnlyOneNodeSuccess_after_IsInsertedAfter_start, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertAfter_Success_after_IsInsertedAfter_start_WhenOnlyOneNode"); - UtTest_Add(Test_CF_CList_InsertAfter_Success_after_IsInsertedAfter_start_WhenAnyNode, + "Test_CF_CList_InsertAfter_WhenOnlyOneNodeSuccess_after_IsInsertedAfter_start"); + UtTest_Add(Test_CF_CList_InsertAfter_WhenAnyNodeSuccess_after_IsInsertedAfter_start, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_InsertAfter_Success_after_IsInsertedAfter_start_WhenAnyNode"); -} + "Test_CF_CList_InsertAfter_WhenAnyNodeSuccess_after_IsInsertedAfter_start"); +} /* end add_CF_CList_InsertAfter_tests */ void add_CF_CList_Traverse_tests(void) { - UtTest_Add(Test_CF_CList_Traverse_DoesNothing_start_IsNull, + UtTest_Add(Test_CF_CList_Traverse_When_start_Is_NULL_DoNothing, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Traverse_DoesNothing_start_IsNull"); - UtTest_Add(Test_CF_CList_Traverse_ErrorsOutFirst_fn_CallFailsWhenListIsMoreThanOneNode, + "Test_CF_CList_Traverse_When_start_Is_NULL_DoNothing"); + UtTest_Add(Test_CF_CList_Traverse_WhenListIsMoreThanOneNodeErrorOutFirst_fn_CallFails, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Traverse_ErrorsOutFirst_fn_CallFailsWhenListIsMoreThanOneNode"); - UtTest_Add(Test_CF_CList_Traverse_SuccessWhenListIsOneNode, + "Test_CF_CList_Traverse_WhenListIsMoreThanOneNodeErrorOutFirst_fn_CallFails"); + UtTest_Add(Test_CF_CList_Traverse_WhenListIsOneNodeSuccess, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Traverse_SuccessWhenListIsOneNode"); + "Test_CF_CList_Traverse_WhenListIsOneNodeSuccess"); UtTest_Add(Test_CF_CList_Traverse_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_ThatForcesIt, cf_clist_tests_Setup, cf_clist_tests_Teardown, "Test_CF_CList_Traverse_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_ThatForcesIt"); - UtTest_Add(Test_CF_CList_Traverse_ErrorIn_fn_CallWhenListIsManyNodes, + UtTest_Add(Test_CF_CList_Traverse_WhenListIsManyNodesErrorIn_fn_Call, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Traverse_ErrorIn_fn_CallWhenListIsManyNodes"); - UtTest_Add(Test_CF_CList_Traverse_SuccessWhenListIsManyNodes, + "Test_CF_CList_Traverse_WhenListIsManyNodesErrorIn_fn_Call"); + UtTest_Add(Test_CF_CList_Traverse_WhenListIsManyNodesSuccess, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Traverse_SuccessWhenListIsManyNodes"); -} + "Test_CF_CList_Traverse_WhenListIsManyNodesSuccess"); +} /* end add_CF_CList_Traverse_tests */ void add_CF_CList_Traverse_R_tests(void) { - UtTest_Add(Test_CF_CList_Traverse_R_DoesNothing_end_IsNull, + UtTest_Add(Test_CF_CList_Traverse_R_When_end_Is_NULL_DoNothing, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Traverse_R_DoesNothing_end_IsNull"); - UtTest_Add(Test_CF_CList_Traverse_R_DoesNothing_end_prev_IsNull, + "Test_CF_CList_Traverse_R_When_end_Is_NULL_DoNothing"); + UtTest_Add(Test_CF_CList_Traverse_R_When_end_prev_Is_NULLDoNothing, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Traverse_R_DoesNothing_end_prev_IsNull"); - UtTest_Add(Test_CF_CList_Traverse_R_ErrorsOutFirst_fn_CallFailsWhenListIsMoreThanOneNode, + "Test_CF_CList_Traverse_R_When_end_prev_Is_NULLDoNothing"); + UtTest_Add(Test_CF_CList_Traverse_R_WhenListIsMoreThanOneNodeErrorOutFirst_fn_CallFails, cf_clist_tests_Setup, cf_clist_tests_Teardown, - "Test_CF_CList_Traverse_R_ErrorsOutFirst_fn_CallFailsWhenListIsMoreThanOneNode"); + "Test_CF_CList_Traverse_R_WhenListIsMoreThanOneNodeErrorOutFirst_fn_CallFails"); UtTest_Add(Test_CF_CList_Traverse_R_PassedIn_end_IsTheOnlyNode_fn_Returned_non0, cf_clist_tests_Setup, cf_clist_tests_Teardown, "Test_CF_CList_Traverse_R_PassedIn_end_IsTheOnlyNode_fn_Returned_non0"); @@ -1867,7 +1647,7 @@ void add_CF_CList_Traverse_R_tests(void) UtTest_Add(Test_CF_CList_Traverse_R_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_ThatForcesIt, cf_clist_tests_Setup, cf_clist_tests_Teardown, "Test_CF_CList_Traverse_R_CanActuallyGet_n_next_NotEqTo_nn_ButOnlyWithAn_fn_ThatForcesIt"); -} +} /* end add_CF_CList_Traverse_R_tests */ /******************************************************************************* ** @@ -1896,5 +1676,4 @@ void UtTest_Setup(void) add_CF_CList_Traverse_R_tests(); } /* end UtTest_Setup for cf_clist_tests.c */ - /* end cf_clist_tests.c */ \ No newline at end of file diff --git a/unit-test/cf_cmd_tests.c b/unit-test/cf_cmd_tests.c index b062022b..fac1da0a 100644 --- a/unit-test/cf_cmd_tests.c +++ b/unit-test/cf_cmd_tests.c @@ -1,12 +1,10 @@ - /* cf testing includes */ -#include "cf_cmd.c" #include "cf_test_utils.h" +#include "cf_cmd.c" /* cf_cmd_tests globals */ extern type_of_context_CF_CList_Traverse_t type_of_context_CF_CList_Traverse; - /******************************************************************************* ** ** cf_cmd_tests Setup and Teardown @@ -27,7 +25,7 @@ void cf_cmd_tests_Teardown(void) /******************************************************************************* ** -** cf_cmd_tests specific Any functions TODO:find a better way to to this +** cf_cmd_tests specific Any functions NOTE:Some of these may be better as global ** *******************************************************************************/ @@ -70,13 +68,7 @@ cf_transaction_seq_t Any_cf_transaction_seq_t(void) return (cf_transaction_seq_t)Any_uint32(); } -/******************************************************************************* -** -** cf_utils_tests local argument access structs TODO:find a better way to to this -** -*******************************************************************************/ - - +/* end cf_cmd_tests specific Any functions */ /******************************************************************************* ** @@ -103,7 +95,6 @@ void Dummy_CF_TsnChanAction_fn_t(transaction_t* t, void* context) UT_DEFAULT_IMPL(Dummy_CF_TsnChanAction_fn_t); } - typedef struct { transaction_t* t; void* context; @@ -114,7 +105,8 @@ typedef struct { ** CF_CmdAcc tests ** *******************************************************************************/ -void Test_CF_CmdAcc_Increases_CF_AppData_HkCmdCounterBy1(void) + +void Test_CF_CmdAcc_Increment_CF_AppData_hk_cmd_counter(void) { /* Arrange */ uint16 initial_hk_cmd_counter = Any_uint16(); @@ -128,7 +120,7 @@ void Test_CF_CmdAcc_Increases_CF_AppData_HkCmdCounterBy1(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdAcc_Increases_CF_AppData_HkCmdCounterBy1 */ +} /* end Test_CF_CmdAcc_Increment_CF_AppData_hk_cmd_counter */ /* end CF_CmdAcc tests */ @@ -137,7 +129,7 @@ void Test_CF_CmdAcc_Increases_CF_AppData_HkCmdCounterBy1(void) ** CF_CmdRej tests ** *******************************************************************************/ -void Test_CF_CmdRej_Increases_CF_AppData_HkErrCounterBy1(void) +void Test_CF_CmdRej_Increment_CF_AppData_hk_err_counter(void) { /* Arrange */ uint16 initial_hk_err_counter = Any_uint16(); @@ -151,7 +143,7 @@ void Test_CF_CmdRej_Increases_CF_AppData_HkErrCounterBy1(void) UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdRej_Increases_CF_AppData_HkErrCounterBy1 */ +} /* end Test_CF_CmdRej_Increment_CF_AppData_hk_err_counter */ /* end CF_CmdRej tests */ @@ -161,7 +153,7 @@ void Test_CF_CmdRej_Increases_CF_AppData_HkErrCounterBy1(void) ** *******************************************************************************/ -void Test_CF_CmdCond_Calls_CF_CmdAccWhenCondIs0(void) +void Test_CF_CmdCond_When_cond_Is_0_Call_CF_CmdAcc(void) { /* Arrange */ int arg_cond = 0; @@ -180,9 +172,9 @@ void Test_CF_CmdCond_Calls_CF_CmdAccWhenCondIs0(void) "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* Test_CF_CmdCond_Calls_CF_CmdAccWhenCondIs0 */ +} /* Test_CF_CmdCond_When_cond_Is_0_Call_CF_CmdAcc */ -void Test_CF_CmdCond_Calls_CF_CmdRejWhenCondIsNot0(void) +void Test_CF_CmdCond_When_cond_IsNot_0_Call_CF_CmdRej(void) { /* Arrange */ int arg_cond = Any_int_Except(0); @@ -201,7 +193,7 @@ void Test_CF_CmdCond_Calls_CF_CmdRejWhenCondIsNot0(void) "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* Test_CF_CmdCond_Calls_CF_CmdRejWhenCondIsNot0 */ +} /* Test_CF_CmdCond_When_cond_IsNot_0_Call_CF_CmdRej */ /* end CF_CmdCond tests */ @@ -211,10 +203,10 @@ void Test_CF_CmdCond_Calls_CF_CmdRejWhenCondIsNot0(void) ** *******************************************************************************/ -void Test_CF_CmdNoop_SendsNoopEventAndAcceptsCommand(void) +void Test_CF_CmdNoop_SendNoopEventAndAcceptCommand(void) { /* Arrange */ - CFE_SB_Buffer_t* arg_msg; + CFE_SB_Buffer_t* arg_msg = NULL; UT_SetDataBuffer(UT_KEY(CFE_EVS_SendEvent), &EventID, sizeof(EventID), false); @@ -238,7 +230,7 @@ void Test_CF_CmdNoop_SendsNoopEventAndAcceptsCommand(void) "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* Test_CF_CmdNoop_SendsNoopEventAndAcceptsCommand */ +} /* Test_CF_CmdNoop_SendNoopEventAndAcceptCommand */ /* end CF_CmdNoop tests */ @@ -248,7 +240,7 @@ void Test_CF_CmdNoop_SendsNoopEventAndAcceptsCommand(void) ** *******************************************************************************/ -void Test_CF_CmdReset_tests_SendsEventAndRejectsCommandWhenCommandByteIsEqTo_5(void) +void Test_CF_CmdReset_tests_WhenCommandByteIsEqTo_5_SendEventAndRejectCommand(void) { /* Arrange */ cf_cmd_unionargs_t dummy_msg; @@ -266,8 +258,7 @@ void Test_CF_CmdReset_tests_SendsEventAndRejectsCommandWhenCommandByteIsEqTo_5(v /* Act */ CF_CmdReset(arg_msg); - - + /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(EventID == CF_EID_ERR_CMD_RESET_INVALID, @@ -277,9 +268,9 @@ void Test_CF_CmdReset_tests_SendsEventAndRejectsCommandWhenCommandByteIsEqTo_5(v UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdReset_tests_SendsEventAndRejectsCommandWhenCommandByteIsEqTo_5 */ +} /* end Test_CF_CmdReset_tests_WhenCommandByteIsEqTo_5_SendEventAndRejectCommand */ -void Test_CF_CmdReset_tests_SendsEventAndRejectsCommandWhenCommandByteIsGreaterThan_5(void) +void Test_CF_CmdReset_tests_WhenCommandByteIsGreaterThan_5_SendEventAndRejectCommand(void) { /* Arrange */ cf_cmd_unionargs_t dummy_msg; @@ -308,9 +299,9 @@ void Test_CF_CmdReset_tests_SendsEventAndRejectsCommandWhenCommandByteIsGreaterT UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdReset_tests_SendsEventAndRejectsCommandWhenCommandByteIsGreaterThan_5 */ +} /* end Test_CF_CmdReset_tests_WhenCommandByteIsGreaterThan_5_SendEventAndRejectCommand */ -void Test_CF_CmdReset_tests_SendsEventWhenCommandByteIs_command_AndResetsHkCmdAndErrCount(void) +void Test_CF_CmdReset_tests_WhenCommandByteIs_command_AndResetHkCmdAndErrCountSendEvent(void) { /* Arrange */ cf_cmd_unionargs_t dummy_msg; @@ -339,9 +330,9 @@ void Test_CF_CmdReset_tests_SendsEventWhenCommandByteIs_command_AndResetsHkCmdAn UtAssert_True(CF_AppData.hk.counters.err == 0, "CF_AppData.hk.counters.err is %hu and should be 0 (was reset)", CF_AppData.hk.counters.err); - } /* end Test_CF_CmdReset_tests_SendsEventWhenCommandByteIs_command_AndResetsHkCmdAndErrCount */ + } /* end Test_CF_CmdReset_tests_WhenCommandByteIs_command_AndResetHkCmdAndErrCountSendEvent */ -void Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_fault_AndResetsAllHkFaultCount(void) +void Test_CF_CmdReset_tests_WhenCommandByteIs_fault_ResetAllHkFaultCountSendEventAndAcceptCommand(void) { /* Arrange */ cf_cmd_unionargs_t dummy_msg; @@ -429,9 +420,9 @@ void Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_fault_AndR UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); - } /* end Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_fault_AndResetsAllHkFaultCount */ + } /* end Test_CF_CmdReset_tests_WhenCommandByteIs_fault_ResetAllHkFaultCountSendEventAndAcceptCommand */ -void Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_up_AndResetsAllHkRecvCount(void) +void Test_CF_CmdReset_tests_WhenCommandByteIs_up_AndResetAllHkRecvCountSendEventAndAcceptCommand(void) { /* Arrange */ cf_cmd_unionargs_t dummy_msg; @@ -495,9 +486,9 @@ void Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_up_AndRese UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_up_AndResetsAllHkRecvCount */ +} /* end Test_CF_CmdReset_tests_WhenCommandByteIs_up_AndResetAllHkRecvCountSendEventAndAcceptCommand */ -void Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_down_AndResetsAllHkSentCount(void) +void Test_CF_CmdReset_tests_SWhenCommandByteIs_down_AndResetAllHkSentCountendEventAcceptCommand(void) { /* Arrange */ cf_cmd_unionargs_t dummy_msg; @@ -549,9 +540,9 @@ void Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_down_AndRe UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_down_AndResetsHkSentCount */ +} /* end Test_CF_CmdReset_tests_SWhenCommandByteIs_down_AndResetAllHkSentCountendEventAcceptCommand */ -void Test_CF_CmdReset_tests_SendsEventWhenCommandByteIs_all_AndResetsAllMemValues(void) +void Test_CF_CmdReset_tests_WhenCommandByteIs_all_AndResetAllMemValuesSendEvent(void) { /* Arrange */ cf_cmd_unionargs_t dummy_msg; @@ -632,7 +623,7 @@ void Test_CF_CmdReset_tests_SendsEventWhenCommandByteIs_all_AndResetsAllMemValue sizeof(&CF_AppData.hk.channel_hk[i].counters.sent), "sent channel %d was completely cleared to 0", i); } - } /* end Test_CF_CmdReset_tests_SendsEventWhenCommandByteIs_all_AndResetsAllMemValues */ + } /* end Test_CF_CmdReset_tests_WhenCommandByteIs_all_AndResetAllMemValuesSendEvent */ /* end CF_CmdReset tests */ @@ -643,12 +634,12 @@ void Test_CF_CmdReset_tests_SendsEventWhenCommandByteIs_all_AndResetsAllMemValue ** *******************************************************************************/ -void Test_CF_CmdTxFile_AcceptsCommandWhen_CF_CFDP_TxFile_Returns0(void) +void Test_CF_CmdTxFile_WhenCallTo_CF_CFDP_TxFile_Returns_0_AcceptCommand(void) { /* Arrange */ int32 dummy_CF_CFDP_TxFile_return = 0; - cf_cmd_tx_file_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = (CFE_MSG_Message_t*)&dummy_msg; + cf_cmd_tx_file_t dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; CF_CFDP_TxFile_context_t context_CF_CFDP_TxFile; UT_SetDefaultReturnValue(UT_KEY(CF_CFDP_TxFile), dummy_CF_CFDP_TxFile_return); @@ -700,13 +691,13 @@ void Test_CF_CmdTxFile_AcceptsCommandWhen_CF_CFDP_TxFile_Returns0(void) "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* Test_CF_CmdTxFile_AcceptsCommandWhen_CF_CFDP_TxFile_Returns0 */ +} /* Test_CF_CmdTxFile_WhenCallTo_CF_CFDP_TxFile_Returns_0_AcceptCommand */ -void Test_CF_CmdTxFile_RejectsCommandWhen_CF_CFDP_TxFile_ReturnsNon0(void) +void Test_CF_CmdTxFile_WhenCAllTo_CF_CFDP_TxFile_Returns_Non0_RejectCommand(void) { /* Arrange */ int32 dummy_CF_CFDP_TxFile_return = Any_int32_Except(0); - cf_cmd_tx_file_t dummy_msg; + cf_cmd_tx_file_t dummy_msg; CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; CF_CFDP_TxFile_context_t context_CF_CFDP_TxFile; @@ -758,7 +749,7 @@ void Test_CF_CmdTxFile_RejectsCommandWhen_CF_CFDP_TxFile_ReturnsNon0(void) "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* Test_CF_CmdTxFile_RejectsCommandWhen_CF_CFDP_TxFile_ReturnsNon0 */ +} /* Test_CF_CmdTxFile_WhenCAllTo_CF_CFDP_TxFile_Returns_Non0_RejectCommand */ /* end CF_CmdTxFile tests */ @@ -768,7 +759,7 @@ void Test_CF_CmdTxFile_RejectsCommandWhen_CF_CFDP_TxFile_ReturnsNon0(void) ** *******************************************************************************/ -void Test_CF_CmdPlaybackDir_AcceptsCommandWhen_CF_CFDP_PlaybackDir_Returns0(void) +void Test_CF_CmdPlaybackDir_WhenCAllTo_CF_CFDP_PlaybackDir_Returns_0_AcceptCommand(void) { /* Arrange */ int32 dummy_CF_CFDP_PlaybackDir_return = 0; @@ -827,9 +818,9 @@ void Test_CF_CmdPlaybackDir_AcceptsCommandWhen_CF_CFDP_PlaybackDir_Returns0(void "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdPlaybackDir_AcceptsCommandWhen_CF_CFDP_PlaybackDir_Returns0 */ +} /* end Test_CF_CmdPlaybackDir_WhenCAllTo_CF_CFDP_PlaybackDir_Returns_0_AcceptCommand */ -void Test_CF_CmdPlaybackDir_RejectsCommandWhen_CF_CmdPlaybackDir_ReturnsNon0(void) +void Test_CF_CmdPlaybackDir_WhenCallTo_CF_CmdPlaybackDir_Returns_non0_RejectCommand(void) { /* Arrange */ int32 dummy_CF_CFDP_PlaybackDir_return = Any_int32_Except(0); @@ -889,7 +880,7 @@ void Test_CF_CmdPlaybackDir_RejectsCommandWhen_CF_CmdPlaybackDir_ReturnsNon0(voi "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* Test_CF_CmdPlaybackDir_RejectsCommandWhen_CF_CmdPlaybackDir_ReturnsNon0 */ +} /* Test_CF_CmdPlaybackDir_WhenCallTo_CF_CmdPlaybackDir_Returns_non0_RejectCommand */ /* end CF_CmdTxFile tests */ @@ -899,7 +890,7 @@ void Test_CF_CmdPlaybackDir_RejectsCommandWhen_CF_CmdPlaybackDir_ReturnsNon0(voi ** *******************************************************************************/ -void Test_CF_DoChanAction_ALL_CHANNELS_Returns_1_WhenAny_fn_returns_1(void) +void Test_CF_DoChanAction_ALL_CHANNELS_WhenAny_fn_returns_1_Return_1(void) { /* Arrange */ cf_cmd_unionargs_t dummy_cmd; @@ -929,9 +920,9 @@ void Test_CF_DoChanAction_ALL_CHANNELS_Returns_1_WhenAny_fn_returns_1(void) "CF_DoChanAction returned %d and should be 1 (an fn returned 1)", local_result); -} /* end Test_CF_DoChanAction_ALL_CHANNELS_Returns_1_WhenAny_fn_returns_1 */ +} /* end Test_CF_DoChanAction_ALL_CHANNELS_WhenAny_fn_returns_1_Return_1 */ -void Test_CF_DoChanAction_ALL_CHANNELS_Returns_1_WhenAll_fn_return_1(void) +void Test_CF_DoChanAction_ALL_CHANNELS_WhenAll_fn_return_1_Return_1(void) { /* Arrange */ cf_cmd_unionargs_t dummy_cmd; @@ -959,9 +950,9 @@ void Test_CF_DoChanAction_ALL_CHANNELS_Returns_1_WhenAll_fn_return_1(void) "CF_DoChanAction returned %d and should be 1 (an fn returned 1)", local_result); -} /* end Test_CF_DoChanAction_ALL_CHANNELS_Returns_1_WhenAll_fn_return_1 */ +} /* end Test_CF_DoChanAction_ALL_CHANNELS_WhenAll_fn_return_1_Return_1 */ -void Test_CF_DoChanAction_ALL_CHANNELS_Returns_0_WhenNo_fn_returns_0(void) +void Test_CF_DoChanAction_ALL_CHANNELS_WhenNo_fn_returns_0_Return_0(void) { /* Arrange */ cf_cmd_unionargs_t dummy_cmd; @@ -989,9 +980,9 @@ void Test_CF_DoChanAction_ALL_CHANNELS_Returns_0_WhenNo_fn_returns_0(void) "CF_DoChanAction returned %d and should be 0 (all fn returned 0)", local_result); -} /* end Test_CF_DoChanAction_ALL_CHANNELS_Returns_0_WhenNo_fn_returns_0 */ +} /* end Test_CF_DoChanAction_ALL_CHANNELS_WhenNo_fn_returns_0_Return_0 */ -void Test_CF_DoChanAction_Returns_1_WhenChannel_fn_ActionReturns_1(void) +void Test_CF_DoChanAction_WhenChannel_fn_ActionReturns_1_Return_1(void) { /* Arrange */ cf_cmd_unionargs_t dummy_cmd; @@ -1019,9 +1010,9 @@ void Test_CF_DoChanAction_Returns_1_WhenChannel_fn_ActionReturns_1(void) "CF_DoChanAction returned %d and should be 1 (fn returned 1)", local_result); -} /* end Test_CF_DoChanAction_Returns_1_WhenChannel_fn_ActionReturns_1 */ +} /* end Test_CF_DoChanAction_WhenChannel_fn_ActionReturns_1_Return_1 */ -void Test_CF_DoChanAction_Returns_1_WhenChannel_fn_ActionReturns_0(void) +void Test_CF_DoChanAction_WhenChannel_fn_ActionReturns_0_Return_1(void) { /* Arrange */ cf_cmd_unionargs_t dummy_cmd; @@ -1049,9 +1040,9 @@ void Test_CF_DoChanAction_Returns_1_WhenChannel_fn_ActionReturns_0(void) "CF_DoChanAction returned %d and should be 0 (fn returned 0)", local_result); -} /* end Test_CF_DoChanAction_Returns_1_WhenChannel_fn_ActionReturns_0 */ +} /* end Test_CF_DoChanAction_WhenChannel_fn_ActionReturns_0_Return_1 */ -void Test_CF_DoChanAction_Returns_neg1_And_SendsEvent_WhenChanNumberEq_CF_NUM_CHANNELS(void) +void Test_CF_DoChanAction_WhenChanNumberEq_CF_NUM_CHANNELS_Return_neg1_And_SendEvent_(void) { /* Arrange */ cf_cmd_unionargs_t dummy_cmd; @@ -1083,9 +1074,9 @@ void Test_CF_DoChanAction_Returns_neg1_And_SendsEvent_WhenChanNumberEq_CF_NUM_CH "CF_DoChanAction returned %d and should be -1 (cmd->data.byte[0] >= CF_NUM_CHANNELS)", local_result); -} /* end Test_CF_DoChanAction_Returns_neg1_And_SendsEvent_WhenChanNumberEq_CF_NUM_CHANNELS */ +} /* end Test_CF_DoChanAction_WhenChanNumberEq_CF_NUM_CHANNELS_Return_neg1_And_SendEvent_ */ -void Test_CF_DoChanAction_Returns_neg1_And_SendsEvent_WhenBadChannelNumber(void) +void Test_CF_DoChanAction_WhenBadChannelNumber_Return_neg1_And_SendEvent(void) { /* Arrange */ cf_cmd_unionargs_t dummy_cmd; @@ -1130,7 +1121,7 @@ void Test_CF_DoChanAction_Returns_neg1_And_SendsEvent_WhenBadChannelNumber(void) "CF_DoChanAction returned %d and should be -1 (cmd->data.byte[0] >= CF_NUM_CHANNELS)", local_result); -} /* end Test_CF_DoChanAction_Returns_neg1_And_SendsEvent_WhenBadChannelNumber */ +} /* end Test_CF_DoChanAction_WhenBadChannelNumber_Return_neg1_And_SendEvent */ /* end CF_DoChanAction tests */ @@ -1140,7 +1131,7 @@ void Test_CF_DoChanAction_Returns_neg1_And_SendsEvent_WhenBadChannelNumber(void) ** *******************************************************************************/ -void Test_CF_DoFreezeThaw_Sets_frozen_ToGiven_context_barg_AndReturns_0(void) +void Test_CF_DoFreezeThaw_Set_frozen_ToGiven_context_barg_AndReturn_0(void) { /* Arrange */ uint8 arg_chan_num = Any_cf_channel(); @@ -1168,7 +1159,7 @@ void Test_CF_DoFreezeThaw_Sets_frozen_ToGiven_context_barg_AndReturns_0(void) "CF_DoFreezeThaw returned %d and should be 0 (only returns 0)", local_result); -} /* end Test_CF_DoFreezeThaw_Sets_frozen_ToGiven_context_barg_AndReturns_0 */ +} /* end Test_CF_DoFreezeThaw_Set_frozen_ToGiven_context_barg_AndReturn_0 */ /* end CF_DoFreezeThaw tests */ @@ -1178,7 +1169,7 @@ void Test_CF_DoFreezeThaw_Sets_frozen_ToGiven_context_barg_AndReturns_0(void) ** *******************************************************************************/ -void Test_CF_CmdFreeze_Sets_frozen_To_1_AndAcceptsCommand(void) +void Test_CF_CmdFreeze_Set_frozen_To_1_AndAcceptCommand(void) { /* Arrange */ cf_cmd_unionargs_t dummy_msg; @@ -1208,7 +1199,7 @@ void Test_CF_CmdFreeze_Sets_frozen_To_1_AndAcceptsCommand(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdFreeze_Sets_frozen_To_1_AndAcceptsCommand */ +} /* end Test_CF_CmdFreeze_Set_frozen_To_1_AndAcceptCommand */ /******************************************************************************* ** @@ -1216,7 +1207,7 @@ void Test_CF_CmdFreeze_Sets_frozen_To_1_AndAcceptsCommand(void) ** *******************************************************************************/ -void Test_CF_CmdFThaw_Sets_frozen_To_0_AndAcceptsCommand(void) +void Test_CF_CmdFThaw_Set_frozen_To_0_AndAcceptCommand(void) { /* Arrange */ cf_cmd_unionargs_t dummy_msg; @@ -1247,7 +1238,7 @@ void Test_CF_CmdFThaw_Sets_frozen_To_0_AndAcceptsCommand(void) "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdFThaw_Sets_frozen_To_0_AndAcceptsCommand */ +} /* end Test_CF_CmdFThaw_Set_frozen_To_0_AndAcceptCommand */ /******************************************************************************* ** @@ -1255,7 +1246,7 @@ void Test_CF_CmdFThaw_Sets_frozen_To_0_AndAcceptsCommand(void) ** *******************************************************************************/ -void Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Returns_NULL_NoTransactionFound(void) +void Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_WhenNoTransactionFoundReturn_NULL(void) { /* Arrange */ cf_transaction_seq_t arg_ts = Any_cf_transaction_seq_t(); @@ -1277,22 +1268,18 @@ void Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Returns_NULL_NoTran /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_FindTransactionBySequenceNumber, CF_NUM_CHANNELS); - UtAssert_True(context_CF_CFDP_FTBSN.c == CF_AppData.engine.channels, - "CF_CFDP_FTBSN (abbr.) received c %p and should be %p (CF_AppData.engine.channels)", - context_CF_CFDP_FTBSN.c, CF_AppData.engine.channels); + UtAssert_ADDRESS_EQ(context_CF_CFDP_FTBSN.c, CF_AppData.engine.channels); UtAssert_True(context_CF_CFDP_FTBSN.transaction_sequence_number == arg_ts, "CF_CFDP_FTBSN (abbr.) received transaction_sequence_number %u and should be %u (ts)", context_CF_CFDP_FTBSN.transaction_sequence_number, arg_ts); UtAssert_True(context_CF_CFDP_FTBSN.src_eid == arg_eid, "CF_CFDP_FTBSN (abbr.) received src_eid %u and should be %u (eid)", context_CF_CFDP_FTBSN.src_eid, arg_eid); - UtAssert_True(local_result == expected_result, - "CF_CFDP_FindTransactionBySequenceNumberAllChannels returned %p and should be %p (NULL)", - local_result, expected_result); + UtAssert_ADDRESS_EQ(local_result, expected_result); -} /* end Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Returns_NULL_NoTransactionFound */ +} /* end Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_WhenNoTransactionFoundReturn_NULL */ -void Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Returns_TransactionFound(void) +void Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Return_TransactionFound(void) { /* Arrange */ cf_transaction_seq_t arg_ts = Any_cf_transaction_seq_t(); @@ -1326,9 +1313,7 @@ void Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Returns_Transaction UtAssert_STUB_COUNT(CF_CFDP_FindTransactionBySequenceNumber, number_transaction_match + 1); for(i = 0; i < number_transaction_match; ++i) { - UtAssert_True(contexts_CF_CFDP_FTBSN[i].c == CF_AppData.engine.channels + i, - "CF_CFDP_FTBSN (abbr.) received c %p and should be %p (CF_AppData.engine.channels)", - contexts_CF_CFDP_FTBSN[i].c, CF_AppData.engine.channels + i); + UtAssert_ADDRESS_EQ(contexts_CF_CFDP_FTBSN[i].c, CF_AppData.engine.channels + i); UtAssert_True(contexts_CF_CFDP_FTBSN[i].transaction_sequence_number == arg_ts, "CF_CFDP_FTBSN (abbr.) received transaction_sequence_number %u and should be %u (ts)", contexts_CF_CFDP_FTBSN[i].transaction_sequence_number, arg_ts); @@ -1336,20 +1321,16 @@ void Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Returns_Transaction "CF_CFDP_FTBSN (abbr.) received src_eid %u and should be %u (eid)", contexts_CF_CFDP_FTBSN[i].src_eid, arg_eid); } - UtAssert_True(contexts_CF_CFDP_FTBSN[i].c == CF_AppData.engine.channels + i, - "CF_CFDP_FTBSN (abbr.) received c %p and should be %p (CF_AppData.engine.channels)", - contexts_CF_CFDP_FTBSN[i].c, CF_AppData.engine.channels + i); + UtAssert_ADDRESS_EQ(contexts_CF_CFDP_FTBSN[i].c, CF_AppData.engine.channels + i); UtAssert_True(contexts_CF_CFDP_FTBSN[i].transaction_sequence_number == arg_ts, "CF_CFDP_FTBSN (abbr.) received transaction_sequence_number %u and should be %u (ts)", contexts_CF_CFDP_FTBSN[i].transaction_sequence_number, arg_ts); UtAssert_True(contexts_CF_CFDP_FTBSN[i].src_eid == arg_eid, "CF_CFDP_FTBSN (abbr.) received src_eid %u and should be %u (eid)", contexts_CF_CFDP_FTBSN[i].src_eid, arg_eid); - UtAssert_True(local_result == expected_result, - "CF_CFDP_FTBSNAC (abbr.) returned %p and should be %p (matched transaction)", - local_result, expected_result); + UtAssert_ADDRESS_EQ(local_result, expected_result); -} /* end Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Returns_NULL_NoTransactionFound */ +} /* end Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Return_TransactionFound */ /******************************************************************************* @@ -1358,7 +1339,7 @@ void Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Returns_Transaction ** *******************************************************************************/ -void Test_CF_TsnChanAction_SendsEvent_cmd_chan_Eq_COMPOUND_KEY_TransactionNotFoundAndReturns_neg1_Fail(void) +void Test_CF_TsnChanAction_SendEvent_cmd_chan_Eq_COMPOUND_KEY_TransactionNotFoundAndReturn_neg1_Fail(void) { /* Arrange */ cf_cmd_transaction_t dummy_cmd; @@ -1405,9 +1386,9 @@ void Test_CF_TsnChanAction_SendsEvent_cmd_chan_Eq_COMPOUND_KEY_TransactionNotFou "CFE_EVS_SendEvent received %u and should have received %u (CF_EID_ERR_CMD_TRANS_NOT_FOUND)", EventID, CF_EID_ERR_CMD_TRANS_NOT_FOUND); UtAssert_STUB_COUNT(Dummy_CF_TsnChanAction_fn_t, 0); -} /* end Test_CF_TsnChanAction_SendsEvent_cmd_chan_Eq_COMPOUND_KEY_TransactionNotFoundAndReturns_neg1_Fail */ +} /* end Test_CF_TsnChanAction_SendEvent_cmd_chan_Eq_COMPOUND_KEY_TransactionNotFoundAndReturn_neg1_Fail */ -void Test_CF_TsnChanAction_cmd_chan_Eq_COMPOUND_KEY_TransactionFoundRuns_fn_AndReturns_CFE_SUCCESS(void) +void Test_CF_TsnChanAction_cmd_chan_Eq_COMPOUND_KEY_TransactionFoundRun_fn_AndReturn_CFE_SUCCESS(void) { /* Arrange */ cf_cmd_transaction_t dummy_cmd; @@ -1451,15 +1432,11 @@ void Test_CF_TsnChanAction_cmd_chan_Eq_COMPOUND_KEY_TransactionFoundRuns_fn_AndR local_result, CFE_SUCCESS); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); UtAssert_STUB_COUNT(Dummy_CF_TsnChanAction_fn_t, 1); - UtAssert_True(context_Dummy_CF_TsnChanAction_fn_t.t == &dummy_t, - "fn received t %p and should be %p (return from CF_CFDP_FTBSNAC (abbr.))", - context_Dummy_CF_TsnChanAction_fn_t.t, &dummy_t); - UtAssert_True(context_Dummy_CF_TsnChanAction_fn_t.context == arg_context, - "fn received context %p and should be %p (context)", - context_Dummy_CF_TsnChanAction_fn_t.context, arg_context); -} /* end Test_CF_TsnChanAction_cmd_chan_Eq_COMPOUND_KEY_TransactionFoundRuns_fn_AndReturns_CFE_SUCCESS */ + UtAssert_True(context_Dummy_CF_TsnChanAction_fn_t.t == &dummy_t, "context_Dummy_CF_TsnChanAction_fn_t.t == &dummy_t"); + UtAssert_True(context_Dummy_CF_TsnChanAction_fn_t.context == arg_context, "context_Dummy_CF_TsnChanAction_fn_t.context == arg_context"); +} /* end Test_CF_TsnChanAction_cmd_chan_Eq_COMPOUND_KEY_TransactionFoundRun_fn_AndReturn_CFE_SUCCESS */ -void Test_CF_TsnChanAction_cmd_chan_Eq_ALL_CHANNELS_Returns_CF_TraverseAllTransactions_All_Channels(void) +void Test_CF_TsnChanAction_cmd_chan_Eq_ALL_CHANNELS_Return_CF_TraverseAllTransactions_All_Channels(void) { /* Arrange */ cf_cmd_transaction_t dummy_cmd; @@ -1494,7 +1471,7 @@ void Test_CF_TsnChanAction_cmd_chan_Eq_ALL_CHANNELS_Returns_CF_TraverseAllTransa "CF_TsnChanAction returned %d and should be %d (ret from CF_TraverseAllTransactions_All_Channels)", local_result, expected_result); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} /* end Test_CF_TsnChanAction_cmd_chan_Eq_ALL_CHANNELS_Returns_CF_TraverseAllTransactions_All_Channels */ +} /* end Test_CF_TsnChanAction_cmd_chan_Eq_ALL_CHANNELS_Return_CF_TraverseAllTransactions_All_Channels */ void Test_CF_TsnChanAction_cmd_chan_IsASingleChannel(void) { @@ -1527,9 +1504,9 @@ void Test_CF_TsnChanAction_cmd_chan_IsASingleChannel(void) local_result, expected_result); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); /* TODO: values for context_CF_TraverseAllTransactions need checked!! */ -} /* end Test_CF_TsnChanAction_cmd_chan_Eq_ALL_CHANNELS_Returns_CF_TraverseAllTransactions_All_Channels */ +} /* end Test_CF_TsnChanAction_cmd_chan_Eq_ALL_CHANNELS_Return_CF_TraverseAllTransactions_All_Channels */ -void Test_CF_TsnChanAction_cmd_FailsBecause_cmd_chan_IsInvalid(void) +void Test_CF_TsnChanAction_cmd_FailBecause_cmd_chan_IsInvalid(void) { /* Arrange */ cf_cmd_transaction_t dummy_cmd; @@ -1557,7 +1534,7 @@ void Test_CF_TsnChanAction_cmd_FailsBecause_cmd_chan_IsInvalid(void) UtAssert_True(EventID == CF_EID_ERR_CMD_TSN_CHAN_INVALID, "CFE_EVS_SendEvent received %u and should have received %u (CF_EID_ERR_CMD_TSN_CHAN_INVALID)", EventID, CF_EID_ERR_CMD_TSN_CHAN_INVALID); -} /* end Test_CF_TsnChanAction_cmd_FailsBecause_cmd_chan_IsInvalid */ +} /* end Test_CF_TsnChanAction_cmd_FailBecause_cmd_chan_IsInvalid */ /******************************************************************************* ** @@ -1567,15 +1544,15 @@ void Test_CF_TsnChanAction_cmd_FailsBecause_cmd_chan_IsInvalid(void) void Test_CF_DoSuspRes__Asserts_t_Is_NULL(void) { - /* Arrange */ + // /* Arrange */ - /* Act */ + // /* Act */ - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert"); } /* end Test_CF_DoSuspRes__Asserts_t_Is_NULL */ -void Test_CF_DoSuspRes__Sets_context_same_To_1_suspended_Eq_action(void) +void Test_CF_DoSuspRes__Set_context_same_To_1_suspended_Eq_action(void) { /* Arrange */ transaction_t dummy_t; @@ -1597,9 +1574,9 @@ void Test_CF_DoSuspRes__Sets_context_same_To_1_suspended_Eq_action(void) UtAssert_True(arg_context->same == 1, "CF_DoSuspRes_ set context->same to %d and should be 1 (direct set)", arg_context->same); -} /* end Test_CF_DoSuspRes__Sets_context_same_To_1_suspended_Eq_action */ +} /* end Test_CF_DoSuspRes__Set_context_same_To_1_suspended_Eq_action */ -void Test_CF_DoSuspRes__Sets_suspended_To_action_Because_suspended_NotEq_action(void) +void Test_CF_DoSuspRes__When_suspended_NotEqTo_action_Set_suspended_To_action(void) { /* Arrange */ transaction_t dummy_t; @@ -1621,7 +1598,7 @@ void Test_CF_DoSuspRes__Sets_suspended_To_action_Because_suspended_NotEq_action( UtAssert_True(arg_t->flags.all.suspended == arg_context->action, "CF_DoSuspRes_ set arg_t->flags.all.suspended to %d and should be %d (context->action)", arg_t->flags.all.suspended, arg_context->action); -} /* end Test_CF_DoSuspRes__Sets_context_same_To_1_suspended_Eq_action */ +} /* end Test_CF_DoSuspRes__When_suspended_NotEqTo_action_Set_suspended_To_action */ /******************************************************************************* ** @@ -1629,7 +1606,7 @@ void Test_CF_DoSuspRes__Sets_suspended_To_action_Because_suspended_NotEq_action( ** *******************************************************************************/ -void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasChangedTo_1_SendsEventAndRejectsCmd(void) +void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasChangedTo_1_SendEventAndRejectCmd(void) { /* Arrange */ transaction_t dummy_t_instance; @@ -1662,7 +1639,6 @@ void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasChange /* Act */ CF_DoSuspRes(arg_cmd, arg_action); - /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(EventID == CF_EID_ERR_CMD_SUSPRES_SAME, @@ -1672,13 +1648,13 @@ void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasChange UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasChangedTo_1_SendsEventAndRejectsCmd */ +} /* end Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasChangedTo_1_SendEventAndRejectCmd */ -/* TODO: Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasChangedTo_1_SendsEventAndRejectsCmd -** and Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasNotChangedFrom_0_SendsEventAndRejectsCmd +/* TODO: Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasChangedTo_1_SendEventAndRejectCmd +** and Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasNotChangedFrom_0_SendEventAndRejectCmd ** are really unable to be told apart because they have the exact same results, there is no "actual" way to know these ** test's results are indicative of what is actually occurring except by examining the actual tests */ -void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasChangedTo_1_SendsEventAndRejectsCmd(void) +void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasChangedTo_1_SendEventAndRejectCmd(void) { /* Arrange */ cf_cmd_transaction_t dummy_cmd; @@ -1708,7 +1684,6 @@ void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasCha /* Act */ CF_DoSuspRes(arg_cmd, arg_action); - /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(EventID == CF_EID_ERR_CMD_SUSPRES_CHAN, @@ -1718,9 +1693,9 @@ void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasCha UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasChangedTo_1_SendsEventAndRejectsCmd */ +} /* end Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasChangedTo_1_SendEventAndRejectCmd */ -void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasNotChangedFrom_0_SendsEventAndRejectsCmd(void) +void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasNotChangedFrom_0_SendEventAndRejectCmd(void) { /* Arrange */ cf_cmd_transaction_t dummy_cmd; @@ -1750,7 +1725,6 @@ void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasNot /* Act */ CF_DoSuspRes(arg_cmd, arg_action); - /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(EventID == CF_EID_ERR_CMD_SUSPRES_CHAN, @@ -1760,9 +1734,9 @@ void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasNot UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasNotChangedFrom_0_SendsEventAndRejectsCmd */ +} /* end Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasNotChangedFrom_0_SendEventAndRejectCmd */ -void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasNotChangedFrom_0_AcceptsCmd(void) +void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasNotChangedFrom_0_AcceptCmd(void) { /* Arrange */ transaction_t dummy_t_instance; @@ -1795,14 +1769,13 @@ void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasNotCha /* Act */ CF_DoSuspRes(arg_cmd, arg_action); - /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); /* Assert CF_CmdAcc */ UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasNotChangedFrom_0_AcceptsCmd */ +} /* end Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasNotChangedFrom_0_AcceptCmd */ @@ -1811,12 +1784,12 @@ void Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasNotCha ** CF_CmdSuspend tests ** *******************************************************************************/ -/* TODO: SendEvent needs to be able to check all values before action = 1 can be verified in Test_CF_CmdSuspend_Calls_CF_DoSuspRes_WithGiven_msg_And_action_1 */ -void Test_CF_CmdSuspend_Calls_CF_DoSuspRes_WithGiven_msg_And_action_1(void) +/* TODO: SendEvent needs to be able to check all values before action = 1 can be verified in Test_CF_CmdSuspend_Call_CF_DoSuspRes_WithGiven_msg_And_action_1 */ +void Test_CF_CmdSuspend_Call_CF_DoSuspRes_WithGiven_msg_And_action_1(void) { /* Arrange */ cf_cmd_transaction_t dummy_cmd; - CFE_SB_Buffer_t* arg_cmd = (CFE_MSG_Message_t*)&dummy_cmd; + CFE_SB_Buffer_t* arg_cmd = (CFE_SB_Buffer_t*)&dummy_cmd; uint16 local_EventID[2]; /* Arrange unstubbable: CF_DoSuspRes */ @@ -1834,7 +1807,6 @@ void Test_CF_CmdSuspend_Calls_CF_DoSuspRes_WithGiven_msg_And_action_1(void) /* Act */ CF_CmdSuspend(arg_cmd); - /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); /* Assert CF_TsnChanAction */ @@ -1849,7 +1821,7 @@ void Test_CF_CmdSuspend_Calls_CF_DoSuspRes_WithGiven_msg_And_action_1(void) UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdSuspend_Calls_CF_DoSuspRes_WithGiven_msg_And_action_1 */ +} /* end Test_CF_CmdSuspend_Call_CF_DoSuspRes_WithGiven_msg_And_action_1 */ /* end CF_CmdSuspend tests */ @@ -1858,12 +1830,12 @@ void Test_CF_CmdSuspend_Calls_CF_DoSuspRes_WithGiven_msg_And_action_1(void) ** CF_CmdResume tests ** *******************************************************************************/ -/* TODO: SendEvent needs to be able to check all values before action = 0 can be verified in Test_CF_CmdResume_Calls_CF_DoSuspRes_WithGiven_msg_And_action_0 */ -void Test_CF_CmdResume_Calls_CF_DoSuspRes_WithGiven_msg_And_action_0(void) +/* TODO: SendEvent needs to be able to check all values before action = 0 can be verified in Test_CF_CmdResume_Call_CF_DoSuspRes_WithGiven_msg_And_action_0 */ +void Test_CF_CmdResume_Call_CF_DoSuspRes_WithGiven_msg_And_action_0(void) { /* Arrange */ cf_cmd_transaction_t dummy_cmd; - CFE_SB_Buffer_t* arg_cmd = (CFE_MSG_Message_t*)&dummy_cmd; + CFE_SB_Buffer_t* arg_cmd = (CFE_SB_Buffer_t*)&dummy_cmd; uint16 local_EventID[2]; /* Arrange unstubbable: CF_DoSuspRes */ @@ -1881,7 +1853,6 @@ void Test_CF_CmdResume_Calls_CF_DoSuspRes_WithGiven_msg_And_action_0(void) /* Act */ CF_CmdResume(arg_cmd); - /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 2); /* Assert CF_TsnChanAction */ @@ -1896,7 +1867,7 @@ void Test_CF_CmdResume_Calls_CF_DoSuspRes_WithGiven_msg_And_action_0(void) UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdResume_Calls_CF_DoSuspRes_WithGiven_msg_And_action_0 */ +} /* end Test_CF_CmdResume_Call_CF_DoSuspRes_WithGiven_msg_And_action_0 */ /* end CF_CmdResume tests */ @@ -1906,7 +1877,7 @@ void Test_CF_CmdResume_Calls_CF_DoSuspRes_WithGiven_msg_And_action_0(void) ** *******************************************************************************/ -void Test_CF_CmdCancel__Calls_CF_CFDP_CancelTransaction_WithGiven_t(void) +void Test_CF_CmdCancel__Call_CF_CFDP_CancelTransaction_WithGiven_t(void) { /* Arrange */ transaction_t dummy_t; @@ -1921,11 +1892,9 @@ void Test_CF_CmdCancel__Calls_CF_CFDP_CancelTransaction_WithGiven_t(void) CF_CmdCancel_(arg_t, arg_ignored); /* Assert */ - UtAssert_True(context_CF_CFDP_CancelTransaction == arg_t, - "CF_CFDP_CancelTransaction was called with transaction_t* %p and should be %p (t)", - context_CF_CFDP_CancelTransaction, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_CancelTransaction, arg_t); -} /* end Test_CF_CmdCancel__Calls_CF_CFDP_CancelTransaction_WithGiven_t */ +} /* end Test_CF_CmdCancel__Call_CF_CFDP_CancelTransaction_WithGiven_t */ /******************************************************************************* ** @@ -1933,11 +1902,11 @@ void Test_CF_CmdCancel__Calls_CF_CFDP_CancelTransaction_WithGiven_t(void) ** *******************************************************************************/ -void Test_CF_CmdCancel_Calls_CF_CmdCond_WithNotted_CF_TsnChanAction(void) +void Test_CF_CmdCancel_Call_CF_CmdCond_WithNotted_CF_TsnChanAction(void) { /* Arrange */ cf_cmd_transaction_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = (CFE_MSG_Message_t*)&dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; //TODO: CF_TsnChanAction result is default with no setup; it should be controlled, but in the essence of time this default value is used to show functionality of the code /* Arrange unstubbable: CF_TsnChanAction */ @@ -1961,20 +1930,14 @@ void Test_CF_CmdCancel_Calls_CF_CmdCond_WithNotted_CF_TsnChanAction(void) /* Assert */ /* Assert for CF_TsnChanAction */ UtAssert_STUB_COUNT(CF_TraverseAllTransactions, 1); - UtAssert_True(context_CF_TraverseAllTransactions.c == CF_AppData.engine.channels + ((cf_cmd_transaction_t*)arg_msg)->chan, - "CF_TraverseAllTransactions received c %p and should be %p (CF_AppData.engine.channels+cmd->chan)", - context_CF_TraverseAllTransactions.c, CF_AppData.engine.channels + ((cf_cmd_transaction_t*)arg_msg)->chan); - UtAssert_True(context_CF_TraverseAllTransactions.fn == CF_CmdCancel_, - "CF_TraverseAllTransactions received fn %p and should be %p (CF_CmdCancel_)", - context_CF_TraverseAllTransactions.fn, CF_CmdCancel_); - UtAssert_True(context_CF_TraverseAllTransactions.context == NULL, - "CF_TraverseAllTransactions received context %p and should be %p (NULL)", - context_CF_TraverseAllTransactions.context, NULL); + UtAssert_ADDRESS_EQ(context_CF_TraverseAllTransactions.c, CF_AppData.engine.channels + ((cf_cmd_transaction_t*)arg_msg)->chan); + UtAssert_True(context_CF_TraverseAllTransactions.fn == CF_CmdCancel_, "context_CF_TraverseAllTransactions.fn == CF_CmdCancel_"); + UtAssert_ADDRESS_EQ(context_CF_TraverseAllTransactions.context, NULL); /* Assert for CF_CmdRej */ UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdCancel_Calls_CF_CmdCond_WithNotted_CF_TsnChanAction */ +} /* end Test_CF_CmdCancel_Call_CF_CmdCond_WithNotted_CF_TsnChanAction */ /******************************************************************************* ** @@ -1982,7 +1945,7 @@ void Test_CF_CmdCancel_Calls_CF_CmdCond_WithNotted_CF_TsnChanAction(void) ** *******************************************************************************/ -void Test_CF_CmdAbandon__Calls_CF_CFDP_ResetTransaction_WithGiven_t_And_0(void) +void Test_CF_CmdAbandon__Call_CF_CFDP_ResetTransaction_WithGiven_t_And_0(void) { /* Arrange */ transaction_t dummy_t; @@ -1997,14 +1960,12 @@ void Test_CF_CmdAbandon__Calls_CF_CFDP_ResetTransaction_WithGiven_t_And_0(void) CF_CmdAbandon_(arg_t, arg_ignored); /* Assert */ - UtAssert_True(context_CF_CFDP_ResetTransaction.t == arg_t, - "CF_CFDP_CancelTransaction was called with transaction_t* %p and should be %p (t)", - context_CF_CFDP_ResetTransaction.t, arg_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetTransaction.t, arg_t); UtAssert_True(context_CF_CFDP_ResetTransaction.keep_history == 0, "CF_CFDP_CancelTransaction was called with int %d and should be 0 (constant in call)", context_CF_CFDP_ResetTransaction.keep_history); -} /* end Test_CF_CmdAbandon__Calls_CF_CFDP_ResetTransaction_WithGiven_t_And_0 */ +} /* end Test_CF_CmdAbandon__Call_CF_CFDP_ResetTransaction_WithGiven_t_And_0 */ /******************************************************************************* ** @@ -2012,11 +1973,11 @@ void Test_CF_CmdAbandon__Calls_CF_CFDP_ResetTransaction_WithGiven_t_And_0(void) ** *******************************************************************************/ -void Test_CF_CmdAbandon_Calls_CF_CmdCond_WithNotted_CF_TsnChanAction(void) +void Test_CF_CmdAbandon_Call_CF_CmdCond_WithNotted_CF_TsnChanAction(void) { /* Arrange */ cf_cmd_transaction_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = (CFE_MSG_Message_t*)&dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; //TODO: CF_TsnChanAction result is default with no setup; it should be controlled, but in the essence of time this default value is used to show functionality of the code /* Arrange unstubbable: CF_TsnChanAction */ @@ -2040,20 +2001,14 @@ void Test_CF_CmdAbandon_Calls_CF_CmdCond_WithNotted_CF_TsnChanAction(void) /* Assert */ /* Assert for CF_TsnChanAction */ UtAssert_STUB_COUNT(CF_TraverseAllTransactions, 1); - UtAssert_True(context_CF_TraverseAllTransactions.c == CF_AppData.engine.channels + ((cf_cmd_transaction_t*)arg_msg)->chan, - "CF_TraverseAllTransactions received c %p and should be %p (CF_AppData.engine.channels+cmd->chan)", - context_CF_TraverseAllTransactions.c, CF_AppData.engine.channels + ((cf_cmd_transaction_t*)arg_msg)->chan); - UtAssert_True(context_CF_TraverseAllTransactions.fn == CF_CmdAbandon_, - "CF_TraverseAllTransactions received fn %p and should be %p (CF_CmdAbandon_)", - context_CF_TraverseAllTransactions.fn, CF_CmdAbandon_); - UtAssert_True(context_CF_TraverseAllTransactions.context == NULL, - "CF_TraverseAllTransactions received context %p and should be %p (NULL)", - context_CF_TraverseAllTransactions.context, NULL); + UtAssert_ADDRESS_EQ(context_CF_TraverseAllTransactions.c, CF_AppData.engine.channels + ((cf_cmd_transaction_t*)arg_msg)->chan); + UtAssert_True(context_CF_TraverseAllTransactions.fn == CF_CmdAbandon_, "context_CF_TraverseAllTransactions.fn == CF_CmdAbandon_"); + UtAssert_ADDRESS_EQ(context_CF_TraverseAllTransactions.context, NULL); /* Assert for CF_CmdRej */ UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdAbandon_Calls_CF_CmdCond_WithNotted_CF_TsnChanAction */ +} /* end Test_CF_CmdAbandon_Call_CF_CmdCond_WithNotted_CF_TsnChanAction */ /******************************************************************************* ** @@ -2061,7 +2016,7 @@ void Test_CF_CmdAbandon_Calls_CF_CmdCond_WithNotted_CF_TsnChanAction(void) ** *******************************************************************************/ -void Test_CF_DoEnableDisableDequeue_Sets_chan_num_EnabledFlagTo_context_barg(void) +void Test_CF_DoEnableDisableDequeue_Set_chan_num_EnabledFlagTo_context_barg(void) { /* Arrange */ cf_config_table_t dummy_config_table; @@ -2080,7 +2035,7 @@ void Test_CF_DoEnableDisableDequeue_Sets_chan_num_EnabledFlagTo_context_barg(voi "Channel %u dequeue_enabled is %u and should be %u (context->barg)", arg_chan_num, CF_AppData.config_table->chan[arg_chan_num].dequeue_enabled, dummy_context.barg); -} /* end Test_CF_DoEnableDisableDequeue_Sets_chan_num_EnabledFlagTo_context_barg */ +} /* end Test_CF_DoEnableDisableDequeue_Set_chan_num_EnabledFlagTo_context_barg */ /******************************************************************************* ** @@ -2088,7 +2043,7 @@ void Test_CF_DoEnableDisableDequeue_Sets_chan_num_EnabledFlagTo_context_barg(voi ** *******************************************************************************/ -void Test_CF_CmdEnableDequeue_Calls_CmdCond_WithResultsOf_CF_DoChanAction(void) +void Test_CF_CmdEnableDequeue_Call_CmdCond_WithResultsOf_CF_DoChanAction(void) { /* Arrange */ cf_cmd_unionargs_t dummy_msg; @@ -2121,7 +2076,7 @@ void Test_CF_CmdEnableDequeue_Calls_CmdCond_WithResultsOf_CF_DoChanAction(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d\nACCEPTANCE OF COMMAND (+1) SHOULD BE THE BEHAVIOR BUT IT IS NOT", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdEnableDequeue_Calls_CmdCond_WithResultsOf_CF_DoChanAction */ +} /* end Test_CF_CmdEnableDequeue_Call_CmdCond_WithResultsOf_CF_DoChanAction */ /******************************************************************************* ** @@ -2129,7 +2084,7 @@ void Test_CF_CmdEnableDequeue_Calls_CmdCond_WithResultsOf_CF_DoChanAction(void) ** *******************************************************************************/ -void Test_CF_CmdDisableDequeue_Calls_CmdCond_WithResultsOf_CF_DoChanAction(void) +void Test_CF_CmdDisableDequeue_Call_CmdCond_WithResultsOf_CF_DoChanAction(void) { /* Arrange */ cf_cmd_unionargs_t dummy_msg; @@ -2162,7 +2117,7 @@ void Test_CF_CmdDisableDequeue_Calls_CmdCond_WithResultsOf_CF_DoChanAction(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdDisableDequeue_Calls_CmdCond_WithResultsOf_CF_DoChanAction */ +} /* end Test_CF_CmdDisableDequeue_Call_CmdCond_WithResultsOf_CF_DoChanAction */ /******************************************************************************* @@ -2171,7 +2126,7 @@ void Test_CF_CmdDisableDequeue_Calls_CmdCond_WithResultsOf_CF_DoChanAction(void) ** *******************************************************************************/ -void Test_CF_DoEnableDisablePolldir_SetsAllPolldirsInChannelEnabledTo_context_barg_When_ALL_CHANNELS(void) +void Test_CF_DoEnableDisablePolldir_When_ALL_CHANNELS_SetAllPolldirsInChannelEnabledTo_context_barg(void) { /* Arrange */ uint8 arg_chan_num = Any_cf_channel(); @@ -2209,9 +2164,9 @@ void Test_CF_DoEnableDisablePolldir_SetsAllPolldirsInChannelEnabledTo_context_ba UtAssert_True(local_result == 0, "CF_DoEnableDisablePolldir returned %d and should be 0", local_result); -} /* end Test_CF_DoEnableDisablePolldir_SetsAllPolldirsInChannelEnabledTo_context_barg_When_ALL_CHANNELS */ +} /* end Test_CF_DoEnableDisablePolldir_When_ALL_CHANNELS_SetAllPolldirsInChannelEnabledTo_context_barg */ -void Test_CF_DoEnableDisablePolldir_SetsPolldirFrom_context_ChannelEnabledTo_context_barg_WhenSetToSpecificPolldir(void) +void Test_CF_DoEnableDisablePolldir_WhenSetToSpecificPolldirSetPolldirFrom_context_ChannelEnabledTo_context_barg(void) { /* Arrange */ uint8 arg_chan_num = Any_cf_channel(); @@ -2245,9 +2200,9 @@ void Test_CF_DoEnableDisablePolldir_SetsPolldirFrom_context_ChannelEnabledTo_con UtAssert_True(local_result == 0, "CF_DoEnableDisablePolldir returned %d and should be 0", local_result); -} /* end Test_CF_DoEnableDisablePolldir_SetsPolldirFrom_context_ChannelEnabledTo_context_barg_WhenSetToSpecificPolldir */ +} /* end Test_CF_DoEnableDisablePolldir_WhenSetToSpecificPolldirSetPolldirFrom_context_ChannelEnabledTo_context_barg */ -void Test_CF_DoEnableDisablePolldir_FailsPolldirEq_CF_MAX_POLLING_DIR_PER_CHAN_AndSendsEvent(void) +void Test_CF_DoEnableDisablePolldir_FailPolldirEq_CF_MAX_POLLING_DIR_PER_CHAN_AndSendEvent(void) { /* Arrange */ uint8 arg_chan_num = Any_cf_channel(); @@ -2281,9 +2236,9 @@ void Test_CF_DoEnableDisablePolldir_FailsPolldirEq_CF_MAX_POLLING_DIR_PER_CHAN_A UtAssert_True(local_result == -1, "CF_DoEnableDisablePolldir returned %d and should be -1", local_result); -} /* end Test_CF_DoEnableDisablePolldir_FailsPolldirEq_CF_MAX_POLLING_DIR_PER_CHAN_AndSendsEvent */ +} /* end Test_CF_DoEnableDisablePolldir_FailPolldirEq_CF_MAX_POLLING_DIR_PER_CHAN_AndSendEvent */ -void Test_CF_DoEnableDisablePolldir_FailsAnyBadPolldirSendsEvent(void) +void Test_CF_DoEnableDisablePolldir_FailAnyBadPolldirSendEvent(void) { /* Arrange */ uint8 arg_chan_num = Any_cf_channel(); @@ -2317,7 +2272,7 @@ void Test_CF_DoEnableDisablePolldir_FailsAnyBadPolldirSendsEvent(void) UtAssert_True(local_result == -1, "CF_DoEnableDisablePolldir returned %d and should be -1", local_result); -} /* end Test_CF_DoEnableDisablePolldir_FailsAnyBadPolldirSendsEvent */ +} /* end Test_CF_DoEnableDisablePolldir_FailAnyBadPolldirSendEvent */ /******************************************************************************* @@ -2333,7 +2288,7 @@ void Test_CF_CmdEnablePolldir_SuccessWhenActionSuccess(void) uint8 dummy_channel = Any_cf_channel(); uint8 dummy_polldir = Any_cf_polldir(); cf_cmd_unionargs_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = (CFE_MSG_Message_t*)&dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; CF_AppData.config_table = &dummy_config_table; @@ -2366,10 +2321,9 @@ void Test_CF_CmdEnablePolldir_FailWhenActionFail(void) { /* Arrange */ uint8 dummy_channel = Any_cf_channel(); - uint8 error_polldir = - Any_uint8_BetweenInclusive(CF_MAX_POLLING_DIR_PER_CHAN, ALL_CHANNELS - 1); + uint8 error_polldir = Any_uint8_BetweenInclusive(CF_MAX_POLLING_DIR_PER_CHAN, ALL_CHANNELS - 1); cf_cmd_unionargs_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = (CFE_MSG_Message_t*)&dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; /* Arrange unstubbable: CF_DoChanAction */ dummy_msg.data.byte[0] = dummy_channel; @@ -2408,7 +2362,7 @@ void Test_CF_CmdDisablePolldir_SuccessWhenActionSuccess(void) uint8 dummy_channel = Any_cf_channel(); uint8 dummy_polldir = Any_cf_polldir(); cf_cmd_unionargs_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = (CFE_MSG_Message_t*)&dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; CF_AppData.config_table = &dummy_config_table; @@ -2441,10 +2395,9 @@ void Test_CF_CmdDisablePolldir_FailWhenActionFail(void) { /* Arrange */ uint8 dummy_channel = Any_cf_channel(); - uint8 error_polldir = - Any_uint8_BetweenInclusive(CF_MAX_POLLING_DIR_PER_CHAN, ALL_CHANNELS - 1); + uint8 error_polldir = Any_uint8_BetweenInclusive(CF_MAX_POLLING_DIR_PER_CHAN, ALL_CHANNELS - 1); cf_cmd_unionargs_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = (CFE_MSG_Message_t*)&dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; /* Arrange unstubbable: CF_DoChanAction */ dummy_msg.data.byte[0] = dummy_channel; @@ -2475,7 +2428,7 @@ void Test_CF_CmdDisablePolldir_FailWhenActionFail(void) ** *******************************************************************************/ -void Test_CF_PurgeHistory_Calls_CF_CFDP_ResetHistory_AndReturns_CLIST_CONT(void) +void Test_CF_PurgeHistory_Call_CF_CFDP_ResetHistory_AndReturn_CLIST_CONT(void) { /* Arrange */ history_t dummy_h; @@ -2492,17 +2445,13 @@ void Test_CF_PurgeHistory_Calls_CF_CFDP_ResetHistory_AndReturns_CLIST_CONT(void) local_result = CF_PurgeHistory(arg_n, arg_c); /* Assert */ - UtAssert_True(context_CF_CFDP_ResetHistory.c == arg_c, - "CF_CFDP_ResetHistory received c ptr %p and should be %p (c)", - context_CF_CFDP_ResetHistory.c, arg_c); - UtAssert_True(context_CF_CFDP_ResetHistory.h == &dummy_h, - "CF_CFDP_ResetHistory received h ptr %p and should be %p (h)", - context_CF_CFDP_ResetHistory.h, &dummy_h); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetHistory.c, arg_c); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetHistory.h, &dummy_h); UtAssert_True(local_result == CLIST_CONT, "CF_PurgeHistory returned %d and should be %d (CLIST_CONT)", local_result, CLIST_CONT); -} /* end Test_CF_PurgeHistory_Calls_CF_CFDP_ResetHistory_AndReturns_CLIST_CONT */ +} /* end Test_CF_PurgeHistory_Call_CF_CFDP_ResetHistory_AndReturn_CLIST_CONT */ /******************************************************************************* @@ -2511,7 +2460,7 @@ void Test_CF_PurgeHistory_Calls_CF_CFDP_ResetHistory_AndReturns_CLIST_CONT(void) ** *******************************************************************************/ -void Test_CF_PurgeTransaction_Calls_CF_CFDP_ResetTransaction_AndReturns_CLIST_CONT(void) +void Test_CF_PurgeTransaction_Call_CF_CFDP_ResetTransaction_AndReturn_CLIST_CONT(void) { /* Arrange */ transaction_t dummy_t; @@ -2528,9 +2477,7 @@ void Test_CF_PurgeTransaction_Calls_CF_CFDP_ResetTransaction_AndReturns_CLIST_CO local_result = CF_PurgeTransaction(arg_n, arg_ignored); /* Assert */ - UtAssert_True(context_CF_CFDP_ResetTransaction.t == &dummy_t, - "CF_CFDP_ResetTransaction received t ptr %p and should be %p (t)", - context_CF_CFDP_ResetTransaction.t, &dummy_t); + UtAssert_ADDRESS_EQ(context_CF_CFDP_ResetTransaction.t, &dummy_t); UtAssert_True(context_CF_CFDP_ResetTransaction.keep_history == 0, "CF_CFDP_ResetTransaction received keep_history %u and should be 0 (constant)", context_CF_CFDP_ResetTransaction.keep_history); @@ -2538,7 +2485,7 @@ void Test_CF_PurgeTransaction_Calls_CF_CFDP_ResetTransaction_AndReturns_CLIST_CO "CF_PurgeHistory returned %d and should be %d (CLIST_CONT)", local_result, CLIST_CONT); -} /* end Test_CF_PurgeHistory_Calls_CF_CFDP_ResetHistory_AndReturns_CLIST_CONT */ +} /* end Test_CF_PurgeHistory_Call_CF_CFDP_ResetHistory_AndReturn_CLIST_CONT */ /******************************************************************************* ** @@ -2576,15 +2523,9 @@ void Test_CF_DoPurgeQueue_PendOnly(void) /* Assert */ UtAssert_STUB_COUNT(CF_CList_Traverse, 1); - UtAssert_True(context_CF_CList_Traverse.start == expected_start, - "CF_CList_Traverse received clist_node %p and should be %p (c->qs[CF_Q_PEND])", - context_CF_CList_Traverse.start, expected_start); - UtAssert_True(context_CF_CList_Traverse.fn == CF_PurgeTransaction, - "CF_CList_Traverse received clist_fn_t %p and should be %p (CF_PurgeTransaction)", - context_CF_CList_Traverse.fn, CF_PurgeTransaction); - UtAssert_True(context_CF_CList_Traverse.context == NULL, - "CF_CList_Traverse received void* %p and should be %p (NULL)", - context_CF_CList_Traverse.context, NULL); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse.start, expected_start); + UtAssert_True(context_CF_CList_Traverse.fn == CF_PurgeTransaction, "context_CF_CList_Traverse.fn == CF_PurgeTransaction"); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse.context, NULL); UtAssert_True(local_result == 0, "CF_DoPurgeQueue returned %d and should be 0", local_result); @@ -2620,15 +2561,9 @@ void Test_CF_DoPurgeQueue_HistoryOnly(void) /* Assert */ UtAssert_STUB_COUNT(CF_CList_Traverse, 1); - UtAssert_True(context_CF_CList_Traverse.start == expected_start, - "CF_CList_Traverse received clist_node %p and should be %p (c->qs[CF_Q_HIST])", - context_CF_CList_Traverse.start, expected_start); - UtAssert_True(context_CF_CList_Traverse.fn == (clist_fn_t)CF_PurgeHistory, - "CF_CList_Traverse received clist_fn_t %p and should be %p (CF_PurgeHistory)", - context_CF_CList_Traverse.fn, (clist_fn_t)CF_PurgeHistory); - UtAssert_True(context_CF_CList_Traverse.context == dummy_c, - "CF_CList_Traverse received void* %p and should be %p (c)", - context_CF_CList_Traverse.context, dummy_c); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse.start, expected_start); + UtAssert_True(context_CF_CList_Traverse.fn == (clist_fn_t)CF_PurgeHistory, "context_CF_CList_Traverse.fn == (clist_fn_t)CF_PurgeHistory"); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse.context, dummy_c); UtAssert_True(local_result == 0, "CF_DoPurgeQueue returned %d and should be 0", local_result); @@ -2667,30 +2602,18 @@ void Test_CF_DoPurgeQueue_Both(void) /* Assert */ UtAssert_STUB_COUNT(CF_CList_Traverse, 2); - UtAssert_True(context_CF_CList_Traverse[0].start == expected_pend_start, - "CF_CList_Traverse received clist_node %p and should be %p (c->qs[CF_Q_PEND])", - context_CF_CList_Traverse[0].start, expected_pend_start); - UtAssert_True(context_CF_CList_Traverse[0].fn == CF_PurgeTransaction, - "CF_CList_Traverse received clist_fn_t %p and should be %p (CF_PurgeTransaction)", - context_CF_CList_Traverse[0].fn, CF_PurgeTransaction); - UtAssert_True(context_CF_CList_Traverse[0].context == NULL, - "CF_CList_Traverse received void* %p and should be %p (NULL)", - context_CF_CList_Traverse[0].context, NULL); - UtAssert_True(context_CF_CList_Traverse[1].start == expected_history_start, - "CF_CList_Traverse received clist_node %p and should be %p (c->qs[CF_Q_HIST])", - context_CF_CList_Traverse[1].start, expected_history_start); - UtAssert_True(context_CF_CList_Traverse[1].fn == (clist_fn_t)CF_PurgeHistory, - "CF_CList_Traverse received clist_fn_t %p and should be %p (CF_PurgeHistory)", - context_CF_CList_Traverse[1].fn, (clist_fn_t)CF_PurgeHistory); - UtAssert_True(context_CF_CList_Traverse[1].context == dummy_c, - "CF_CList_Traverse received void* %p and should be %p (c)", - context_CF_CList_Traverse[1].context, dummy_c); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse[0].start, expected_pend_start); + UtAssert_True(context_CF_CList_Traverse[0].fn == CF_PurgeTransaction, "context_CF_CList_Traverse[0].fn == CF_PurgeTransaction"); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse[0].context, NULL); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse[1].start, expected_history_start); + UtAssert_True(context_CF_CList_Traverse[1].fn == (clist_fn_t)CF_PurgeHistory, "context_CF_CList_Traverse[1].fn == (clist_fn_t)CF_PurgeHistory"); + UtAssert_ADDRESS_EQ(context_CF_CList_Traverse[1].context, dummy_c); UtAssert_True(local_result == 0, "CF_DoPurgeQueue returned %d and should be 0", local_result); } /* end Test_CF_DoPurgeQueue_Both */ -void Test_CF_DoPurgeQueue_GivenBad_data_byte_1_SendsEventAndReturns_neg1(void) +void Test_CF_DoPurgeQueue_GivenBad_data_byte_1_SendEventAndReturn_neg1(void) { /* Arrange */ uint8 arg_chan_num = Any_cf_channel(); @@ -2717,9 +2640,9 @@ void Test_CF_DoPurgeQueue_GivenBad_data_byte_1_SendsEventAndReturns_neg1(void) "CFE_EVS_SendEvent received %u and should have received %u (CF_EID_ERR_CMD_PURGE_ARG)", EventID, CF_EID_ERR_CMD_PURGE_ARG); UtAssert_STUB_COUNT(CF_CList_Traverse, 0); -} /* end Test_CF_DoPurgeQueue_GivenBad_data_byte_1_SendsEventAndReturns_neg1 */ +} /* end Test_CF_DoPurgeQueue_GivenBad_data_byte_1_SendEventAndReturn_neg1 */ -void Test_CF_DoPurgeQueue_AnyGivenBad_data_byte_1_SendsEventAndReturns_neg1(void) +void Test_CF_DoPurgeQueue_AnyGivenBad_data_byte_1_SendEventAndReturn_neg1(void) { /* Arrange */ uint8 arg_chan_num = Any_cf_channel(); @@ -2746,7 +2669,7 @@ void Test_CF_DoPurgeQueue_AnyGivenBad_data_byte_1_SendsEventAndReturns_neg1(void "CFE_EVS_SendEvent received %u and should have received %u (CF_EID_ERR_CMD_PURGE_ARG)", EventID, CF_EID_ERR_CMD_PURGE_ARG); UtAssert_STUB_COUNT(CF_CList_Traverse, 0); -} /* end Test_CF_DoPurgeQueue_AnyGivenBad_data_byte_1_SendsEventAndReturns_neg1 */ +} /* end Test_CF_DoPurgeQueue_AnyGivenBad_data_byte_1_SendEventAndReturn_neg1 */ /******************************************************************************* ** @@ -2759,9 +2682,8 @@ void Test_CF_CmdPurgeQueue_FailWhenActionFail(void) /* Arrange */ uint8 dummy_channel = Any_cf_channel(); uint8 error_purge = 3; /* Shortest return from CF_DoPurgeQueue */ - Any_uint8_BetweenInclusive(CF_MAX_POLLING_DIR_PER_CHAN, ALL_CHANNELS - 1); cf_cmd_unionargs_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = (CFE_MSG_Message_t*)&dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; /* Arrange unstubbable: CF_DoChanAction */ dummy_msg.data.byte[0] = dummy_channel; @@ -2791,7 +2713,7 @@ void Test_CF_CmdPurgeQueue_FailWhenActionFail(void) ** *******************************************************************************/ -void Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_chan_Eq_CF_NUM_CAHNNELS(void) +void Test_CF_CmdWriteQueue_When_chan_Eq_CF_NUM_CAHNNELS_SendEventAndRejectCommand(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -2820,9 +2742,9 @@ void Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_chan_Eq_CF_NUM_CAHNNEL UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_chan_Eq_CF_NUM_CAHNNELS */ +} /* end Test_CF_CmdWriteQueue_When_chan_Eq_CF_NUM_CAHNNELS_SendEventAndRejectCommand */ -void Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_chan_GreaterThan_CF_NUM_CAHNNELS(void) +void Test_CF_CmdWriteQueue_When_chan_GreaterThan_CF_NUM_CAHNNELS_SendEventAndRejectCommand(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -2851,9 +2773,9 @@ void Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_chan_GreaterThan_CF_NU UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_chan_Eq_CF_NUM_CAHNNELS */ +} /* end Test_CF_CmdWriteQueue_When_chan_GreaterThan_CF_NUM_CAHNNELS_SendEventAndRejectCommand */ -void Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhenUpAndPendingQueue(void) +void Test_CF_CmdWriteQueue_WhenUpAndPendingQueueSendEventAndRejectCommand(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -2886,9 +2808,9 @@ void Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhenUpAndPendingQueue(void) UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhenUpAndPendingQueue */ +} /* end Test_CF_CmdWriteQueue_WhenUpAndPendingQueueSendEventAndRejectCommand */ -void Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_CF_WrappedCreat_Fails_type_Is_type_up_And_queue_IsNot_q_pend(void) +void Test_CF_CmdWriteQueue_When_CF_WrappedCreat_Fails_type_Is_type_up_And_queue_IsNot_q_pend_SendEventAndRejectCommand(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -2934,9 +2856,9 @@ void Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_CF_WrappedCreat_Fails_ UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_CF_WrappedCreat_Fails_type_Is_type_up_And_queue_IsNot_q_pend */ +} /* end Test_CF_CmdWriteQueue_When_CF_WrappedCreat_Fails_type_Is_type_up_And_queue_IsNot_q_pend_SendEventAndRejectCommand */ -void Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_CF_WrappedCreat_Fails_type_IsNot_type_up_And_queue_Is_q_pend(void) +void Test_CF_CmdWriteQueue_When_CF_WrappedCreat_Fails_type_IsNot_type_up_And_queue_Is_q_pend_SendEventAndRejectCommand(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -2982,9 +2904,9 @@ void Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_CF_WrappedCreat_Fails_ UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_CF_WrappedCreat_Fails_type_IsNot_type_up_And_queue_Is_q_pend */ +} /* end Test_CF_CmdWriteQueue_When_CF_WrappedCreat_Fails_type_IsNot_type_up_And_queue_Is_q_pend_SendEventAndRejectCommand */ -void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteQueueDataToFile_FailsWhen_wq_IsAllAnd_queue_IsAll_fd_Is_0_Calls_CF_WrappedClose(void) +void Test_CF_CmdWriteQueue_When_wq_IsAllAnd_queue_IsAll_fd_Is_0_Call_CF_WrappedClose_SendEventCloseAndRejectCommandWhen_CF_WriteQueueDataToFile_Fails(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3038,9 +2960,9 @@ void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteQueueDat UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteQueueDataToFile_FailsWhen_wq_IsAllAnd_queue_IsAll_fd_Is_0_Calls_CF_WrappedClose */ +} /* end Test_CF_CmdWriteQueue_When_wq_IsAllAnd_queue_IsAll_fd_Is_0_Call_CF_WrappedClose_SendEventCloseAndRejectCommandWhen_CF_WriteQueueDataToFile_Fails */ -void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteQueueDataToFile_FailsWhen_wq_IsUpAnd_queue_IsActive_fd_IsPositive_Calls_CF_WrappedClose(void) +void Test_CF_CmdWriteQueue_When_CF_WriteQueueDataToFile_FailsAnd_wq_IsUpAnd_queue_IsActive_fd_IsPositive_Call_CF_WrappedClose_SendEventClosesAndRejectCommand(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3100,9 +3022,9 @@ void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteQueueDat UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteQueueDataToFile_FailsWhen_wq_IsUpAnd_queue_IsActive_fd_IsPositive_Calls_CF_WrappedClose */ +} /* end Test_CF_CmdWriteQueue_When_CF_WriteQueueDataToFile_FailsAnd_wq_IsUpAnd_queue_IsActive_fd_IsPositive_Call_CF_WrappedClose_SendEventClosesAndRejectCommand */ -void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQueueDataToFile_FailsWhen_wq_IsUpAnd_queue_IsHistory_fd_IsPositive_Calls_CF_WrappedClose(void) +void Test_CF_CmdWriteQueue_When_CF_WriteHistoryQueueDataToFile_FailsAnd_wq_IsUpAnd_queue_IsHistory_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3162,9 +3084,9 @@ void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQ UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQueueDataToFile_FailsWhen_wq_IsUpAnd_queue_IsHistory_fd_IsPositive_Calls_CF_WrappedClose(void) */ +} /* end Test_CF_CmdWriteQueue_When_CF_WriteHistoryQueueDataToFile_FailsAnd_wq_IsUpAnd_queue_IsHistory_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand(void) */ -void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryDataToFile_FailsOnFirstCallWhen_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Calls_CF_WrappedClose(void) +void Test_CF_CmdWriteQueue_When_CF_WriteHistoryDataToFile_FailsOnFirstCallAnd_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3224,9 +3146,9 @@ void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryD UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryDataToFile_FailsOnFirstCallWhen_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Calls_CF_WrappedClose */ +} /* end Test_CF_CmdWriteQueue_When_CF_WriteHistoryDataToFile_FailsOnFirstCallAnd_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand */ -void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryDataToFile_FailsOnSecondCallWhen_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Calls_CF_WrappedClose(void) +void Test_CF_CmdWriteQueue_When_CF_WriteHistoryDataToFile_FailsOnSecondCallAnd_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3289,9 +3211,9 @@ void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryD UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryDataToFile_FailsOnSecondCallWhen_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Calls_CF_WrappedClose */ +} /* end Test_CF_CmdWriteQueue_When_CF_WriteHistoryDataToFile_FailsOnSecondCallAnd_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand */ -void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQueueDataToFile_FailsWhen_wq_IsDownAnd_queue_IsPend_fd_IsPositive_Calls_CF_WrappedClose(void) +void Test_CF_CmdWriteQueue_When_CF_WriteHistoryQueueDataToFile_FailsAnd_wq_IsDownAnd_queue_IsPend_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3351,9 +3273,9 @@ void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQ UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQueueDataToFile_FailsWhen_wq_IsDownAnd_queue_IsPend_fd_IsPositive_Calls_CF_WrappedClose(void) */ +} /* end Test_CF_CmdWriteQueue_When_CF_WriteHistoryQueueDataToFile_FailsAnd_wq_IsDownAnd_queue_IsPend_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand(void) */ -void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQueueDataToFile_FailsWhen_wq_IsDownAnd_queue_IsHistory_fd_IsPositive_Calls_CF_WrappedClose(void) +void Test_CF_CmdWriteQueue_When_CF_WriteHistoryQueueDataToFile_FailsAnd_wq_IsDownAnd_queue_IsHistory_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3413,9 +3335,9 @@ void Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQ UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQueueDataToFile_FailsWhen_wq_IsDownAnd_queue_IsHistory_fd_IsPositive_Calls_CF_WrappedClose(void) */ +} /* end Test_CF_CmdWriteQueue_When_CF_WriteHistoryQueueDataToFile_FailsAnd_wq_IsDownAnd_queue_IsHistory_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand(void) */ -void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_All(void) +void Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_All(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3467,9 +3389,9 @@ void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_All(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_All */ +} /* end Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_All */ -void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_History(void) +void Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_History(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3515,9 +3437,9 @@ void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_History(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_History */ +} /* end Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_History */ -void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_Active(void) +void Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_Active(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3563,9 +3485,9 @@ void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_Active(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_All */ +} /* end Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_All */ -void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_Pend(void) +void Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_Pend(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3611,9 +3533,9 @@ void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_Pend(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_Pend */ +} /* end Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_Pend */ -void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_All(void) +void Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_UpAnd_q_All(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3665,9 +3587,9 @@ void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_All(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_All */ +} /* end Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_All */ -void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_History(void) +void Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_UpAnd_q_History(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3713,9 +3635,9 @@ void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_History(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_History */ +} /* end Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_UpAnd_q_History */ -void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_Active(void) +void Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_UpAnd_q_Active(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3761,11 +3683,11 @@ void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_Active(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_Active */ +} /* end Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_UpAnd_q_Active */ -/* Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_Pend IS an error and is handled by a previous test */ +/* Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_UpAnd_q_Pend IS an error and is handled by a previous test */ -void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_All(void) +void Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_All(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3811,9 +3733,9 @@ void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_All(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Active */ +} /* end Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_Active */ -void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_History(void) +void Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_History(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3859,9 +3781,9 @@ void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_History(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Active */ +} /* end Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_Active */ -void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Active(void) +void Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_Active(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3907,9 +3829,9 @@ void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Active(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Active */ +} /* end Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_Active */ -void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Pend(void) +void Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_Pend(void) { /* Arrange */ cf_cmd_write_q_t dummy_wq; @@ -3955,7 +3877,7 @@ void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Pend(void) UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Pend */ +} /* end Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_Pend */ /* end CF_CmdWriteQueue tests */ @@ -3965,11 +3887,11 @@ void Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Pend(void) ** *******************************************************************************/ -void Test_CF_CmdSendCfgParams_Sets_cfg_TimeStampsAndSendsMsg_AcceptsCommand(void) +void Test_CF_CmdSendCfgParams_Set_cfg_TimeStampAndSendMsg_AcceptCommand(void) { /* Arrange */ CFE_MSG_Message_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = &dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; cf_config_table_t dummy_config_table; CFE_TIME_SysTime_t fake_time; CFE_SB_TransmitMsg_context_t context_CFE_SB_TransmitMsg; @@ -4002,7 +3924,6 @@ void Test_CF_CmdSendCfgParams_Sets_cfg_TimeStampsAndSendsMsg_AcceptsCommand(void /* Act */ CF_CmdSendCfgParams(arg_msg); - /* Assert */ UtAssert_True(CF_AppData.cfg.ticks_per_second == CF_AppData.config_table->ticks_per_second, "cfg.ticks_per_second is %u and should be %u (config_table->ticks_per_second)", @@ -4032,9 +3953,7 @@ void Test_CF_CmdSendCfgParams_Sets_cfg_TimeStampsAndSendsMsg_AcceptsCommand(void "cfg.local_eid is %u and should be %u (config_table->local_eid)", CF_AppData.cfg.local_eid, CF_AppData.config_table->local_eid); UtAssert_STUB_COUNT(CFE_MSG_SetMsgTime, 1); - UtAssert_True(context_CFE_MSG_SetMsgTime.MsgPtr == &CF_AppData.cfg.tlm_header.Msg, - "CFE_MSG_SetMsgTime received MsgPtr %p and should be %p (&CF_AppData.cfg.tlm_header.Msg)", - context_CFE_MSG_SetMsgTime.MsgPtr, &CF_AppData.cfg.tlm_header.Msg); + UtAssert_ADDRESS_EQ(context_CFE_MSG_SetMsgTime.MsgPtr, &CF_AppData.cfg.tlm_header.Msg); UtAssert_True(context_CFE_MSG_SetMsgTime.Time.Seconds == fake_time.Seconds, "CFE_MSG_SetMsgTime received Time.Seconds %u and should be %u (call to CFE_TIME_GetTime Seconds)", context_CFE_MSG_SetMsgTime.Time.Seconds, fake_time.Seconds); @@ -4042,9 +3961,7 @@ void Test_CF_CmdSendCfgParams_Sets_cfg_TimeStampsAndSendsMsg_AcceptsCommand(void "CFE_MSG_SetMsgTime received Time.Subseconds %u and should be %u (call to CFE_TIME_GetTime Subseconds)", context_CFE_MSG_SetMsgTime.Time.Subseconds, fake_time.Subseconds); UtAssert_STUB_COUNT(CFE_SB_TransmitMsg, 1); - UtAssert_True(context_CFE_SB_TransmitMsg.MsgPtr == &CF_AppData.cfg.tlm_header.Msg, - "CFE_SB_TransmitMsg received MsgPtr %p and should be %p (&CF_AppData.cfg.tlm_header.Msg)", - context_CFE_SB_TransmitMsg.MsgPtr, &CF_AppData.cfg.tlm_header.Msg); + UtAssert_ADDRESS_EQ(context_CFE_SB_TransmitMsg.MsgPtr, &CF_AppData.cfg.tlm_header.Msg); UtAssert_True(context_CFE_SB_TransmitMsg.IncrementSequenceCount == true, "CFE_SB_TransmitMsg received IncrementSequenceCount '%s' and should be 'true'", context_CFE_SB_TransmitMsg.IncrementSequenceCount ? "true" : "false"); @@ -4052,7 +3969,7 @@ void Test_CF_CmdSendCfgParams_Sets_cfg_TimeStampsAndSendsMsg_AcceptsCommand(void UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdSendCfgParams_Sets_cfg_TimeStampsAndSendsMsg_AcceptsCommand */ +} /* end Test_CF_CmdSendCfgParams_Set_cfg_TimeStampAndSendMsg_AcceptCommand */ /******************************************************************************* ** @@ -4060,7 +3977,7 @@ void Test_CF_CmdSendCfgParams_Sets_cfg_TimeStampsAndSendsMsg_AcceptsCommand(void ** *******************************************************************************/ -void Test_CF_CmdValidateChunkSize_val_GreaterThan_pdu_fd_data_t_FailsAndReturns_1(void) +void Test_CF_CmdValidateChunkSize_val_GreaterThan_pdu_fd_data_t_FailAndReturn_1(void) { /* Arrange */ uint8 arg_chan_num = Any_uint8(); /* value labeled as 'ignored' in func def */ @@ -4075,9 +3992,9 @@ void Test_CF_CmdValidateChunkSize_val_GreaterThan_pdu_fd_data_t_FailsAndReturns_ "CF_CmdValidateChunkSize returned %d and should be 1 (failed)", local_result); -} /* end Test_CF_CmdValidateChunkSize_val_GreaterThan_pdu_fd_data_t_FailsAndReturns_1 */ +} /* end Test_CF_CmdValidateChunkSize_val_GreaterThan_pdu_fd_data_t_FailAndReturn_1 */ -void Test_CF_CmdValidateChunkSize_Any_val_GreaterThan_pdu_fd_data_t_FailsAndReturns_1(void) +void Test_CF_CmdValidateChunkSize_Any_val_GreaterThan_pdu_fd_data_t_FailAndReturn_1(void) { /* Arrange */ uint8 arg_chan_num = Any_uint8(); /* value labeled as 'ignored' in func def */ @@ -4092,9 +4009,9 @@ void Test_CF_CmdValidateChunkSize_Any_val_GreaterThan_pdu_fd_data_t_FailsAndRetu "CF_CmdValidateChunkSize returned %d and should be 1 (failed)", local_result); -} /* end Test_CF_CmdValidateChunkSize_Any_val_GreaterThan_pdu_fd_data_t_FailsAndReturns_1 */ +} /* end Test_CF_CmdValidateChunkSize_Any_val_GreaterThan_pdu_fd_data_t_FailAndReturn_1 */ -void Test_CF_CmdValidateChunkSize_val_SizeOf_pdu_fd_data_t_SuccessAndReturns_0(void) +void Test_CF_CmdValidateChunkSize_val_SizeOf_pdu_fd_data_t_SuccessAndReturn_0(void) { /* Arrange */ uint8 arg_chan_num = Any_uint8(); /* value labeled as 'ignored' in func def */ @@ -4109,9 +4026,9 @@ void Test_CF_CmdValidateChunkSize_val_SizeOf_pdu_fd_data_t_SuccessAndReturns_0(v "CF_CmdValidateChunkSize returned %d and should be 0 (success)", local_result); -} /* end Test_CF_CmdValidateChunkSize_val_SizeOf_pdu_fd_data_t_SuccessAndReturns_0 */ +} /* end Test_CF_CmdValidateChunkSize_val_SizeOf_pdu_fd_data_t_SuccessAndReturn_0 */ -void Test_CF_CmdValidateChunkSize_val_LessThanOrEqSizeOf_pdu_fd_data_t_SuccessAndReturns_0(void) +void Test_CF_CmdValidateChunkSize_val_LessThanOrEqSizeOf_pdu_fd_data_t_SuccessAndReturn_0(void) { /* Arrange */ uint8 arg_chan_num = Any_uint8(); /* value labeled as 'ignored' in func def */ @@ -4126,7 +4043,7 @@ void Test_CF_CmdValidateChunkSize_val_LessThanOrEqSizeOf_pdu_fd_data_t_SuccessAn "CF_CmdValidateChunkSize returned %d and should be 0 (success)", local_result); -} /* end Test_CF_CmdValidateChunkSize_val_LessThanOrEqSizeOf_pdu_fd_data_t_SuccessAndReturns_0 */ +} /* end Test_CF_CmdValidateChunkSize_val_LessThanOrEqSizeOf_pdu_fd_data_t_SuccessAndReturn_0 */ /******************************************************************************* ** @@ -4134,7 +4051,7 @@ void Test_CF_CmdValidateChunkSize_val_LessThanOrEqSizeOf_pdu_fd_data_t_SuccessAn ** *******************************************************************************/ -void Test_CF_CmdValidateMaxOutgoing_SuccessBecauseGiven_val_IsNot_0_Returns_0(void) +void Test_CF_CmdValidateMaxOutgoing_WhenGiven_val_IsNot_0_Return_0_Success(void) { /* Arrange */ uint32 arg_val = Any_uint32_Except(0); @@ -4152,16 +4069,14 @@ void Test_CF_CmdValidateMaxOutgoing_SuccessBecauseGiven_val_IsNot_0_Returns_0(vo "CF_CmdValidateMaxOutgoing returned %d and should be 0 (Success)", local_result); -} /* end Test_CF_CmdValidateMaxOutgoing_SuccessBecauseGiven_val_IsNot_0_Returns_0 */ +} /* end Test_CF_CmdValidateMaxOutgoing_WhenGiven_val_IsNot_0_Return_0_Success */ -void Test_CF_CmdValidateMaxOutgoing_SuccessBecauseGiven_val_Is_0_But_sem_name_IsNot_NULL_Returns_0(void) +void Test_CF_CmdValidateMaxOutgoing_WhenGiven_val_Is_0_But_sem_name_IsNot_NULL_Return_0_Success(void) { /* Arrange */ uint32 arg_val = 0; uint8 arg_chan_num = Any_cf_chan_num(); /* Any_cf_chan_num used here because value matters to this test */ cf_config_table_t dummy_config_table; - cf_channel_t dummy_chan; - uint8 dummy_sem_name_0 = Any_uint8(); int local_result; CF_AppData.config_table = &dummy_config_table; @@ -4175,16 +4090,14 @@ void Test_CF_CmdValidateMaxOutgoing_SuccessBecauseGiven_val_Is_0_But_sem_name_Is "CF_CmdValidateMaxOutgoing returned %d and should be 0 (Success)", local_result); -} /* end Test_CF_CmdValidateMaxOutgoing_SuccessBecauseGiven_val_Is_0_But_sem_name_IsNot_NULL_Returns_0 */ +} /* end Test_CF_CmdValidateMaxOutgoing_WhenGiven_val_Is_0_But_sem_name_IsNot_NULL_Return_0_Success */ -void Test_CF_CmdValidateMaxOutgoing_FailBecauseGiven_val_Is_0_And_sem_name_Is_NULL_Returns_1(void) +void Test_CF_CmdValidateMaxOutgoing_WhenGiven_val_Is_0_And_sem_name_Is_NULL_Return_1_Fail(void) { /* Arrange */ uint32 arg_val = 0; uint8 arg_chan_num = Any_cf_chan_num(); /* Any_cf_chan_num used here because value matters to this test */ cf_config_table_t dummy_config_table; - cf_channel_t dummy_chan; - uint8 dummy_sem_name_0 = Any_uint8(); int local_result; CF_AppData.config_table = &dummy_config_table; @@ -4198,7 +4111,7 @@ void Test_CF_CmdValidateMaxOutgoing_FailBecauseGiven_val_Is_0_And_sem_name_Is_NU "CF_CmdValidateMaxOutgoing returned %d and should be 1 (Success)", local_result); -} /* end Test_CF_CmdValidateMaxOutgoing_FailBecauseGiven_val_Is_0_And_sem_name_Is_NULL_Returns_1 */ +} /* end Test_CF_CmdValidateMaxOutgoing_WhenGiven_val_Is_0_And_sem_name_Is_NULL_Return_1_Fail */ /* end CF_CmdValidateMaxOutgoing tests */ @@ -4208,7 +4121,7 @@ void Test_CF_CmdValidateMaxOutgoing_FailBecauseGiven_val_Is_0_And_sem_name_Is_NU ** *******************************************************************************/ -void Test_CF_CmdGetSetParam_FailsSendsEventAndRejectsCmd_param_id_Eq_CF_NUM_CFG_PACKET_ITEMS(void) +void Test_CF_CmdGetSetParam_When_param_id_Eq_CF_NUM_CFG_PACKET_ITEMS_FailSendEventAndRejectCmd(void) { /* Arrange */ cf_config_table_t dummy_config_table; @@ -4230,7 +4143,6 @@ void Test_CF_CmdGetSetParam_FailsSendsEventAndRejectsCmd_param_id_Eq_CF_NUM_CFG_ /* Act */ CF_CmdGetSetParam(arg_is_set, arg_param_id, arg_value, arg_chan_num); - /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(EventID == CF_EID_ERR_CMD_GETSET_PARAM, @@ -4241,9 +4153,9 @@ void Test_CF_CmdGetSetParam_FailsSendsEventAndRejectsCmd_param_id_Eq_CF_NUM_CFG_ "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdGetSetParam_FailsSendsEventAndRejectsCmd_param_id_Eq_CF_NUM_CFG_PACKET_ITEMS */ +} /* end Test_CF_CmdGetSetParam_When_param_id_Eq_CF_NUM_CFG_PACKET_ITEMS_FailSendEventAndRejectCmd */ -void Test_CF_CmdGetSetParam_FailsSendsEventAndRejectsCmd_param_id_AnyGreaterThan_CF_NUM_CFG_PACKET_ITEMS(void) +void Test_CF_CmdGetSetParam_When_param_id_AnyGreaterThan_CF_NUM_CFG_PACKET_ITEMS_FailSendEventAndRejectCmd(void) { /* Arrange */ cf_config_table_t dummy_config_table; @@ -4265,7 +4177,6 @@ void Test_CF_CmdGetSetParam_FailsSendsEventAndRejectsCmd_param_id_AnyGreaterThan /* Act */ CF_CmdGetSetParam(arg_is_set, arg_param_id, arg_value, arg_chan_num); - /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(EventID == CF_EID_ERR_CMD_GETSET_PARAM, @@ -4276,9 +4187,9 @@ void Test_CF_CmdGetSetParam_FailsSendsEventAndRejectsCmd_param_id_AnyGreaterThan "CF_AppData.hk.counters.err is %u and should be 1 more than %u", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdGetSetParam_FailsSendsEventAndRejectsCmd_param_id_AnyGreaterThan_CF_NUM_CFG_PACKET_ITEMS */ +} /* end Test_CF_CmdGetSetParam_When_param_id_AnyGreaterThan_CF_NUM_CFG_PACKET_ITEMS_FailSendEventAndRejectCmd */ -void Test_CF_CmdGetSetParam_Given_chan_num_IsEqTo_CF_NUM_CHANNELS_ErrorsOutAndCountsError(void) +void Test_CF_CmdGetSetParam_Given_chan_num_IsEqTo_CF_NUM_CHANNELS_ErrorOutAndCountError(void) { /* Arrange */ cf_config_table_t dummy_config_table; @@ -4300,7 +4211,6 @@ void Test_CF_CmdGetSetParam_Given_chan_num_IsEqTo_CF_NUM_CHANNELS_ErrorsOutAndCo /* Act */ CF_CmdGetSetParam(arg_is_set, arg_param_id, arg_value, arg_chan_num); - /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(EventID == CF_EID_ERR_CMD_GETSET_CHAN, @@ -4311,9 +4221,9 @@ void Test_CF_CmdGetSetParam_Given_chan_num_IsEqTo_CF_NUM_CHANNELS_ErrorsOutAndCo "CF_AppData.hk.counters.err is %u and should be 1 more than %u", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdGetSetParam_Given_chan_num_IsEqTo_CF_NUM_CHANNELS_ErrorsOutAndCountsError */ +} /* end Test_CF_CmdGetSetParam_Given_chan_num_IsEqTo_CF_NUM_CHANNELS_ErrorOutAndCountError */ -void Test_CF_CmdGetSetParam_Given_chan_num_IsGreaterThan_CF_NUM_CHANNELS_ErrorsOutAndCountsError(void) +void Test_CF_CmdGetSetParam_Given_chan_num_IsGreaterThan_CF_NUM_CHANNELS_ErrorOutAndCountError(void) { /* Arrange */ cf_config_table_t dummy_config_table; @@ -4335,7 +4245,6 @@ void Test_CF_CmdGetSetParam_Given_chan_num_IsGreaterThan_CF_NUM_CHANNELS_ErrorsO /* Act */ CF_CmdGetSetParam(arg_is_set, arg_param_id, arg_value, arg_chan_num); - /* Assert */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(EventID == CF_EID_ERR_CMD_GETSET_CHAN, @@ -4346,9 +4255,9 @@ void Test_CF_CmdGetSetParam_Given_chan_num_IsGreaterThan_CF_NUM_CHANNELS_ErrorsO "CF_AppData.hk.counters.err is %u and should be 1 more than %u", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdGetSetParam_Given_chan_num_IsGreaterThan_CF_NUM_CHANNELS_ErrorsOutAndCountsError */ +} /* end Test_CF_CmdGetSetParam_Given_chan_num_IsGreaterThan_CF_NUM_CHANNELS_ErrorOutAndCountError */ -void Test_CF_CmdGetSetParam_is_set_Is_0_And_param_id_Is_0_MemCopiesSendsEventAndAcceptsCommand(void) +void Test_CF_CmdGetSetParam_When_is_set_Is_0_And_param_id_Is_0_MemCopySendEventAndAcceptCommand(void) { /* Arrange */ cf_config_table_t dummy_config_table; @@ -4382,9 +4291,9 @@ void Test_CF_CmdGetSetParam_is_set_Is_0_And_param_id_Is_0_MemCopiesSendsEventAnd "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdGetSetParam_is_set_Is_0_And_param_id_Is_0_MemCopiesSendsEventAndAcceptsCommand */ +} /* end Test_CF_CmdGetSetParam_When_is_set_Is_0_And_param_id_Is_0_MemCopySendEventAndAcceptCommand */ -void Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_0_HasANull_fn_ThenCopies_value_To_ptr_SendsEventAndAcceptsCommand(void) +void Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_0_HasANull_fn_ThenCopy_value_To_ptr_SendEventAndAcceptCommand(void) { /* Arrange */ cf_config_table_t dummy_config_table; @@ -4420,11 +4329,11 @@ void Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_0_HasANull_fn_ThenCopies "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_0_HasANull_fn_ThenCopies_value_To_ptr_SendsEventAndAcceptsCommand */ +} /* end Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_0_HasANull_fn_ThenCopy_value_To_ptr_SendEventAndAcceptCommand */ /* TODO: Add randomized test that will check any SPTR value, but that will take extra time for now. */ -void Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_SendsEventBecause_fn_Returned_1_AndRejectsCommand(void) +void Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_SendEventBecause_fn_Returned_1_AndRejectCommand(void) { /* Arrange */ cf_config_table_t dummy_config_table; @@ -4458,9 +4367,9 @@ void Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_SendsEvent "CF_AppData.hk.counters.err is %u and should be 1 more than %u", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_SendsEventBecause_fn_Returned_1_AndRejectsCommand */ +} /* end Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_SendEventBecause_fn_Returned_1_AndRejectCommand */ -void Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_ThenCopies_value_To_ptr_Because_fn_Returned_0_SendsEventAndAcceptsCommand(void) +void Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_ThenCopy_value_To_ptr_Because_fn_Returned_0_SendEventAndAcceptCommand(void) { /* Arrange */ cf_config_table_t dummy_config_table; @@ -4496,7 +4405,7 @@ void Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_ThenCopies "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_ThenCopies_value_To_ptr_Because_fn_Returned_0_SendsEventAndAcceptsCommand */ +} /* end Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_ThenCopy_value_To_ptr_Because_fn_Returned_0_SendEventAndAcceptCommand */ /* end CF_CmdGetSetParam tests */ @@ -4506,19 +4415,19 @@ void Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_ThenCopies ** *******************************************************************************/ -/* TODO: Test_CF_CmdSetParam_Calls_CF_CmdGetSetParam_With_cmd_key_And_cmd_value only uses 0 as key, there could be more tests here, but only because CF_CmdGetSetParam is unstubbable, this test mimics Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_0_HasANull_fn_ThenCopies_value_To_ptr_SendsEventAndAcceptsCommand*/ -void Test_CF_CmdSetParam_Calls_CF_CmdGetSetParam_With_cmd_key_And_cmd_value(void) +/* TODO: Test_CF_CmdSetParam_Call_CF_CmdGetSetParam_With_cmd_key_And_cmd_value only uses 0 as key, there could be more tests here, but only because CF_CmdGetSetParam is unstubbable, this test mimics Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_0_HasANull_fn_ThenCopy_value_To_ptr_SendEventAndAcceptCommand*/ +void Test_CF_CmdSetParam_Call_CF_CmdGetSetParam_With_cmd_key_And_cmd_value(void) { /* Arrange */ cf_cmd_set_param_args_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = (CFE_MSG_Message_t*)&dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; /* Arrange unstubbable: CF_CmdGetSetParam */ cf_config_table_t dummy_config_table; dummy_msg.key = 0; dummy_msg.value = Any_uint32(); - uint8 arg_chan_num = Any_uint8(); + dummy_msg.chan_num = 0; CF_AppData.config_table = &dummy_config_table; @@ -4533,7 +4442,6 @@ void Test_CF_CmdSetParam_Calls_CF_CmdGetSetParam_With_cmd_key_And_cmd_value(void /* Act */ CF_CmdSetParam(arg_msg); - /* Assert */ UtAssert_True(CF_AppData.config_table->ticks_per_second == dummy_msg.value, "ticks_per_second is %u and should be %u (msg->value)", @@ -4547,7 +4455,7 @@ void Test_CF_CmdSetParam_Calls_CF_CmdGetSetParam_With_cmd_key_And_cmd_value(void "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdSetParam_Calls_CF_CmdGetSetParam_With_cmd_key_And_cmd_value */ +} /* end Test_CF_CmdSetParam_Call_CF_CmdGetSetParam_With_cmd_key_And_cmd_value */ /* end CF_CmdSetParam tests */ @@ -4557,8 +4465,8 @@ void Test_CF_CmdSetParam_Calls_CF_CmdGetSetParam_With_cmd_key_And_cmd_value(void ** *******************************************************************************/ -/* TODO: Test_CF_CmdGetParam_Calls_CF_CmdGetSetParam_With_cmd_data_byte_0_And_0 only uses 0 as key, there could be more tests here, but only because CF_CmdGetSetParam is unstubbable, this test mimics Test_CF_CmdGetSetParam_is_set_Is_0_And_param_id_Is_0_MemCopiesSendsEventAndAcceptsCommand*/ -void Test_CF_CmdGetParam_Calls_CF_CmdGetSetParam_With_cmd_data_byte_0_AndConstantValue_0(void) +/* TODO: Test_CF_CmdGetParam_Call_CF_CmdGetSetParam_With_cmd_data_byte_0_And_0 only uses 0 as key, there could be more tests here, but only because CF_CmdGetSetParam is unstubbable, this test mimics Test_CF_CmdGetSetParam_When_is_set_Is_0_And_param_id_Is_0_MemCopySendEventAndAcceptCommand*/ +void Test_CF_CmdGetParam_Call_CF_CmdGetSetParam_With_cmd_data_byte_0_AndConstantValue_0(void) { /* Arrange */ cf_cmd_get_param_args_t dummy_msg; @@ -4583,7 +4491,6 @@ void Test_CF_CmdGetParam_Calls_CF_CmdGetSetParam_With_cmd_data_byte_0_AndConstan /* Act */ CF_CmdGetParam(arg_msg); - /* Assert */ /* Assert for CF_CmdGetSetParam */ /* TODO: CANNOT test memcpy because copies it to a local value (the arg value, but it was not passed by ref) and then only used in the SendEvent function which does not track that value as of the writing of this comment. */ @@ -4596,7 +4503,7 @@ void Test_CF_CmdGetParam_Calls_CF_CmdGetSetParam_With_cmd_data_byte_0_AndConstan "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdGetParam_Calls_CF_CmdGetSetParam_With_cmd_data_byte_0_AndConstantValue_0 */ +} /* end Test_CF_CmdGetParam_Call_CF_CmdGetSetParam_With_cmd_data_byte_0_AndConstantValue_0 */ /******************************************************************************* ** @@ -4604,7 +4511,7 @@ void Test_CF_CmdGetParam_Calls_CF_CmdGetSetParam_With_cmd_data_byte_0_AndConstan ** *******************************************************************************/ -void Test_CF_CmdEnableEngine_WithEngineNotEnableInitSucceedsAndIncrementsCmdAccCounter(void) +void Test_CF_CmdEnableEngine_WithEngineNotEnableInitSuccessAndIncrementCmdAccCounter(void) { /* Arrange */ CFE_SB_Buffer_t* arg_msg = NULL; @@ -4632,10 +4539,10 @@ void Test_CF_CmdEnableEngine_WithEngineNotEnableInitSucceedsAndIncrementsCmdAccC "CF_AppData.hk.counters.cmd is %d and should be 1 more than %d", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdEnableEngine_WithEngineNotEnableInitSucceedsAndIncrementsCmdAccCounter */ +} /* end Test_CF_CmdEnableEngine_WithEngineNotEnableInitSuccessAndIncrementCmdAccCounter */ -void Test_CF_CmdEnableEngine_WithEngineNotEnableFailsInitSendsEventAndIncrementsCmdRejCounter(void) +void Test_CF_CmdEnableEngine_WithEngineNotEnableFailsInitSendEventAndIncrementCmdRejCounter(void) { /* Arrange */ CFE_SB_Buffer_t* arg_msg = NULL; @@ -4668,9 +4575,9 @@ void Test_CF_CmdEnableEngine_WithEngineNotEnableFailsInitSendsEventAndIncrements "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdEnableEngine_WithEngineNotEnableFailsInitSendsEventAndIncrementsCmdRejCounter */ +} /* end Test_CF_CmdEnableEngine_WithEngineNotEnableFailsInitSendEventAndIncrementCmdRejCounter */ -void Test_CF_CmdEnableEngine_WithEngineEnableFailsSendsEventAndIncrementsCmdRejCounter(void) +void Test_CF_CmdEnableEngine_WithEngineEnableFailsSendEventAndIncrementCmdRejCounter(void) { /* Arrange */ CFE_SB_Buffer_t* arg_msg = NULL; @@ -4701,7 +4608,7 @@ void Test_CF_CmdEnableEngine_WithEngineEnableFailsSendsEventAndIncrementsCmdRejC "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_CmdEnableEngine_WithEngineEnableFailsSendsEventAndIncrementsCmdRejCounter */ +} /* end Test_CF_CmdEnableEngine_WithEngineEnableFailsSendEventAndIncrementCmdRejCounter */ /******************************************************************************* @@ -4710,7 +4617,7 @@ void Test_CF_CmdEnableEngine_WithEngineEnableFailsSendsEventAndIncrementsCmdRejC ** *******************************************************************************/ -void Test_CF_CmdDisableEngine_SuccessWhenEngineEnabledAndIncrementsCmdAccCounter(void) +void Test_CF_CmdDisableEngine_SuccessWhenEngineEnabledAndIncrementCmdAccCounter(void) { /* Arrange */ CFE_SB_Buffer_t* arg_msg = NULL; @@ -4725,7 +4632,6 @@ void Test_CF_CmdDisableEngine_SuccessWhenEngineEnabledAndIncrementsCmdAccCounter /* Act */ CF_CmdDisableEngine(arg_msg); - /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_DisableEngine, 1); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); @@ -4735,9 +4641,9 @@ void Test_CF_CmdDisableEngine_SuccessWhenEngineEnabledAndIncrementsCmdAccCounter CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_CmdDisableEngine_SuccessWhenEngineEnabledAndIncrementsCmdAccCounter */ +} /* end Test_CF_CmdDisableEngine_SuccessWhenEngineEnabledAndIncrementCmdAccCounter */ -void Test_CF_CmdDisableEngine_FailsWhenEngineDisabledAndIncrementsCmdAccCounter(void) +void Test_CF_CmdDisableEngine_WhenEngineDisabledAndIncrementCmdAccCounterThenFail(void) { /* Arrange */ CFE_SB_Buffer_t* arg_msg = NULL; @@ -4755,7 +4661,6 @@ void Test_CF_CmdDisableEngine_FailsWhenEngineDisabledAndIncrementsCmdAccCounter( /* Act */ CF_CmdDisableEngine(arg_msg); - /* Assert */ UtAssert_STUB_COUNT(CF_CFDP_DisableEngine, 0); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); @@ -4766,10 +4671,10 @@ void Test_CF_CmdDisableEngine_FailsWhenEngineDisabledAndIncrementsCmdAccCounter( UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); - -} /* end Test_CF_CmdDisableEngine_SuccessWhenEngineEnabledAndIncrementsCmdAccCounter */ +} /* end Test_CF_CmdDisableEngine_WhenEngineDisabledAndIncrementCmdAccCounterThenFail */ +/* end CF_CmdDisableEngine tests */ /******************************************************************************* ** @@ -4777,11 +4682,11 @@ void Test_CF_CmdDisableEngine_FailsWhenEngineDisabledAndIncrementsCmdAccCounter( ** *******************************************************************************/ -void Test_CF_ProcessGroundCommand_Fails_cmd_EqTo_CF_NUM_COMMANDS_AndSendsEvent(void) +void Test_CF_ProcessGroundCommand_When_cmd_EqTo_CF_NUM_COMMANDS_FailAndSendEvent(void) { /* Arrange */ CFE_MSG_Message_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = &dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; CFE_MSG_FcnCode_t forced_return_CFE_MSG_GetFcnCode = CF_NUM_COMMANDS; const char* expected_Spec = "CF: invalid ground command packet cmd_code=0x%02x"; CFE_MSG_GetFcnCode_context_t context_CFE_MSG_GetFcnCode; @@ -4789,7 +4694,7 @@ void Test_CF_ProcessGroundCommand_Fails_cmd_EqTo_CF_NUM_COMMANDS_AndSendsEvent(v UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &forced_return_CFE_MSG_GetFcnCode, sizeof(forced_return_CFE_MSG_GetFcnCode), false); UT_SetHookFunction(UT_KEY(CFE_MSG_GetFcnCode), stub_reporter, &context_CFE_MSG_GetFcnCode); - /* CFE_MSG_GetSize does not matter for Test_CF_ProcessGroundCommand_Fails_cmd_EqTo_CF_NUM_COMMANDS_AndSendsEvent */ + /* CFE_MSG_GetSize does not matter for Test_CF_ProcessGroundCommand_When_cmd_EqTo_CF_NUM_COMMANDS_FailAndSendEvent */ UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); @@ -4801,12 +4706,9 @@ void Test_CF_ProcessGroundCommand_Fails_cmd_EqTo_CF_NUM_COMMANDS_AndSendsEvent(v /* Act */ CF_ProcessGroundCommand(arg_msg); - /* Assert */ UtAssert_STUB_COUNT(CFE_MSG_GetFcnCode, 1); - UtAssert_True(context_CFE_MSG_GetFcnCode.MsgPtr == &arg_msg->Msg, - "CFE_MSG_GetFcnCode received MsgPtr %p and should have received %p (&msg->Msg)", - context_CFE_MSG_GetFcnCode.MsgPtr, &arg_msg->Msg); + UtAssert_ADDRESS_EQ(context_CFE_MSG_GetFcnCode.MsgPtr, &arg_msg->Msg); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(context_CFE_EVS_SendEvent.EventID == CF_EID_ERR_CMD_GCMD_CC, "CFE_EVS_SendEvent received EventID %u and should have received %u (CF_EID_ERR_CMD_GCMD_CC)", @@ -4821,13 +4723,13 @@ void Test_CF_ProcessGroundCommand_Fails_cmd_EqTo_CF_NUM_COMMANDS_AndSendsEvent(v UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_ProcessGroundCommand_Fails_cmd_EqTo_CF_NUM_COMMANDS_AndSendsEvent */ +} /* end Test_CF_ProcessGroundCommand_When_cmd_EqTo_CF_NUM_COMMANDS_FailAndSendEvent */ -void Test_CF_ProcessGroundCommand_Fails_cmd_GreaterThan_CF_NUM_COMMANDS_AndSendsEvent(void) +void Test_CF_ProcessGroundCommand_When_cmd_GreaterThan_CF_NUM_COMMANDS_FailAndSendEvent(void) { /* Arrange */ CFE_MSG_Message_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = &dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; CFE_MSG_FcnCode_t forced_return_CFE_MSG_GetFcnCode = Any_uint8_GreaterThan(CF_NUM_COMMANDS); CFE_MSG_GetFcnCode_context_t context_CFE_MSG_GetFcnCode; const char* expected_Spec = "CF: invalid ground command packet cmd_code=0x%02x"; @@ -4835,7 +4737,7 @@ void Test_CF_ProcessGroundCommand_Fails_cmd_GreaterThan_CF_NUM_COMMANDS_AndSends UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &forced_return_CFE_MSG_GetFcnCode, sizeof(forced_return_CFE_MSG_GetFcnCode), false); UT_SetHookFunction(UT_KEY(CFE_MSG_GetFcnCode), stub_reporter, &context_CFE_MSG_GetFcnCode); - /* CFE_MSG_GetSize does not matter for Test_CF_ProcessGroundCommand_Fails_cmd_EqTo_CF_NUM_COMMANDS_AndSendsEvent */ + /* CFE_MSG_GetSize does not matter for Test_CF_ProcessGroundCommand_When_cmd_EqTo_CF_NUM_COMMANDS_FailAndSendEvent */ UT_SetHookFunction(UT_KEY(CFE_EVS_SendEvent), stub_reporter, &context_CFE_EVS_SendEvent); @@ -4847,12 +4749,9 @@ void Test_CF_ProcessGroundCommand_Fails_cmd_GreaterThan_CF_NUM_COMMANDS_AndSends /* Act */ CF_ProcessGroundCommand(arg_msg); - /* Assert */ UtAssert_STUB_COUNT(CFE_MSG_GetFcnCode, 1); - UtAssert_True(context_CFE_MSG_GetFcnCode.MsgPtr == &arg_msg->Msg, - "CFE_MSG_GetFcnCode received MsgPtr %p and should have received %p (&msg->Msg)", - context_CFE_MSG_GetFcnCode.MsgPtr, &arg_msg->Msg); + UtAssert_ADDRESS_EQ(context_CFE_MSG_GetFcnCode.MsgPtr, &arg_msg->Msg); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(context_CFE_EVS_SendEvent.EventID == CF_EID_ERR_CMD_GCMD_CC, "CFE_EVS_SendEvent received EventID %u and should have received %u (CF_EID_ERR_CMD_GCMD_CC)", @@ -4867,13 +4766,13 @@ void Test_CF_ProcessGroundCommand_Fails_cmd_GreaterThan_CF_NUM_COMMANDS_AndSends UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_ProcessGroundCommand_Fails_cmd_GreaterThan_CF_NUM_COMMANDS_AndSendsEvent */ +} /* end Test_CF_ProcessGroundCommand_When_cmd_GreaterThan_CF_NUM_COMMANDS_FailAndSendEvent */ -void Test_CF_ProcessGroundCommand_Receives_cmd_AndLengthDoesNotMatchExpectedForThatCommandSendsEventAndCalls_CF_CmdRej(void) +void Test_CF_ProcessGroundCommand_Receives_cmd_AndLengthDoesNotMatchExpectedForThatCommandSendEventAndCall_CF_CmdRej(void) { /* Arrange */ CFE_MSG_Message_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = &dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; CFE_MSG_FcnCode_t forced_return_CFE_MSG_GetFcnCode = 0x00; /* 0x00 forces fns[0] which is CF_CmdNoop */ CFE_MSG_Size_t forced_return_CFE_MSG_GetSize = Any_uint16_Except(sizeof(cf_cmd_noargs_t)); /* sizeof(cf_cmd_noargs_t) is expected size of CF_CmdNoop, using uint16 as a reasonable size constraint here as size_t is at least 16 bit */ const char* expected_Spec = "CF: invalid ground command length for command 0x%02x, expected %d got %zd"; @@ -4896,16 +4795,11 @@ void Test_CF_ProcessGroundCommand_Receives_cmd_AndLengthDoesNotMatchExpectedForT /* Act */ CF_ProcessGroundCommand(arg_msg); - /* Assert */ UtAssert_STUB_COUNT(CFE_MSG_GetFcnCode, 1); - UtAssert_True(context_CFE_MSG_GetFcnCode.MsgPtr == &arg_msg->Msg, - "CFE_MSG_GetFcnCode received MsgPtr %p and should have received %p (&msg->Msg)", - context_CFE_MSG_GetFcnCode.MsgPtr, &arg_msg->Msg); + UtAssert_ADDRESS_EQ(context_CFE_MSG_GetFcnCode.MsgPtr, &arg_msg->Msg); UtAssert_STUB_COUNT(CFE_MSG_GetSize, 1); - UtAssert_True(context_CFE_MSG_GetSize.MsgPtr == &arg_msg->Msg, - "CFE_MSG_GetSize received MsgPtr %p and should have received %p (&msg->Msg)", - context_CFE_MSG_GetSize.MsgPtr, &arg_msg->Msg); + UtAssert_ADDRESS_EQ(context_CFE_MSG_GetSize.MsgPtr, &arg_msg->Msg); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(context_CFE_EVS_SendEvent.EventID == CF_EID_ERR_CMD_GCMD_LEN, "CFE_EVS_SendEvent received EventID %u and should have received %u (CF_EID_ERR_CMD_GCMD_LEN)", @@ -4920,13 +4814,13 @@ void Test_CF_ProcessGroundCommand_Receives_cmd_AndLengthDoesNotMatchExpectedForT UtAssert_True(CF_AppData.hk.counters.err == (uint16)(initial_hk_err_counter + 1), "CF_AppData.hk.counters.err is %d and should be 1 more than %d", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_ProcessGroundCommand_Receives_cmd_AndLengthDoesNotMatchExpectedForThatCommandSendsEventAndCalls_CF_CmdRej */ +} /* end Test_CF_ProcessGroundCommand_Receives_cmd_AndLengthDoesNotMatchExpectedForThatCommandSendEventAndCall_CF_CmdRej */ -void Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x00_AndCalls_CF_CmdNoop_With_msg(void) +void Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x00_AndCall_CF_CmdNoop_With_msg(void) { /* Arrange */ CFE_MSG_Message_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = &dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; CFE_MSG_FcnCode_t forced_return_CFE_MSG_GetFcnCode = 0x00; /* 0x00 forces fns[0] which is CF_CmdNoop */ CFE_MSG_Size_t forced_return_CFE_MSG_GetSize = sizeof(cf_cmd_noargs_t); /* sizeof(cf_cmd_noargs_t) is expected size of CF_CmdNoop */ const char* expected_Spec = "CF: No-Op received, Version %d.%d.%d"; @@ -4950,16 +4844,11 @@ void Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x00_AndCalls_CF_CmdNoop_With_ /* Act */ CF_ProcessGroundCommand(arg_msg); - /* Assert */ UtAssert_STUB_COUNT(CFE_MSG_GetFcnCode, 1); - UtAssert_True(context_CFE_MSG_GetFcnCode.MsgPtr == &arg_msg->Msg, - "CFE_MSG_GetFcnCode received MsgPtr %p and should have received %p (&msg->Msg)", - context_CFE_MSG_GetFcnCode.MsgPtr, &arg_msg->Msg); + UtAssert_ADDRESS_EQ(context_CFE_MSG_GetFcnCode.MsgPtr, &arg_msg->Msg); UtAssert_STUB_COUNT(CFE_MSG_GetSize, 1); - UtAssert_True(context_CFE_MSG_GetSize.MsgPtr == &arg_msg->Msg, - "CFE_MSG_GetSize received MsgPtr %p and should have received %p (&msg->Msg)", - context_CFE_MSG_GetSize.MsgPtr, &arg_msg->Msg); + UtAssert_ADDRESS_EQ(context_CFE_MSG_GetSize.MsgPtr, &arg_msg->Msg); /* Assert for CF_CmdNoop */ UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); UtAssert_True(context_CFE_EVS_SendEvent.EventID == CF_EID_INF_CMD_NOOP, @@ -4975,19 +4864,18 @@ void Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x00_AndCalls_CF_CmdNoop_With_ UtAssert_True(CF_AppData.hk.counters.cmd == (uint16)(initial_hk_cmd_counter + 1), "CF_AppData.hk.counters.cmd is %u and should be 1 more than %u (value before call)", CF_AppData.hk.counters.cmd, initial_hk_cmd_counter); -} /* end Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x00_AndCalls_CF_CmdNoop_With_msg */ +} /* end Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x00_AndCall_CF_CmdNoop_With_msg */ /* TODO: Not sure if it is even possible to have a NULL get to this check, but -** Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoesNothingBecause_fns_12_Is_NULL is forcing it +** Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoNothingBecause_fns_12_Is_NULL is forcing it ** to happen. The reason is, I'm not sure CFE_SB_GetTotalMsgLength can ever actually return 0. */ -void Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoesNothingBecause_fns_12_Is_NULL(void) +void Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoNothingBecause_fns_12_Is_NULL(void) { /* Arrange */ CFE_MSG_Message_t dummy_msg; - CFE_SB_Buffer_t* arg_msg = &dummy_msg; + CFE_SB_Buffer_t* arg_msg = (CFE_SB_Buffer_t*)&dummy_msg; CFE_MSG_FcnCode_t forced_return_CFE_MSG_GetFcnCode = 0x0C; /* 0x0C forces a null slot */ CFE_MSG_Size_t forced_return_CFE_MSG_GetSize = 0; - const char* expected_Spec = "CF: No-Op received, Version %d.%d.%d"; CFE_MSG_GetFcnCode_context_t context_CFE_MSG_GetFcnCode; UT_SetDataBuffer(UT_KEY(CFE_MSG_GetFcnCode), &forced_return_CFE_MSG_GetFcnCode, @@ -5007,16 +4895,11 @@ void Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoesNothingBecause_fns /* Act */ CF_ProcessGroundCommand(arg_msg); - /* Assert */ UtAssert_STUB_COUNT(CFE_MSG_GetFcnCode, 1); - UtAssert_True(context_CFE_MSG_GetFcnCode.MsgPtr == &arg_msg->Msg, - "CFE_MSG_GetFcnCode received MsgPtr %p and should have received %p (&msg->Msg)", - context_CFE_MSG_GetFcnCode.MsgPtr, &arg_msg->Msg); + UtAssert_ADDRESS_EQ(context_CFE_MSG_GetFcnCode.MsgPtr, &arg_msg->Msg); UtAssert_STUB_COUNT(CFE_MSG_GetSize, 1); - UtAssert_True(context_CFE_MSG_GetSize.MsgPtr == &arg_msg->Msg, - "CFE_MSG_GetSize received MsgPtr %p and should have received %p (&msg->Msg)", - context_CFE_MSG_GetSize.MsgPtr, &arg_msg->Msg); + UtAssert_ADDRESS_EQ(context_CFE_MSG_GetSize.MsgPtr, &arg_msg->Msg); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); /* Assert for CF_CmdAcc */ /* TODO: just to note because of other CF_ProcessGroundCommand tests note, no problem here with overflow because no values should have been altered */ UtAssert_True(CF_AppData.hk.counters.cmd == initial_hk_cmd_counter, @@ -5025,7 +4908,7 @@ void Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoesNothingBecause_fns UtAssert_True(CF_AppData.hk.counters.err == initial_hk_err_counter, "CF_AppData.hk.counters.err is %u and should not have changed from %u (value before call)", CF_AppData.hk.counters.err, initial_hk_err_counter); -} /* end Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoesNothingBecause_fns_12_Is_NULL */ +} /* end Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoNothingBecause_fns_12_Is_NULL */ /* end CF_ProcessGroundCommand tests */ @@ -5037,153 +4920,153 @@ void Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoesNothingBecause_fns void add_CF_CmdAcc_tests(void) { - UtTest_Add(Test_CF_CmdAcc_Increases_CF_AppData_HkCmdCounterBy1, + UtTest_Add(Test_CF_CmdAcc_Increment_CF_AppData_hk_cmd_counter, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdAcc_Increases_CF_AppData_HkCmdCounterBy1"); + "Test_CF_CmdAcc_Increment_CF_AppData_hk_cmd_counter"); } /* end add_CF_CmdAcc_tests */ void add_CF_CmdRej_tests(void) { - UtTest_Add(Test_CF_CmdRej_Increases_CF_AppData_HkErrCounterBy1, + UtTest_Add(Test_CF_CmdRej_Increment_CF_AppData_hk_err_counter, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdRej_Increases_CF_AppData_HkErrCounterBy1"); + "Test_CF_CmdRej_Increment_CF_AppData_hk_err_counter"); } /* end add_CF_CmdRej_tests */ void add_CF_CmdCond_tests(void) { - UtTest_Add(Test_CF_CmdCond_Calls_CF_CmdAccWhenCondIs0, + UtTest_Add(Test_CF_CmdCond_When_cond_Is_0_Call_CF_CmdAcc, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdCond_Calls_CF_CmdAccWhenCondIs0"); - UtTest_Add(Test_CF_CmdCond_Calls_CF_CmdRejWhenCondIsNot0, + "Test_CF_CmdCond_When_cond_Is_0_Call_CF_CmdAcc"); + UtTest_Add(Test_CF_CmdCond_When_cond_IsNot_0_Call_CF_CmdRej, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdCond_Calls_CF_CmdRejWhenCondIsNot0"); + "Test_CF_CmdCond_When_cond_IsNot_0_Call_CF_CmdRej"); } /* end add_CF_CmdCond_tests */ void add_CF_CmdNoop_tests(void) { - UtTest_Add(Test_CF_CmdNoop_SendsNoopEventAndAcceptsCommand, + UtTest_Add(Test_CF_CmdNoop_SendNoopEventAndAcceptCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdNoop_SendsNoopEventAndAcceptsCommand"); + "Test_CF_CmdNoop_SendNoopEventAndAcceptCommand"); } /* end add_CF_CmdNoop_tests */ void add_CF_CmdReset_tests(void) { - UtTest_Add(Test_CF_CmdReset_tests_SendsEventAndRejectsCommandWhenCommandByteIsEqTo_5, + UtTest_Add(Test_CF_CmdReset_tests_WhenCommandByteIsEqTo_5_SendEventAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdReset_tests_SendsEventAndRejectsCommandWhenCommandByteIsEqTo_5"); - UtTest_Add(Test_CF_CmdReset_tests_SendsEventAndRejectsCommandWhenCommandByteIsGreaterThan_5, + "Test_CF_CmdReset_tests_WhenCommandByteIsEqTo_5_SendEventAndRejectCommand"); + UtTest_Add(Test_CF_CmdReset_tests_WhenCommandByteIsGreaterThan_5_SendEventAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdReset_tests_SendsEventAndRejectsCommandWhenCommandByteIsGreaterThan_5"); - UtTest_Add(Test_CF_CmdReset_tests_SendsEventWhenCommandByteIs_command_AndResetsHkCmdAndErrCount, + "Test_CF_CmdReset_tests_WhenCommandByteIsGreaterThan_5_SendEventAndRejectCommand"); + UtTest_Add(Test_CF_CmdReset_tests_WhenCommandByteIs_command_AndResetHkCmdAndErrCountSendEvent, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdReset_tests_SendsEventWhenCommandByteIs_command_AndResetsHkCmdAndErrCount"); - UtTest_Add(Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_fault_AndResetsAllHkFaultCount, + "Test_CF_CmdReset_tests_WhenCommandByteIs_command_AndResetHkCmdAndErrCountSendEvent"); + UtTest_Add(Test_CF_CmdReset_tests_WhenCommandByteIs_fault_ResetAllHkFaultCountSendEventAndAcceptCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_fault_AndResetsAllHkFaultCount"); - UtTest_Add(Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_up_AndResetsAllHkRecvCount, + "Test_CF_CmdReset_tests_WhenCommandByteIs_fault_ResetAllHkFaultCountSendEventAndAcceptCommand"); + UtTest_Add(Test_CF_CmdReset_tests_WhenCommandByteIs_up_AndResetAllHkRecvCountSendEventAndAcceptCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_up_AndResetsAllHkRecvCount"); - UtTest_Add(Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_down_AndResetsAllHkSentCount, + "Test_CF_CmdReset_tests_WhenCommandByteIs_up_AndResetAllHkRecvCountSendEventAndAcceptCommand"); + UtTest_Add(Test_CF_CmdReset_tests_SWhenCommandByteIs_down_AndResetAllHkSentCountendEventAcceptCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdReset_tests_SendsEventAcceptsCommandWhenCommandByteIs_down_AndResetsAllHkSentCount"); - UtTest_Add(Test_CF_CmdReset_tests_SendsEventWhenCommandByteIs_all_AndResetsAllMemValues, + "Test_CF_CmdReset_tests_SWhenCommandByteIs_down_AndResetAllHkSentCountendEventAcceptCommand"); + UtTest_Add(Test_CF_CmdReset_tests_WhenCommandByteIs_all_AndResetAllMemValuesSendEvent, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdReset_tests_SendsEventWhenCommandByteIs_all_AndResetsAllMemValues"); + "Test_CF_CmdReset_tests_WhenCommandByteIs_all_AndResetAllMemValuesSendEvent"); } /* end add_CF_CmdReset_tests */ void add_CF_CmdTxFile_tests(void) { - UtTest_Add(Test_CF_CmdTxFile_AcceptsCommandWhen_CF_CFDP_TxFile_Returns0, + UtTest_Add(Test_CF_CmdTxFile_WhenCallTo_CF_CFDP_TxFile_Returns_0_AcceptCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdTxFile_AcceptsCommandWhen_CF_CFDP_TxFile_Returns0"); - UtTest_Add(Test_CF_CmdTxFile_RejectsCommandWhen_CF_CFDP_TxFile_ReturnsNon0, + "Test_CF_CmdTxFile_WhenCallTo_CF_CFDP_TxFile_Returns_0_AcceptCommand"); + UtTest_Add(Test_CF_CmdTxFile_WhenCAllTo_CF_CFDP_TxFile_Returns_Non0_RejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdTxFile_RejectsCommandWhen_CF_CFDP_TxFile_ReturnsNon0"); + "Test_CF_CmdTxFile_WhenCAllTo_CF_CFDP_TxFile_Returns_Non0_RejectCommand"); } /* end add_CF_CmdTxFile_tests */ void add_CF_CmdPlaybackDir_tests(void) { - UtTest_Add(Test_CF_CmdPlaybackDir_AcceptsCommandWhen_CF_CFDP_PlaybackDir_Returns0, + UtTest_Add(Test_CF_CmdPlaybackDir_WhenCAllTo_CF_CFDP_PlaybackDir_Returns_0_AcceptCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdPlaybackDir_AcceptsCommandWhen_CF_CFDP_PlaybackDir_Returns0"); - UtTest_Add(Test_CF_CmdPlaybackDir_RejectsCommandWhen_CF_CmdPlaybackDir_ReturnsNon0, + "Test_CF_CmdPlaybackDir_WhenCAllTo_CF_CFDP_PlaybackDir_Returns_0_AcceptCommand"); + UtTest_Add(Test_CF_CmdPlaybackDir_WhenCallTo_CF_CmdPlaybackDir_Returns_non0_RejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdPlaybackDir_RejectsCommandWhen_CF_CmdPlaybackDir_ReturnsNon0"); + "Test_CF_CmdPlaybackDir_WhenCallTo_CF_CmdPlaybackDir_Returns_non0_RejectCommand"); } /* end add_CF_CmdPlaybackDir_tests */ void add_CF_DoChanAction_tests(void) { - UtTest_Add(Test_CF_DoChanAction_ALL_CHANNELS_Returns_1_WhenAny_fn_returns_1, + UtTest_Add(Test_CF_DoChanAction_ALL_CHANNELS_WhenAny_fn_returns_1_Return_1, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoChanAction_ALL_CHANNELS_Returns_1_WhenAny_fn_returns_1"); - UtTest_Add(Test_CF_DoChanAction_ALL_CHANNELS_Returns_1_WhenAll_fn_return_1, + "Test_CF_DoChanAction_ALL_CHANNELS_WhenAny_fn_returns_1_Return_1"); + UtTest_Add(Test_CF_DoChanAction_ALL_CHANNELS_WhenAll_fn_return_1_Return_1, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoChanAction_ALL_CHANNELS_Returns_1_WhenAll_fn_return_1"); - UtTest_Add(Test_CF_DoChanAction_ALL_CHANNELS_Returns_0_WhenNo_fn_returns_0, + "Test_CF_DoChanAction_ALL_CHANNELS_WhenAll_fn_return_1_Return_1"); + UtTest_Add(Test_CF_DoChanAction_ALL_CHANNELS_WhenNo_fn_returns_0_Return_0, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoChanAction_ALL_CHANNELS_Returns_0_WhenNo_fn_returns_0"); - UtTest_Add(Test_CF_DoChanAction_Returns_1_WhenChannel_fn_ActionReturns_1, + "Test_CF_DoChanAction_ALL_CHANNELS_WhenNo_fn_returns_0_Return_0"); + UtTest_Add(Test_CF_DoChanAction_WhenChannel_fn_ActionReturns_1_Return_1, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoChanAction_Returns_1_WhenChannel_fn_ActionReturns_1"); - UtTest_Add(Test_CF_DoChanAction_Returns_1_WhenChannel_fn_ActionReturns_0, + "Test_CF_DoChanAction_WhenChannel_fn_ActionReturns_1_Return_1"); + UtTest_Add(Test_CF_DoChanAction_WhenChannel_fn_ActionReturns_0_Return_1, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoChanAction_Returns_1_WhenChannel_fn_ActionReturns_0"); - UtTest_Add(Test_CF_DoChanAction_Returns_neg1_And_SendsEvent_WhenChanNumberEq_CF_NUM_CHANNELS, + "Test_CF_DoChanAction_WhenChannel_fn_ActionReturns_0_Return_1"); + UtTest_Add(Test_CF_DoChanAction_WhenChanNumberEq_CF_NUM_CHANNELS_Return_neg1_And_SendEvent_, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoChanAction_Returns_neg1_And_SendsEvent_WhenChanNumberEq_CF_NUM_CHANNELS"); - UtTest_Add(Test_CF_DoChanAction_Returns_neg1_And_SendsEvent_WhenBadChannelNumber, + "Test_CF_DoChanAction_WhenChanNumberEq_CF_NUM_CHANNELS_Return_neg1_And_SendEvent_"); + UtTest_Add(Test_CF_DoChanAction_WhenBadChannelNumber_Return_neg1_And_SendEvent, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoChanAction_Returns_neg1_And_SendsEvent_WhenBadChannelNumber"); + "Test_CF_DoChanAction_WhenBadChannelNumber_Return_neg1_And_SendEvent"); } /* end add_CF_DoChanAction_tests */ void add_CF_DoFreezeThaw_tests(void) { - UtTest_Add(Test_CF_DoFreezeThaw_Sets_frozen_ToGiven_context_barg_AndReturns_0, + UtTest_Add(Test_CF_DoFreezeThaw_Set_frozen_ToGiven_context_barg_AndReturn_0, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoFreezeThaw_Sets_frozen_ToGiven_context_barg_AndReturns_0"); + "Test_CF_DoFreezeThaw_Set_frozen_ToGiven_context_barg_AndReturn_0"); }/* end add_CF_DoFreezeThaw_tests */ void add_CF_CmdFreeze_tests(void) { - UtTest_Add(Test_CF_CmdFreeze_Sets_frozen_To_1_AndAcceptsCommand, + UtTest_Add(Test_CF_CmdFreeze_Set_frozen_To_1_AndAcceptCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdFreeze_Sets_frozen_To_1_AndAcceptsCommand"); + "Test_CF_CmdFreeze_Set_frozen_To_1_AndAcceptCommand"); }/* end add_CF_CmdFreeze_tests */ void add_CF_CmdThaw_tests(void) { - UtTest_Add(Test_CF_CmdFThaw_Sets_frozen_To_0_AndAcceptsCommand, + UtTest_Add(Test_CF_CmdFThaw_Set_frozen_To_0_AndAcceptCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdFThaw_Sets_frozen_To_0_AndAcceptsCommand"); + "Test_CF_CmdFThaw_Set_frozen_To_0_AndAcceptCommand"); }/* end add_CF_CmdThaw_tests */ void add_CF_CFDP_FindTransactionBySequenceNumberAllChannels_tests(void) { - UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Returns_NULL_NoTransactionFound, + UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_WhenNoTransactionFoundReturn_NULL, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Returns_NULL_NoTransactionFound"); - UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Returns_TransactionFound, + "Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_WhenNoTransactionFoundReturn_NULL"); + UtTest_Add(Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Return_TransactionFound, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Returns_TransactionFound"); + "Test_CF_CFDP_FindTransactionBySequenceNumberAllChannels_Return_TransactionFound"); }/* end add_CF_CFDP_FindTransactionBySequenceNumberAllChannels_tests */ void add_CF_TsnChanAction_tests(void) { - UtTest_Add(Test_CF_TsnChanAction_SendsEvent_cmd_chan_Eq_COMPOUND_KEY_TransactionNotFoundAndReturns_neg1_Fail, + UtTest_Add(Test_CF_TsnChanAction_SendEvent_cmd_chan_Eq_COMPOUND_KEY_TransactionNotFoundAndReturn_neg1_Fail, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_TsnChanAction_SendsEvent_cmd_chan_Eq_COMPOUND_KEY_TransactionNotFoundAndReturns_neg1_Fail"); - UtTest_Add(Test_CF_TsnChanAction_cmd_chan_Eq_COMPOUND_KEY_TransactionFoundRuns_fn_AndReturns_CFE_SUCCESS, + "Test_CF_TsnChanAction_SendEvent_cmd_chan_Eq_COMPOUND_KEY_TransactionNotFoundAndReturn_neg1_Fail"); + UtTest_Add(Test_CF_TsnChanAction_cmd_chan_Eq_COMPOUND_KEY_TransactionFoundRun_fn_AndReturn_CFE_SUCCESS, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_TsnChanAction_cmd_chan_Eq_COMPOUND_KEY_TransactionFoundRuns_fn_AndReturns_CFE_SUCCESS"); - UtTest_Add(Test_CF_TsnChanAction_cmd_chan_Eq_ALL_CHANNELS_Returns_CF_TraverseAllTransactions_All_Channels, + "Test_CF_TsnChanAction_cmd_chan_Eq_COMPOUND_KEY_TransactionFoundRun_fn_AndReturn_CFE_SUCCESS"); + UtTest_Add(Test_CF_TsnChanAction_cmd_chan_Eq_ALL_CHANNELS_Return_CF_TraverseAllTransactions_All_Channels, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_TsnChanAction_cmd_chan_Eq_ALL_CHANNELS_Returns_CF_TraverseAllTransactions_All_Channels"); + "Test_CF_TsnChanAction_cmd_chan_Eq_ALL_CHANNELS_Return_CF_TraverseAllTransactions_All_Channels"); UtTest_Add(Test_CF_TsnChanAction_cmd_chan_IsASingleChannel, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, "Test_CF_TsnChanAction_cmd_chan_IsASingleChannel"); - UtTest_Add(Test_CF_TsnChanAction_cmd_FailsBecause_cmd_chan_IsInvalid, + UtTest_Add(Test_CF_TsnChanAction_cmd_FailBecause_cmd_chan_IsInvalid, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_TsnChanAction_cmd_FailsBecause_cmd_chan_IsInvalid"); + "Test_CF_TsnChanAction_cmd_FailBecause_cmd_chan_IsInvalid"); }/* end add_CF_TsnChanAction_tests */ void add_CF_DoSuspRes__tests(void) @@ -5191,107 +5074,107 @@ void add_CF_DoSuspRes__tests(void) UtTest_Add(Test_CF_DoSuspRes__Asserts_t_Is_NULL, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, "Test_CF_DoSuspRes__Asserts_t_Is_NULL"); - UtTest_Add(Test_CF_DoSuspRes__Sets_context_same_To_1_suspended_Eq_action, + UtTest_Add(Test_CF_DoSuspRes__Set_context_same_To_1_suspended_Eq_action, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoSuspRes__Sets_context_same_To_1_suspended_Eq_action"); - UtTest_Add(Test_CF_DoSuspRes__Sets_suspended_To_action_Because_suspended_NotEq_action, + "Test_CF_DoSuspRes__Set_context_same_To_1_suspended_Eq_action"); + UtTest_Add(Test_CF_DoSuspRes__When_suspended_NotEqTo_action_Set_suspended_To_action, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoSuspRes__Sets_suspended_To_action_Because_suspended_NotEq_action"); + "Test_CF_DoSuspRes__When_suspended_NotEqTo_action_Set_suspended_To_action"); }/* end add_CF_DoSuspRes__tests */ void add_CF_DoSuspRes_tests(void) { - UtTest_Add(Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasChangedTo_1_SendsEventAndRejectsCmd, + UtTest_Add(Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasChangedTo_1_SendEventAndRejectCmd, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasChangedTo_1_SendsEventAndRejectsCmd"); - UtTest_Add(Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasChangedTo_1_SendsEventAndRejectsCmd, + "Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasChangedTo_1_SendEventAndRejectCmd"); + UtTest_Add(Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasChangedTo_1_SendEventAndRejectCmd, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasChangedTo_1_SendsEventAndRejectsCmd"); - UtTest_Add(Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasNotChangedFrom_0_SendsEventAndRejectsCmd, + "Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasChangedTo_1_SendEventAndRejectCmd"); + UtTest_Add(Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasNotChangedFrom_0_SendEventAndRejectCmd, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasNotChangedFrom_0_SendsEventAndRejectsCmd"); - UtTest_Add(Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasNotChangedFrom_0_AcceptsCmd, + "Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_neg1_And_args_same_WasNotChangedFrom_0_SendEventAndRejectCmd"); + UtTest_Add(Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasNotChangedFrom_0_AcceptCmd, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasNotChangedFrom_0_AcceptsCmd"); + "Test_CF_DoSuspRes_CallTo_CF_TsnChanAction_Returns_0_And_args_same_WasNotChangedFrom_0_AcceptCmd"); }/* end add_CF_DoSuspRes_tests */ void add_CF_CmdSuspend_tests(void) { - UtTest_Add(Test_CF_CmdSuspend_Calls_CF_DoSuspRes_WithGiven_msg_And_action_1, + UtTest_Add(Test_CF_CmdSuspend_Call_CF_DoSuspRes_WithGiven_msg_And_action_1, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdSuspend_Calls_CF_DoSuspRes_WithGiven_msg_And_action_1"); + "Test_CF_CmdSuspend_Call_CF_DoSuspRes_WithGiven_msg_And_action_1"); }/* end add_CF_CmdSuspend_tests */ void add_CF_CmdResume_tests(void) { - UtTest_Add(Test_CF_CmdResume_Calls_CF_DoSuspRes_WithGiven_msg_And_action_0, + UtTest_Add(Test_CF_CmdResume_Call_CF_DoSuspRes_WithGiven_msg_And_action_0, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdResume_Calls_CF_DoSuspRes_WithGiven_msg_And_action_0"); + "Test_CF_CmdResume_Call_CF_DoSuspRes_WithGiven_msg_And_action_0"); }/* end add_CF_CmdResume_tests */ void add_CF_CmdCancel__tests(void) { - UtTest_Add(Test_CF_CmdCancel__Calls_CF_CFDP_CancelTransaction_WithGiven_t, + UtTest_Add(Test_CF_CmdCancel__Call_CF_CFDP_CancelTransaction_WithGiven_t, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdCancel__Calls_CF_CFDP_CancelTransaction_WithGiven_t"); + "Test_CF_CmdCancel__Call_CF_CFDP_CancelTransaction_WithGiven_t"); }/* end add_CF_CF_CmdCancel__tests */ void add_CF_CmdCancel_tests(void) { - UtTest_Add(Test_CF_CmdCancel_Calls_CF_CmdCond_WithNotted_CF_TsnChanAction, + UtTest_Add(Test_CF_CmdCancel_Call_CF_CmdCond_WithNotted_CF_TsnChanAction, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdCancel_Calls_CF_CmdCond_WithNotted_CF_TsnChanAction"); + "Test_CF_CmdCancel_Call_CF_CmdCond_WithNotted_CF_TsnChanAction"); }/* end add_CF_CmdCancel_tests */ void add_CF_CmdAbandon__tests(void) { - UtTest_Add(Test_CF_CmdAbandon__Calls_CF_CFDP_ResetTransaction_WithGiven_t_And_0, + UtTest_Add(Test_CF_CmdAbandon__Call_CF_CFDP_ResetTransaction_WithGiven_t_And_0, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdAbandon__Calls_CF_CFDP_ResetTransaction_WithGiven_t_And_0"); + "Test_CF_CmdAbandon__Call_CF_CFDP_ResetTransaction_WithGiven_t_And_0"); }/* end add_CF_CmdAbandon__tests */ void add_CF_CmdAbandon_tests(void) { - UtTest_Add(Test_CF_CmdAbandon_Calls_CF_CmdCond_WithNotted_CF_TsnChanAction, + UtTest_Add(Test_CF_CmdAbandon_Call_CF_CmdCond_WithNotted_CF_TsnChanAction, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdAbandon_Calls_CF_CmdCond_WithNotted_CF_TsnChanAction"); + "Test_CF_CmdAbandon_Call_CF_CmdCond_WithNotted_CF_TsnChanAction"); }/* end add_CF_CmdAbandon__tests */ void add_CF_DoEnableDisableDequeue_tests(void) { - UtTest_Add(Test_CF_DoEnableDisableDequeue_Sets_chan_num_EnabledFlagTo_context_barg, + UtTest_Add(Test_CF_DoEnableDisableDequeue_Set_chan_num_EnabledFlagTo_context_barg, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoEnableDisableDequeue_Sets_chan_num_EnabledFlagTo_context_barg"); + "Test_CF_DoEnableDisableDequeue_Set_chan_num_EnabledFlagTo_context_barg"); }/* end add_CF_DoEnableDisableDequeue_tests */ void add_CF_CmdEnableDequeue_tests(void) { - UtTest_Add(Test_CF_CmdEnableDequeue_Calls_CmdCond_WithResultsOf_CF_DoChanAction, + UtTest_Add(Test_CF_CmdEnableDequeue_Call_CmdCond_WithResultsOf_CF_DoChanAction, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdEnableDequeue_Calls_CmdCond_WithResultsOf_CF_DoChanAction"); + "Test_CF_CmdEnableDequeue_Call_CmdCond_WithResultsOf_CF_DoChanAction"); }/* end add_CF_CmdEnableDequeue_tests */ void add_CF_CmdDisableDequeue_tests(void) { - UtTest_Add(Test_CF_CmdDisableDequeue_Calls_CmdCond_WithResultsOf_CF_DoChanAction, + UtTest_Add(Test_CF_CmdDisableDequeue_Call_CmdCond_WithResultsOf_CF_DoChanAction, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdDisableDequeue_Calls_CmdCond_WithResultsOf_CF_DoChanAction"); + "Test_CF_CmdDisableDequeue_Call_CmdCond_WithResultsOf_CF_DoChanAction"); }/* end add_CF_CmdDisableDequeue_tests */ void add_CF_DoEnableDisablePolldir_tests(void) { - UtTest_Add(Test_CF_DoEnableDisablePolldir_SetsAllPolldirsInChannelEnabledTo_context_barg_When_ALL_CHANNELS, + UtTest_Add(Test_CF_DoEnableDisablePolldir_When_ALL_CHANNELS_SetAllPolldirsInChannelEnabledTo_context_barg, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoEnableDisablePolldir_SetsAllPolldirsInChannelEnabledTo_context_barg_When_ALL_CHANNELS"); - UtTest_Add(Test_CF_DoEnableDisablePolldir_SetsPolldirFrom_context_ChannelEnabledTo_context_barg_WhenSetToSpecificPolldir, + "Test_CF_DoEnableDisablePolldir_When_ALL_CHANNELS_SetAllPolldirsInChannelEnabledTo_context_barg"); + UtTest_Add(Test_CF_DoEnableDisablePolldir_WhenSetToSpecificPolldirSetPolldirFrom_context_ChannelEnabledTo_context_barg, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoEnableDisablePolldir_SetsPolldirFrom_context_ChannelEnabledTo_context_barg_WhenSetToSpecificPolldir"); - UtTest_Add(Test_CF_DoEnableDisablePolldir_FailsPolldirEq_CF_MAX_POLLING_DIR_PER_CHAN_AndSendsEvent, + "Test_CF_DoEnableDisablePolldir_WhenSetToSpecificPolldirSetPolldirFrom_context_ChannelEnabledTo_context_barg"); + UtTest_Add(Test_CF_DoEnableDisablePolldir_FailPolldirEq_CF_MAX_POLLING_DIR_PER_CHAN_AndSendEvent, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoEnableDisablePolldir_FailsPolldirEq_CF_MAX_POLLING_DIR_PER_CHAN_AndSendsEvent"); - UtTest_Add(Test_CF_DoEnableDisablePolldir_FailsAnyBadPolldirSendsEvent, + "Test_CF_DoEnableDisablePolldir_FailPolldirEq_CF_MAX_POLLING_DIR_PER_CHAN_AndSendEvent"); + UtTest_Add(Test_CF_DoEnableDisablePolldir_FailAnyBadPolldirSendEvent, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoEnableDisablePolldir_FailsAnyBadPolldirSendsEvent"); + "Test_CF_DoEnableDisablePolldir_FailAnyBadPolldirSendEvent"); }/* end add_CF_DoEnableDisablePolldir_tests */ void add_CF_CmdEnablePolldir_tests(void) @@ -5316,16 +5199,16 @@ void add_CF_CmdDisablePolldir_tests(void) void add_CF_PurgeHistory_tests(void) { - UtTest_Add(Test_CF_PurgeHistory_Calls_CF_CFDP_ResetHistory_AndReturns_CLIST_CONT, + UtTest_Add(Test_CF_PurgeHistory_Call_CF_CFDP_ResetHistory_AndReturn_CLIST_CONT, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_PurgeHistory_Calls_CF_CFDP_ResetHistory_AndReturns_CLIST_CONT"); + "Test_CF_PurgeHistory_Call_CF_CFDP_ResetHistory_AndReturn_CLIST_CONT"); }/* end add_CF_PurgeHistory_tests */ void add_CF_PurgeTransaction_tests(void) { - UtTest_Add(Test_CF_PurgeTransaction_Calls_CF_CFDP_ResetTransaction_AndReturns_CLIST_CONT, + UtTest_Add(Test_CF_PurgeTransaction_Call_CF_CFDP_ResetTransaction_AndReturn_CLIST_CONT, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_PurgeTransaction_Calls_CF_CFDP_ResetTransaction_AndReturns_CLIST_CONT"); + "Test_CF_PurgeTransaction_Call_CF_CFDP_ResetTransaction_AndReturn_CLIST_CONT"); }/* end add_CF_PurgeTransaction_tests */ void add_CF_DoPurgeQueue_tests(void) @@ -5339,12 +5222,12 @@ void add_CF_DoPurgeQueue_tests(void) UtTest_Add(Test_CF_DoPurgeQueue_Both, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, "Test_CF_DoPurgeQueue_Both"); - UtTest_Add(Test_CF_DoPurgeQueue_GivenBad_data_byte_1_SendsEventAndReturns_neg1, + UtTest_Add(Test_CF_DoPurgeQueue_GivenBad_data_byte_1_SendEventAndReturn_neg1, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoPurgeQueue_GivenBad_data_byte_1_SendsEventAndReturns_neg1"); - UtTest_Add(Test_CF_DoPurgeQueue_AnyGivenBad_data_byte_1_SendsEventAndReturns_neg1, + "Test_CF_DoPurgeQueue_GivenBad_data_byte_1_SendEventAndReturn_neg1"); + UtTest_Add(Test_CF_DoPurgeQueue_AnyGivenBad_data_byte_1_SendEventAndReturn_neg1, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_DoPurgeQueue_AnyGivenBad_data_byte_1_SendsEventAndReturns_neg1"); + "Test_CF_DoPurgeQueue_AnyGivenBad_data_byte_1_SendEventAndReturn_neg1"); }/* end add_CF_DoPurgeQueue_tests */ void add_CF_CmdPurgeQueue_tests(void) @@ -5356,200 +5239,199 @@ void add_CF_CmdPurgeQueue_tests(void) void add_CF_CmdWriteQueue_tests(void) { - UtTest_Add(Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_chan_Eq_CF_NUM_CAHNNELS, + UtTest_Add(Test_CF_CmdWriteQueue_When_chan_Eq_CF_NUM_CAHNNELS_SendEventAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_chan_Eq_CF_NUM_CAHNNELS"); - UtTest_Add(Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_chan_GreaterThan_CF_NUM_CAHNNELS, + "Test_CF_CmdWriteQueue_When_chan_Eq_CF_NUM_CAHNNELS_SendEventAndRejectCommand"); + UtTest_Add(Test_CF_CmdWriteQueue_When_chan_GreaterThan_CF_NUM_CAHNNELS_SendEventAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_chan_GreaterThan_CF_NUM_CAHNNELS"); - UtTest_Add(Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhenUpAndPendingQueue, + "Test_CF_CmdWriteQueue_When_chan_GreaterThan_CF_NUM_CAHNNELS_SendEventAndRejectCommand"); + UtTest_Add(Test_CF_CmdWriteQueue_WhenUpAndPendingQueueSendEventAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhenUpAndPendingQueue"); - UtTest_Add(Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_CF_WrappedCreat_Fails_type_Is_type_up_And_queue_IsNot_q_pend, + "Test_CF_CmdWriteQueue_WhenUpAndPendingQueueSendEventAndRejectCommand"); + UtTest_Add(Test_CF_CmdWriteQueue_When_CF_WrappedCreat_Fails_type_Is_type_up_And_queue_IsNot_q_pend_SendEventAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_CF_WrappedCreat_Fails_type_Is_type_up_And_queue_IsNot_q_pend"); - UtTest_Add(Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_CF_WrappedCreat_Fails_type_IsNot_type_up_And_queue_Is_q_pend, + "Test_CF_CmdWriteQueue_When_CF_WrappedCreat_Fails_type_Is_type_up_And_queue_IsNot_q_pend_SendEventAndRejectCommand"); + UtTest_Add(Test_CF_CmdWriteQueue_When_CF_WrappedCreat_Fails_type_IsNot_type_up_And_queue_Is_q_pend_SendEventAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhen_CF_WrappedCreat_Fails_type_IsNot_type_up_And_queue_Is_q_pend"); - UtTest_Add(Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteQueueDataToFile_FailsWhen_wq_IsAllAnd_queue_IsAll_fd_Is_0_Calls_CF_WrappedClose, + "Test_CF_CmdWriteQueue_When_CF_WrappedCreat_Fails_type_IsNot_type_up_And_queue_Is_q_pend_SendEventAndRejectCommand"); + UtTest_Add(Test_CF_CmdWriteQueue_When_wq_IsAllAnd_queue_IsAll_fd_Is_0_Call_CF_WrappedClose_SendEventCloseAndRejectCommandWhen_CF_WriteQueueDataToFile_Fails, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteQueueDataToFile_FailsWhen_wq_IsAllAnd_queue_IsAll_fd_Is_0_Calls_CF_WrappedClose"); - UtTest_Add(Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteQueueDataToFile_FailsWhen_wq_IsUpAnd_queue_IsActive_fd_IsPositive_Calls_CF_WrappedClose, + "Test_CF_CmdWriteQueue_When_wq_IsAllAnd_queue_IsAll_fd_Is_0_Call_CF_WrappedClose_SendEventCloseAndRejectCommandWhen_CF_WriteQueueDataToFile_Fails"); + UtTest_Add(Test_CF_CmdWriteQueue_When_CF_WriteQueueDataToFile_FailsAnd_wq_IsUpAnd_queue_IsActive_fd_IsPositive_Call_CF_WrappedClose_SendEventClosesAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteQueueDataToFile_FailsWhen_wq_IsUpAnd_queue_IsActive_fd_IsPositive_Calls_CF_WrappedClose"); - UtTest_Add(Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQueueDataToFile_FailsWhen_wq_IsUpAnd_queue_IsHistory_fd_IsPositive_Calls_CF_WrappedClose, + "Test_CF_CmdWriteQueue_When_CF_WriteQueueDataToFile_FailsAnd_wq_IsUpAnd_queue_IsActive_fd_IsPositive_Call_CF_WrappedClose_SendEventClosesAndRejectCommand"); + UtTest_Add(Test_CF_CmdWriteQueue_When_CF_WriteHistoryQueueDataToFile_FailsAnd_wq_IsUpAnd_queue_IsHistory_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQueueDataToFile_FailsWhen_wq_IsUpAnd_queue_IsHistory_fd_IsPositive_Calls_CF_WrappedClose"); - UtTest_Add(Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryDataToFile_FailsOnFirstCallWhen_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Calls_CF_WrappedClose, + "Test_CF_CmdWriteQueue_When_CF_WriteHistoryQueueDataToFile_FailsAnd_wq_IsUpAnd_queue_IsHistory_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand"); + UtTest_Add(Test_CF_CmdWriteQueue_When_CF_WriteHistoryDataToFile_FailsOnFirstCallAnd_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryDataToFile_FailsOnFirstCallWhen_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Calls_CF_WrappedClose"); - UtTest_Add(Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryDataToFile_FailsOnSecondCallWhen_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Calls_CF_WrappedClose, + "Test_CF_CmdWriteQueue_When_CF_WriteHistoryDataToFile_FailsOnFirstCallAnd_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand"); + UtTest_Add(Test_CF_CmdWriteQueue_When_CF_WriteHistoryDataToFile_FailsOnSecondCallAnd_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryDataToFile_FailsOnSecondCallWhen_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Calls_CF_WrappedClose"); - UtTest_Add(Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQueueDataToFile_FailsWhen_wq_IsDownAnd_queue_IsPend_fd_IsPositive_Calls_CF_WrappedClose, + "Test_CF_CmdWriteQueue_When_CF_WriteHistoryDataToFile_FailsOnSecondCallAnd_wq_IsDownAnd_queue_IsActive_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand"); + UtTest_Add(Test_CF_CmdWriteQueue_When_CF_WriteHistoryQueueDataToFile_FailsAnd_wq_IsDownAnd_queue_IsPend_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQueueDataToFile_FailsWhen_wq_IsDownAnd_queue_IsPend_fd_IsPositive_Calls_CF_WrappedClose"); - UtTest_Add(Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQueueDataToFile_FailsWhen_wq_IsDownAnd_queue_IsHistory_fd_IsPositive_Calls_CF_WrappedClose, + "Test_CF_CmdWriteQueue_When_CF_WriteHistoryQueueDataToFile_FailsAnd_wq_IsDownAnd_queue_IsPend_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand"); + UtTest_Add(Test_CF_CmdWriteQueue_When_CF_WriteHistoryQueueDataToFile_FailsAnd_wq_IsDownAnd_queue_IsHistory_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SendsEventClosesAndRejectCommandWhen_CF_WriteHistoryQueueDataToFile_FailsWhen_wq_IsDownAnd_queue_IsHistory_fd_IsPositive_Calls_CF_WrappedClose"); - UtTest_Add(Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_All, + "Test_CF_CmdWriteQueue_When_CF_WriteHistoryQueueDataToFile_FailsAnd_wq_IsDownAnd_queue_IsHistory_fd_IsPositive_Call_CF_WrappedClose_SendEventCloseAndRejectCommand"); + UtTest_Add(Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_All, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_All"); - UtTest_Add(Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_History, + "Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_All"); + UtTest_Add(Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_History, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_History"); - UtTest_Add(Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_Active, + "Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_History"); + UtTest_Add(Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_Active, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_Active"); - UtTest_Add(Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_Pend, + "Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_Active"); + UtTest_Add(Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_Pend, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_AllAnd_q_Pend"); - UtTest_Add(Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_All, + "Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_AllAnd_q_Pend"); + UtTest_Add(Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_UpAnd_q_All, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_All"); - UtTest_Add(Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_History, + "Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_UpAnd_q_All"); + UtTest_Add(Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_UpAnd_q_History, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_History"); - UtTest_Add(Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_Active, + "Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_UpAnd_q_History"); + UtTest_Add(Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_UpAnd_q_Active, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_UpAnd_q_Active"); - /* see Test_CF_CmdWriteQueue_SendsEventAndRejectCommandWhenUpAndPendingQueue */ - UtTest_Add(Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_All, + "Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_UpAnd_q_Active"); + /* see Test_CF_CmdWriteQueue_WhenUpAndPendingQueueSendEventAndRejectCommand */ + UtTest_Add(Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_All, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_All"); - UtTest_Add(Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_History, + "Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_All"); + UtTest_Add(Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_History, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_History"); - UtTest_Add(Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Active, + "Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_History"); + UtTest_Add(Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_Active, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Active"); - UtTest_Add(Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Pend, + "Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_Active"); + UtTest_Add(Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_Pend, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdWriteQueue_SuccessCalls_CF_CmdAcc_type_DownAnd_q_Pend"); + "Test_CF_CmdWriteQueue_SuccessCall_CF_CmdAcc_type_DownAnd_q_Pend"); } /* end add_CF_CmdWriteQueue_tests */ void add_CF_CmdSendCfgParams_tests(void) { - UtTest_Add(Test_CF_CmdSendCfgParams_Sets_cfg_TimeStampsAndSendsMsg_AcceptsCommand, + UtTest_Add(Test_CF_CmdSendCfgParams_Set_cfg_TimeStampAndSendMsg_AcceptCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdSendCfgParams_Sets_cfg_TimeStampsAndSendsMsg_AcceptsCommand"); + "Test_CF_CmdSendCfgParams_Set_cfg_TimeStampAndSendMsg_AcceptCommand"); } /* end add_CF_CmdSendCfgParams_tests */ void add_CF_CmdValidateChunkSize_tests(void) { - UtTest_Add(Test_CF_CmdValidateChunkSize_val_GreaterThan_pdu_fd_data_t_FailsAndReturns_1, + UtTest_Add(Test_CF_CmdValidateChunkSize_val_GreaterThan_pdu_fd_data_t_FailAndReturn_1, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdValidateChunkSize_val_GreaterThan_pdu_fd_data_t_FailsAndReturns_1"); - UtTest_Add(Test_CF_CmdValidateChunkSize_Any_val_GreaterThan_pdu_fd_data_t_FailsAndReturns_1, + "Test_CF_CmdValidateChunkSize_val_GreaterThan_pdu_fd_data_t_FailAndReturn_1"); + UtTest_Add(Test_CF_CmdValidateChunkSize_Any_val_GreaterThan_pdu_fd_data_t_FailAndReturn_1, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdValidateChunkSize_Any_val_GreaterThan_pdu_fd_data_t_FailsAndReturns_1"); - UtTest_Add(Test_CF_CmdValidateChunkSize_val_SizeOf_pdu_fd_data_t_SuccessAndReturns_0, + "Test_CF_CmdValidateChunkSize_Any_val_GreaterThan_pdu_fd_data_t_FailAndReturn_1"); + UtTest_Add(Test_CF_CmdValidateChunkSize_val_SizeOf_pdu_fd_data_t_SuccessAndReturn_0, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdValidateChunkSize_val_SizeOf_pdu_fd_data_t_SuccessAndReturns_0"); - UtTest_Add(Test_CF_CmdValidateChunkSize_val_LessThanOrEqSizeOf_pdu_fd_data_t_SuccessAndReturns_0, + "Test_CF_CmdValidateChunkSize_val_SizeOf_pdu_fd_data_t_SuccessAndReturn_0"); + UtTest_Add(Test_CF_CmdValidateChunkSize_val_LessThanOrEqSizeOf_pdu_fd_data_t_SuccessAndReturn_0, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdValidateChunkSize_val_LessThanOrEqSizeOf_pdu_fd_data_t_SuccessAndReturns_0"); + "Test_CF_CmdValidateChunkSize_val_LessThanOrEqSizeOf_pdu_fd_data_t_SuccessAndReturn_0"); }/* end add_CF_CmdValidateChunkSize_tests */ void add_CF_CmdValidateMaxOutgoing_tests(void) { - UtTest_Add(Test_CF_CmdValidateMaxOutgoing_SuccessBecauseGiven_val_IsNot_0_Returns_0, + UtTest_Add(Test_CF_CmdValidateMaxOutgoing_WhenGiven_val_IsNot_0_Return_0_Success, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdValidateMaxOutgoing_SuccessBecauseGiven_val_IsNot_0_Returns_0"); - UtTest_Add(Test_CF_CmdValidateMaxOutgoing_SuccessBecauseGiven_val_Is_0_But_sem_name_IsNot_NULL_Returns_0, + "Test_CF_CmdValidateMaxOutgoing_WhenGiven_val_IsNot_0_Return_0_Success"); + UtTest_Add(Test_CF_CmdValidateMaxOutgoing_WhenGiven_val_Is_0_But_sem_name_IsNot_NULL_Return_0_Success, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdValidateMaxOutgoing_SuccessBecauseGiven_val_Is_0_But_sem_name_IsNot_NULL_Returns_0"); - UtTest_Add(Test_CF_CmdValidateMaxOutgoing_FailBecauseGiven_val_Is_0_And_sem_name_Is_NULL_Returns_1, + "Test_CF_CmdValidateMaxOutgoing_WhenGiven_val_Is_0_But_sem_name_IsNot_NULL_Return_0_Success"); + UtTest_Add(Test_CF_CmdValidateMaxOutgoing_WhenGiven_val_Is_0_And_sem_name_Is_NULL_Return_1_Fail, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdValidateMaxOutgoing_FailBecauseGiven_val_Is_0_And_sem_name_Is_NULL_Returns_1"); + "Test_CF_CmdValidateMaxOutgoing_WhenGiven_val_Is_0_And_sem_name_Is_NULL_Return_1_Fail"); } /* end add_CF_CmdValidateMaxOutgoing_tests */ void add_CF_CmdGetSetParam_tests(void) { - UtTest_Add(Test_CF_CmdGetSetParam_FailsSendsEventAndRejectsCmd_param_id_Eq_CF_NUM_CFG_PACKET_ITEMS, + UtTest_Add(Test_CF_CmdGetSetParam_When_param_id_Eq_CF_NUM_CFG_PACKET_ITEMS_FailSendEventAndRejectCmd, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdGetSetParam_FailsSendsEventAndRejectsCmd_param_id_Eq_CF_NUM_CFG_PACKET_ITEMS"); - UtTest_Add(Test_CF_CmdGetSetParam_FailsSendsEventAndRejectsCmd_param_id_AnyGreaterThan_CF_NUM_CFG_PACKET_ITEMS, + "Test_CF_CmdGetSetParam_When_param_id_Eq_CF_NUM_CFG_PACKET_ITEMS_FailSendEventAndRejectCmd"); + UtTest_Add(Test_CF_CmdGetSetParam_When_param_id_AnyGreaterThan_CF_NUM_CFG_PACKET_ITEMS_FailSendEventAndRejectCmd, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdGetSetParam_FailsSendsEventAndRejectsCmd_param_id_AnyGreaterThan_CF_NUM_CFG_PACKET_ITEMS"); - UtTest_Add(Test_CF_CmdGetSetParam_Given_chan_num_IsEqTo_CF_NUM_CHANNELS_ErrorsOutAndCountsError, + "Test_CF_CmdGetSetParam_When_param_id_AnyGreaterThan_CF_NUM_CFG_PACKET_ITEMS_FailSendEventAndRejectCmd"); + UtTest_Add(Test_CF_CmdGetSetParam_Given_chan_num_IsEqTo_CF_NUM_CHANNELS_ErrorOutAndCountError, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdGetSetParam_Given_chan_num_IsEqTo_CF_NUM_CHANNELS_ErrorsOutAndCountsError"); - UtTest_Add(Test_CF_CmdGetSetParam_Given_chan_num_IsGreaterThan_CF_NUM_CHANNELS_ErrorsOutAndCountsError, + "Test_CF_CmdGetSetParam_Given_chan_num_IsEqTo_CF_NUM_CHANNELS_ErrorOutAndCountError"); + UtTest_Add(Test_CF_CmdGetSetParam_Given_chan_num_IsGreaterThan_CF_NUM_CHANNELS_ErrorOutAndCountError, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdGetSetParam_Given_chan_num_IsGreaterThan_CF_NUM_CHANNELS_ErrorsOutAndCountsError"); - UtTest_Add(Test_CF_CmdGetSetParam_is_set_Is_0_And_param_id_Is_0_MemCopiesSendsEventAndAcceptsCommand, + "Test_CF_CmdGetSetParam_Given_chan_num_IsGreaterThan_CF_NUM_CHANNELS_ErrorOutAndCountError"); + UtTest_Add(Test_CF_CmdGetSetParam_When_is_set_Is_0_And_param_id_Is_0_MemCopySendEventAndAcceptCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdGetSetParam_is_set_Is_0_And_param_id_Is_0_MemCopiesSendsEventAndAcceptsCommand"); - UtTest_Add(Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_0_HasANull_fn_ThenCopies_value_To_ptr_SendsEventAndAcceptsCommand, + "Test_CF_CmdGetSetParam_When_is_set_Is_0_And_param_id_Is_0_MemCopySendEventAndAcceptCommand"); + UtTest_Add(Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_0_HasANull_fn_ThenCopy_value_To_ptr_SendEventAndAcceptCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_0_HasANull_fn_ThenCopies_value_To_ptr_SendsEventAndAcceptsCommand"); - UtTest_Add(Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_SendsEventBecause_fn_Returned_1_AndRejectsCommand, + "Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_0_HasANull_fn_ThenCopy_value_To_ptr_SendEventAndAcceptCommand"); + UtTest_Add(Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_SendEventBecause_fn_Returned_1_AndRejectCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_SendsEventBecause_fn_Returned_1_AndRejectsCommand"); - UtTest_Add(Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_ThenCopies_value_To_ptr_Because_fn_Returned_0_SendsEventAndAcceptsCommand, + "Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_SendEventBecause_fn_Returned_1_AndRejectCommand"); + UtTest_Add(Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_ThenCopy_value_To_ptr_Because_fn_Returned_0_SendEventAndAcceptCommand, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdGetSetParam_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_ThenCopies_value_To_ptr_Because_fn_Returned_0_SendsEventAndAcceptsCommand"); + "Test_CF_CmdGetSetParam_When_is_set_Is_1_And_param_id_Is_5_Uses_SPTRFN_ThenCopy_value_To_ptr_Because_fn_Returned_0_SendEventAndAcceptCommand"); }/* end add_CF_CmdGetSetParam_tests */ void add_CF_CmdSetParam_tests(void) { - UtTest_Add(Test_CF_CmdSetParam_Calls_CF_CmdGetSetParam_With_cmd_key_And_cmd_value, + UtTest_Add(Test_CF_CmdSetParam_Call_CF_CmdGetSetParam_With_cmd_key_And_cmd_value, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdSetParam_Calls_CF_CmdGetSetParam_With_cmd_key_And_cmd_value"); + "Test_CF_CmdSetParam_Call_CF_CmdGetSetParam_With_cmd_key_And_cmd_value"); }/* end add_CF_CmdSetParam_tests */ void add_CF_CmdGetParam_tests(void) { - UtTest_Add(Test_CF_CmdGetParam_Calls_CF_CmdGetSetParam_With_cmd_data_byte_0_AndConstantValue_0, + UtTest_Add(Test_CF_CmdGetParam_Call_CF_CmdGetSetParam_With_cmd_data_byte_0_AndConstantValue_0, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdGetParam_Calls_CF_CmdGetSetParam_With_cmd_data_byte_0_AndConstantValue_0"); + "Test_CF_CmdGetParam_Call_CF_CmdGetSetParam_With_cmd_data_byte_0_AndConstantValue_0"); }/* end add_CF_CmdGetParam_tests */ void add_CF_CmdEnableEngine_tests(void) { - UtTest_Add(Test_CF_CmdEnableEngine_WithEngineNotEnableInitSucceedsAndIncrementsCmdAccCounter, + UtTest_Add(Test_CF_CmdEnableEngine_WithEngineNotEnableInitSuccessAndIncrementCmdAccCounter, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdEnableEngine_WithEngineNotEnableInitSucceedsAndIncrementsCmdAccCounter"); - UtTest_Add(Test_CF_CmdEnableEngine_WithEngineNotEnableFailsInitSendsEventAndIncrementsCmdRejCounter, + "Test_CF_CmdEnableEngine_WithEngineNotEnableInitSuccessAndIncrementCmdAccCounter"); + UtTest_Add(Test_CF_CmdEnableEngine_WithEngineNotEnableFailsInitSendEventAndIncrementCmdRejCounter, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdEnableEngine_WithEngineNotEnableFailsInitSendsEventAndIncrementsCmdRejCounter"); - UtTest_Add(Test_CF_CmdEnableEngine_WithEngineEnableFailsSendsEventAndIncrementsCmdRejCounter, + "Test_CF_CmdEnableEngine_WithEngineNotEnableFailsInitSendEventAndIncrementCmdRejCounter"); + UtTest_Add(Test_CF_CmdEnableEngine_WithEngineEnableFailsSendEventAndIncrementCmdRejCounter, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdEnableEngine_WithEngineEnableFailsSendsEventAndIncrementsCmdRejCounter"); + "Test_CF_CmdEnableEngine_WithEngineEnableFailsSendEventAndIncrementCmdRejCounter"); }/* end add_CF_CmdEnableEngine_tests */ void add_CF_CmdDisableEngine_tests(void) { - UtTest_Add(Test_CF_CmdDisableEngine_SuccessWhenEngineEnabledAndIncrementsCmdAccCounter, + UtTest_Add(Test_CF_CmdDisableEngine_SuccessWhenEngineEnabledAndIncrementCmdAccCounter, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdDisableEngine_SuccessWhenEngineEnabledAndIncrementsCmdAccCounter"); - UtTest_Add(Test_CF_CmdDisableEngine_FailsWhenEngineDisabledAndIncrementsCmdAccCounter, + "Test_CF_CmdDisableEngine_SuccessWhenEngineEnabledAndIncrementCmdAccCounter"); + UtTest_Add(Test_CF_CmdDisableEngine_WhenEngineDisabledAndIncrementCmdAccCounterThenFail, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_CmdDisableEngine_FailsWhenEngineDisabledAndIncrementsCmdAccCounter"); + "Test_CF_CmdDisableEngine_WhenEngineDisabledAndIncrementCmdAccCounterThenFail"); }/* end add_CF_CmdDisableEngine_tests */ void add_CF_ProcessGroundCommand_tests(void) { - UtTest_Add(Test_CF_ProcessGroundCommand_Fails_cmd_EqTo_CF_NUM_COMMANDS_AndSendsEvent, + UtTest_Add(Test_CF_ProcessGroundCommand_When_cmd_EqTo_CF_NUM_COMMANDS_FailAndSendEvent, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_ProcessGroundCommand_Fails_cmd_EqTo_CF_NUM_COMMANDS_AndSendsEvent"); - UtTest_Add(Test_CF_ProcessGroundCommand_Fails_cmd_GreaterThan_CF_NUM_COMMANDS_AndSendsEvent, + "Test_CF_ProcessGroundCommand_When_cmd_EqTo_CF_NUM_COMMANDS_FailAndSendEvent"); + UtTest_Add(Test_CF_ProcessGroundCommand_When_cmd_GreaterThan_CF_NUM_COMMANDS_FailAndSendEvent, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_ProcessGroundCommand_Fails_cmd_GreaterThan_CF_NUM_COMMANDS_AndSendsEvent"); - UtTest_Add(Test_CF_ProcessGroundCommand_Receives_cmd_AndLengthDoesNotMatchExpectedForThatCommandSendsEventAndCalls_CF_CmdRej, + "Test_CF_ProcessGroundCommand_When_cmd_GreaterThan_CF_NUM_COMMANDS_FailAndSendEvent"); + UtTest_Add(Test_CF_ProcessGroundCommand_Receives_cmd_AndLengthDoesNotMatchExpectedForThatCommandSendEventAndCall_CF_CmdRej, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_ProcessGroundCommand_Receives_cmd_AndLengthDoesNotMatchExpectedForThatCommandSendsEventAndCalls_CF_CmdRej"); - UtTest_Add(Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x00_AndCalls_CF_CmdNoop_With_msg, + "Test_CF_ProcessGroundCommand_Receives_cmd_AndLengthDoesNotMatchExpectedForThatCommandSendEventAndCall_CF_CmdRej"); + UtTest_Add(Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x00_AndCall_CF_CmdNoop_With_msg, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x00_AndCalls_CF_CmdNoop_With_msg"); - UtTest_Add(Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoesNothingBecause_fns_12_Is_NULL, + "Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x00_AndCall_CF_CmdNoop_With_msg"); + UtTest_Add(Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoNothingBecause_fns_12_Is_NULL, cf_cmd_tests_Setup, cf_cmd_tests_Teardown, - "Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoesNothingBecause_fns_12_Is_NULL"); + "Test_CF_ProcessGroundCommand_ReceivesCmdCode_0x0C_AndDoNothingBecause_fns_12_Is_NULL"); }/* end add_CF_ProcessGroundCommand_tests */ - - +/* end cf_cmd tests UtTest_Add groups */ /******************************************************************************* ** @@ -5645,5 +5527,4 @@ void UtTest_Setup(void) } /* end UtTest_Setup for cf_cmd_tests.c */ - /* end cf_cmd_tests.c */ diff --git a/unit-test/cf_crc_tests.c b/unit-test/cf_crc_tests.c index 53dc5cb8..1c34f2fb 100644 --- a/unit-test/cf_crc_tests.c +++ b/unit-test/cf_crc_tests.c @@ -1,8 +1,6 @@ - /* cf testing includes */ -#include "cf_crc.c" #include "cf_test_utils.h" - +#include "cf_crc.c" /******************************************************************************* ** @@ -25,7 +23,6 @@ uint8 Any_cf_crc_index_except_3(void) } /* end cf_crc_tests local utility functions */ - /******************************************************************************* ** ** cf_crc_tests Setup and Teardown @@ -44,15 +41,13 @@ void cf_crc_tests_Teardown(void) /* end cf_crc_tests Setup and Teardown */ - /******************************************************************************* ** ** CF_CRC_Start tests ** *******************************************************************************/ -void test_CF_CRC_Start_ReinitializesGiven_c_ToAllZeroValues(void) +void test_CF_CRC_Start_ReinitializeGiven_c_ToAllZeroValues(void) { - // TODO: would rather be able to -wrap and therefor stub memset to test this /* Arrange */ cf_crc_t dummy_c; cf_crc_t* arg_c = &dummy_c; @@ -75,8 +70,9 @@ void test_CF_CRC_Start_ReinitializesGiven_c_ToAllZeroValues(void) "c->index was set to %d and should be 0", arg_c->index); -} /* end test_CF_CRC_Start_ReinitializesGiven_c_ToAllZeroValues*/ +} /* end test_CF_CRC_Start_ReinitializeGiven_c_ToAllZeroValues*/ +/* end CF_CRC_Start tests */ /******************************************************************************* ** @@ -84,10 +80,10 @@ void test_CF_CRC_Start_ReinitializesGiven_c_ToAllZeroValues(void) ** *******************************************************************************/ -// TODO: not testing len > data's size, by contract this should not occur, -// should it be an assumption in the doxygen comments? +/* NOTE: not testing len > data's size, by contract this should not occur, +** should it be an assumption in the doxygen comments? */ -void Test_CF_CRC_Digest_DoesNotAlter_c_working_or_c_result_or_c_index_When_len_Eq0(void) +void Test_CF_CRC_Digest_When_len_Is_0_DoNotAlter_c_working_or_c_result_or_c_index(void) { /* Arrange */ cf_crc_t dummy_c; @@ -116,9 +112,9 @@ void Test_CF_CRC_Digest_DoesNotAlter_c_working_or_c_result_or_c_index_When_len_E "c->index is %d which is unchanged from %d", arg_c->index, initial_c_index); -} /* end Test_CF_CRC_Digest_DoesNotAlter_c_working_or_c_result_or_c_index_When_len_Eq0 */ +} /* end Test_CF_CRC_Digest_When_len_Is_0_DoNotAlter_c_working_or_c_result_or_c_index */ -void Test_CF_CRC_Digest_PushesDataLeftOnto_c_working_When_len_Eq1(void) +void Test_CF_CRC_Digest_When_len_Eq_1_PushDataLeftOnto_c_working(void) { /* Arrange */ cf_crc_t dummy_c; @@ -143,9 +139,9 @@ void Test_CF_CRC_Digest_PushesDataLeftOnto_c_working_When_len_Eq1(void) "c->working is %u and should be %u", arg_c->working, expected_c_working); -} /* end Test_CF_CRC_Digest_PushesDataLeftOnto_c_working_When_len_Eq1 */ +} /* end Test_CF_CRC_Digest_When_len_Eq_1_PushDataLeftOnto_c_working */ -void Test_CF_CRC_Digest_PushesDataLeftOnto_c_working_NumberOfTimesEqTo_len(void) +void Test_CF_CRC_Digest_PushDataLeftOnto_c_working_NumberOfTimesEqTo_len(void) { /* Arrange */ cf_crc_t dummy_c; @@ -157,7 +153,7 @@ void Test_CF_CRC_Digest_PushesDataLeftOnto_c_working_NumberOfTimesEqTo_len(void) arg_c->working = Any_uint32(); arg_c->index = Any_cf_crc_index(); - arg_len = Any_uint16_GreaterThan(1) / 2; // TODO: change type if len changes, Any_uint16_GreaterThan(1) / 2 roughly translates to a positive int that runs the test within a reasonable timeframe for size of len, this could change when more is learned about what len is supposed to be + arg_len = Any_uint16_GreaterThan(1) / 2; // NOTE: change type if len changes, Any_uint16_GreaterThan(1) / 2 roughly translates to a positive int that runs the test within a reasonable timeframe for size of len, this could change when more is learned about what len is supposed to be arg_data = malloc((size_t)arg_len); AnyBufferOf_uint8_WithSize((uint8*)arg_data, arg_len); @@ -180,9 +176,9 @@ void Test_CF_CRC_Digest_PushesDataLeftOnto_c_working_NumberOfTimesEqTo_len(void) /* local Teardown */ free((uint8*)arg_data); -} /* end Test_CF_CRC_Digest_PushesDataLeftOnto_c_working_NumberOfTimesEqTo_len */ +} /* end Test_CF_CRC_Digest_PushDataLeftOnto_c_working_NumberOfTimesEqTo_len */ -void Test_CF_CRC_Digest_DoesNotUpdate_c_result_WhenIndexIsNot3(void) +void Test_CF_CRC_Digest_When_index_IsNot_3_DoNotUpdate_c_result(void) { /* Arrange */ cf_crc_t dummy_c; @@ -203,9 +199,9 @@ void Test_CF_CRC_Digest_DoesNotUpdate_c_result_WhenIndexIsNot3(void) "c->result was not altered and is %u and should be %u", arg_c->result, initial_c_result); -} /* end Test_CF_CRC_Digest_Updates_c_result_ */ +} /* end Test_CF_CRC_Digest_When_index_IsNot_3_DoNotUpdate_c_result */ -void Test_CF_CRC_Digest_Updates_c_result_When_c_index_Is3(void) +void Test_CF_CRC_Digest_When_c_index_Is_3_Update_c_result(void) { /* Arrange */ cf_crc_t dummy_c; @@ -233,9 +229,9 @@ void Test_CF_CRC_Digest_Updates_c_result_When_c_index_Is3(void) "c->result is %u and should be %u", arg_c->result, expected_c_result); -} /* end Test_CF_CRC_Digest_Updates_c_result_When_c_index_Is3 */ +} /* end Test_CF_CRC_Digest_When_c_index_Is_3_Update_c_result */ -void Test_CF_CRC_Digest_Updates_c_result_TheNumberOfTimesIndexReaches4(void) +void Test_CF_CRC_Digest_Update_c_result_TheNumberOfTimes_index_Reaches4(void) { /* Arrange */ cf_crc_t dummy_c; @@ -250,7 +246,7 @@ void Test_CF_CRC_Digest_Updates_c_result_TheNumberOfTimesIndexReaches4(void) arg_c->working = Any_uint32(); arg_c->index = Any_cf_crc_index(); arg_c->result = Any_uint32(); - arg_len = (int32) (Any_uint16() / 2); // TODO: change type if len changes, Any_uint16_Except(0) / 2 roughly translates to a positive int that runs the test within a reasonable timeframe for size of len, this could change when more is learned about what len is supposed to be + arg_len = (int32) (Any_uint16_GreaterThan(1) / 2); // NOTE: change type if len changes, Any_uint16_GreaterThan(1) / 2 roughly translates to a positive int that runs the test within a reasonable timeframe for size of len, this could change when more is learned about what len is supposed to be arg_data = malloc((size_t)arg_len); AnyBufferOf_uint8_WithSize((uint8*)arg_data, arg_len); @@ -297,9 +293,9 @@ void Test_CF_CRC_Digest_Updates_c_result_TheNumberOfTimesIndexReaches4(void) /* local Teardown */ free((uint8*)arg_data); -} /* end Test_CF_CRC_Digest_Updates_c_result_TheNumberOfTimesIndexReaches4 */ +} /* end Test_CF_CRC_Digest_Update_c_result_TheNumberOfTimes_index_Reaches4 */ -void Test_CF_CRC_Digest_Updates_c_index_By1When_len_Eq1_And_c_index_LessThan3(void) +void Test_CF_CRC_Digest_When_len_Eq1_And_c_index_LessThan_3_Update_c_index_By_1(void) { /* Arrange */ cf_crc_t dummy_c; @@ -323,9 +319,9 @@ void Test_CF_CRC_Digest_Updates_c_index_By1When_len_Eq1_And_c_index_LessThan3(vo "c->index is %u and should be %u", arg_c->index, expected_c_index); -} /* end Test_CF_CRC_Digest_Updates_c_index_By1When_len_Eq1_And_c_index_LessThan3 */ +} /* end Test_CF_CRC_Digest_When_len_Eq1_And_c_index_LessThan_3_Update_c_index_By_1 */ -void Test_CF_CRC_Digest_Updates_c_index_To0When_len_Eq1_And_c_index_Is3(void) +void Test_CF_CRC_Digest_When_len_Eq1_And_c_index_Is_3_Update_c_index_To_0(void) { /* Arrange */ cf_crc_t dummy_c; @@ -346,9 +342,9 @@ void Test_CF_CRC_Digest_Updates_c_index_To0When_len_Eq1_And_c_index_Is3(void) "c->index is %u and should be 0", arg_c->index); -} /* end Test_CF_CRC_Digest_Updates_c_index_To0When_len_Eq1_And_c_index_Is3 */ +} /* end Test_CF_CRC_Digest_When_len_Eq1_And_c_index_Is_3_Update_c_index_To_0 */ -void Test_CF_CRC_Digest_Updates_c_index_CorrectlyDependingOn_c_index_And_len_Values(void) +void Test_CF_CRC_Digest_Update_c_index_CorrectlyDependingOn_c_index_And_len_Values(void) { /* Arrange */ cf_crc_t dummy_c; @@ -360,7 +356,7 @@ void Test_CF_CRC_Digest_Updates_c_index_CorrectlyDependingOn_c_index_And_len_Val arg_c->working = Any_uint32(); arg_c->index = Any_cf_crc_index(); arg_c->result = Any_uint32(); - arg_len = (int32) (Any_uint16() / 2); // TODO: change type if len changes, Any_uint16_Except(0) / 2 roughly translates to a positive int that runs the test within a reasonable timeframe for size of len, this could change when more is learned about what len is supposed to be + arg_len = (int32) (Any_uint16_GreaterThan(1) / 2); // NOTE: change type if len changes, Any_uint16_GreaterThan(1) / 2 roughly translates to a positive int that runs the test within a reasonable timeframe for size of len, this could change when more is learned about what len is supposed to be arg_data = malloc((size_t)arg_len); AnyBufferOf_uint8_WithSize((uint8*)arg_data, arg_len); @@ -378,7 +374,7 @@ void Test_CF_CRC_Digest_Updates_c_index_CorrectlyDependingOn_c_index_And_len_Val /* local Teardown */ free((uint8*)arg_data); -} /* end Test_CF_CRC_Digest_Updates_c_index_To0When_len_Eq1_And_c_index_Is3 */ +} /* end Test_CF_CRC_Digest_Update_c_index_CorrectlyDependingOn_c_index_And_len_Values */ /* end CF_CRC_Digest tests */ @@ -388,7 +384,7 @@ void Test_CF_CRC_Digest_Updates_c_index_CorrectlyDependingOn_c_index_And_len_Val ** *******************************************************************************/ -void Test_CF_CRC_Finalize_DoesNothingWhenIndexIs0(void) +void Test_CF_CRC_Finalize_When_index_Is_0_DoNothing(void) { /* Arrange */ cf_crc_t dummy_c; @@ -413,9 +409,9 @@ void Test_CF_CRC_Finalize_DoesNothingWhenIndexIs0(void) UtAssert_True(arg_c->index == 0, "c->index is %d which is unchanged from 0", arg_c->index); -} /* end Test_CF_CRC_Finalize_DoesNothingWhenIndexIs0 */ +} /* end Test_CF_CRC_Finalize_When_index_Is_0_DoNothing */ -void Test_CF_CRC_Finalize_Getsexpected_resultAtIndex1(void) +void Test_CF_CRC_Finalize_ReceiveExpectedResultAt_index_1(void) { /* Arrange */ cf_crc_t dummy_c; @@ -442,9 +438,9 @@ void Test_CF_CRC_Finalize_Getsexpected_resultAtIndex1(void) UtAssert_True(arg_c->index == 0, "c->index is %u and it should be 0", arg_c->index); -} /* end Test_CF_CRC_Finalize_Getsexpected_resultAtIndex1 */ +} /* end Test_CF_CRC_Finalize_ReceiveExpectedResultAt_index_1 */ -void Test_CF_CRC_Finalize_Getsexpected_resultAtIndex2(void) +void Test_CF_CRC_Finalize_ReceiveExpectedResultAt_index_2(void) { /* Arrange */ cf_crc_t dummy_c; @@ -472,9 +468,9 @@ void Test_CF_CRC_Finalize_Getsexpected_resultAtIndex2(void) UtAssert_True(arg_c->index == 0, "c->index is %u and it should be 0", arg_c->index); -} /* end Test_CF_CRC_Finalize_Getsexpected_resultAtIndex2 */ +} /* end Test_CF_CRC_Finalize_ReceiveExpectedResultAt_index_2 */ -void Test_CF_CRC_Finalize_Getsexpected_resultAtIndex3(void) +void Test_CF_CRC_Finalize_ReceiveExpectedResultAt_index_3(void) { /* Arrange */ cf_crc_t dummy_c; @@ -502,72 +498,71 @@ void Test_CF_CRC_Finalize_Getsexpected_resultAtIndex3(void) UtAssert_True(arg_c->index == 0, "c->index is %u and it should be 0", arg_c->index); -} /* end Test_CF_CRC_Finalize_Getsexpected_resultAtIndex3 */ +} /* end Test_CF_CRC_Finalize_ReceiveExpectedResultAt_index_3 */ /* end CF_CRC_Finalize tests */ - - /******************************************************************************* ** -** cf_crc_tests ADD TESTS functions +** cf_crc_tests UtTest_Add groups ** *******************************************************************************/ void add_CF_CRC_Start_tests(void) { - UtTest_Add(test_CF_CRC_Start_ReinitializesGiven_c_ToAllZeroValues, + UtTest_Add(test_CF_CRC_Start_ReinitializeGiven_c_ToAllZeroValues, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "test_CF_CRC_Start_ReinitializesGiven_c_ToAllZeroValues"); -} + "test_CF_CRC_Start_ReinitializeGiven_c_ToAllZeroValues"); +} /* end add_CF_CRC_Start_tests */ void add_CF_CRC_Digest_tests(void) { - UtTest_Add(Test_CF_CRC_Digest_DoesNotAlter_c_working_or_c_result_or_c_index_When_len_Eq0, + UtTest_Add(Test_CF_CRC_Digest_When_len_Is_0_DoNotAlter_c_working_or_c_result_or_c_index, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Digest_DoesNotAlter_c_working_or_c_result_or_c_index_When_len_Eq0"); - UtTest_Add(Test_CF_CRC_Digest_PushesDataLeftOnto_c_working_When_len_Eq1, + "Test_CF_CRC_Digest_When_len_Is_0_DoNotAlter_c_working_or_c_result_or_c_index"); + UtTest_Add(Test_CF_CRC_Digest_When_len_Eq_1_PushDataLeftOnto_c_working, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Digest_PushesDataLeftOnto_c_working_When_len_Eq1"); - UtTest_Add(Test_CF_CRC_Digest_PushesDataLeftOnto_c_working_NumberOfTimesEqTo_len, + "Test_CF_CRC_Digest_When_len_Eq_1_PushDataLeftOnto_c_working"); + UtTest_Add(Test_CF_CRC_Digest_PushDataLeftOnto_c_working_NumberOfTimesEqTo_len, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Digest_PushesDataLeftOnto_c_working_NumberOfTimesEqTo_len"); - UtTest_Add(Test_CF_CRC_Digest_DoesNotUpdate_c_result_WhenIndexIsNot3, + "Test_CF_CRC_Digest_PushDataLeftOnto_c_working_NumberOfTimesEqTo_len"); + UtTest_Add(Test_CF_CRC_Digest_When_index_IsNot_3_DoNotUpdate_c_result, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Digest_DoesNotUpdate_c_result_WhenIndexIsNot3"); - UtTest_Add(Test_CF_CRC_Digest_Updates_c_result_When_c_index_Is3, + "Test_CF_CRC_Digest_When_index_IsNot_3_DoNotUpdate_c_result"); + UtTest_Add(Test_CF_CRC_Digest_When_c_index_Is_3_Update_c_result, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Digest_Updates_c_result_When_c_index_Is3"); - UtTest_Add(Test_CF_CRC_Digest_Updates_c_result_TheNumberOfTimesIndexReaches4, + "Test_CF_CRC_Digest_When_c_index_Is_3_Update_c_result"); + UtTest_Add(Test_CF_CRC_Digest_Update_c_result_TheNumberOfTimes_index_Reaches4, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Digest_Updates_c_result_TheNumberOfTimesIndexReaches4"); - UtTest_Add(Test_CF_CRC_Digest_Updates_c_index_By1When_len_Eq1_And_c_index_LessThan3, + "Test_CF_CRC_Digest_Update_c_result_TheNumberOfTimes_index_Reaches4"); + UtTest_Add(Test_CF_CRC_Digest_When_len_Eq1_And_c_index_LessThan_3_Update_c_index_By_1, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Digest_Updates_c_index_By1When_len_Eq1_And_c_index_LessThan3"); - UtTest_Add(Test_CF_CRC_Digest_Updates_c_index_To0When_len_Eq1_And_c_index_Is3, + "Test_CF_CRC_Digest_When_len_Eq1_And_c_index_LessThan_3_Update_c_index_By_1"); + UtTest_Add(Test_CF_CRC_Digest_When_len_Eq1_And_c_index_Is_3_Update_c_index_To_0, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Digest_Updates_c_index_To0When_len_Eq1_And_c_index_Is3"); - UtTest_Add(Test_CF_CRC_Digest_Updates_c_index_CorrectlyDependingOn_c_index_And_len_Values, + "Test_CF_CRC_Digest_When_len_Eq1_And_c_index_Is_3_Update_c_index_To_0"); + UtTest_Add(Test_CF_CRC_Digest_Update_c_index_CorrectlyDependingOn_c_index_And_len_Values, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Digest_Updates_c_index_CorrectlyDependingOn_c_index_And_len_Values"); -} + "Test_CF_CRC_Digest_Update_c_index_CorrectlyDependingOn_c_index_And_len_Values"); +} /* end add_CF_CRC_Digest_tests */ void add_CF_CRC_Finalize_tests(void) { - UtTest_Add(Test_CF_CRC_Finalize_DoesNothingWhenIndexIs0, + UtTest_Add(Test_CF_CRC_Finalize_When_index_Is_0_DoNothing, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Finalize_DoesNothingWhenIndexIs0"); - UtTest_Add(Test_CF_CRC_Finalize_Getsexpected_resultAtIndex1, + "Test_CF_CRC_Finalize_When_index_Is_0_DoNothing"); + UtTest_Add(Test_CF_CRC_Finalize_ReceiveExpectedResultAt_index_1, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Finalize_Getsexpected_resultAtIndex1"); - UtTest_Add(Test_CF_CRC_Finalize_Getsexpected_resultAtIndex2, + "Test_CF_CRC_Finalize_ReceiveExpectedResultAt_index_1"); + UtTest_Add(Test_CF_CRC_Finalize_ReceiveExpectedResultAt_index_2, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Finalize_Getsexpected_resultAtIndex2"); - UtTest_Add(Test_CF_CRC_Finalize_Getsexpected_resultAtIndex3, + "Test_CF_CRC_Finalize_ReceiveExpectedResultAt_index_2"); + UtTest_Add(Test_CF_CRC_Finalize_ReceiveExpectedResultAt_index_3, cf_crc_tests_Setup, cf_crc_tests_Teardown, - "Test_CF_CRC_Finalize_Getsexpected_resultAtIndex3"); -} + "Test_CF_CRC_Finalize_ReceiveExpectedResultAt_index_3"); +} /* end add_CF_CRC_Finalize_tests */ +/* end cf_crc_tests UtTest_Add groups */ /******************************************************************************* ** @@ -586,5 +581,4 @@ void UtTest_Setup(void) add_CF_CRC_Finalize_tests(); } /* end UtTest_Setup for cf_crc_tests.c */ - /* end cf_crc_tests.c */ \ No newline at end of file diff --git a/unit-test/cf_timer_tests.c b/unit-test/cf_timer_tests.c index 5108d2cf..3961c433 100644 --- a/unit-test/cf_timer_tests.c +++ b/unit-test/cf_timer_tests.c @@ -1,8 +1,6 @@ - /* cf testing includes */ -#include "cf_timer.c" #include "cf_test_utils.h" - +#include "cf_timer.c" /******************************************************************************* ** @@ -28,7 +26,7 @@ void cf_timer_tests_Teardown(void) ** *******************************************************************************/ -void Test_CF_Timer_Sec2Ticks_ReturnsExpectedValue(void) +void Test_CF_Timer_Sec2Ticks_ReturnExpectedValue(void) { /* Arrange */ cf_timer_sec_t arg_sec = Any_uint32(); @@ -45,7 +43,7 @@ void Test_CF_Timer_Sec2Ticks_ReturnsExpectedValue(void) UtAssert_True(result == arg_sec * dummy_ticks_per_second, "Result was %u and should be %u", result, arg_sec * dummy_ticks_per_second); -} /* end Test_CF_Timer_Sec2Ticks_ReturnsExpectedValue */ +} /* end Test_CF_Timer_Sec2Ticks_ReturnExpectedValue */ /* end CF_Timer_Sec2Ticks tests */ @@ -55,7 +53,7 @@ void Test_CF_Timer_Sec2Ticks_ReturnsExpectedValue(void) ** *******************************************************************************/ -void Test_CF_Timer_InitRelSec_GetsExpectedValue(void) +void Test_CF_Timer_InitRelSec_ReceiveExpectedValue(void) { /* Arrange */ uint32 arg_rel_sec = Any_uint32(); @@ -78,7 +76,7 @@ void Test_CF_Timer_InitRelSec_GetsExpectedValue(void) UtAssert_True(arg_t->tick == arg_rel_sec * dummy_ticks_per_second, "Timer ticks are %u and should be %u (return from CF_Timer_Sec2Ticks)", arg_t->tick, arg_rel_sec * dummy_ticks_per_second); -} /* end Test_CF_Timer_InitRelSec_GetsExpectedValue */ +} /* end Test_CF_Timer_InitRelSec_ReceiveExpectedValue */ /* end CF_Timer_InitRelSec tests */ @@ -88,7 +86,7 @@ void Test_CF_Timer_InitRelSec_GetsExpectedValue(void) ** *******************************************************************************/ -void Test_CF_Timer_Expired_Returns1WhenTickIs0(void) +void Test_CF_Timer_Expired_When_t_tick_Is_0_Return_1(void) { /* Arrange */ cf_timer_t dummy_timer; @@ -103,9 +101,9 @@ void Test_CF_Timer_Expired_Returns1WhenTickIs0(void) /* Assert */ UtAssert_True(local_result == expected_result, "Result was %u and should be %u", local_result, expected_result); -} /* end Test_CF_Timer_Expired_Returns1WhenTickIs0 */ +} /* end Test_CF_Timer_Expired_When_t_tick_Is_0_Return_1 */ -void Test_CF_Timer_Expired_Returns0WhenTickIs1(void) +void Test_CF_Timer_Expired_When_t_tick_Is_1_Return_0(void) { /* Arrange */ cf_timer_t dummy_timer; @@ -120,9 +118,9 @@ void Test_CF_Timer_Expired_Returns0WhenTickIs1(void) /* Assert */ UtAssert_True(local_result == expected_result, "Result was %u and should be %u", local_result, expected_result); -} /* end Test_CF_Timer_Expired_Returns0WhenTickIs1 */ +} /* end Test_CF_Timer_Expired_When_t_tick_Is_1_Return_0 */ -void Test_CF_Timer_Expired_Returns0WhenTickIsAnyIntegerExcept0(void) +void Test_CF_Timer_Expired_When_t_tick_IsAnyIntegerExcept_0_Return_0(void) { /* Arrange */ cf_timer_t dummy_timer; @@ -137,7 +135,7 @@ void Test_CF_Timer_Expired_Returns0WhenTickIsAnyIntegerExcept0(void) /* Assert */ UtAssert_True(local_result == expected_result, "Result was %u and should be %u", local_result, expected_result); -} /* end Test_CF_Timer_Expired_Returns0WhenTickIsAnyIntegerExcept0 */ +} /* end Test_CF_Timer_Expired_When_t_tick_IsAnyIntegerExcept_0_Return_0 */ /* end CF_Timer_Expired tests */ @@ -147,17 +145,17 @@ void Test_CF_Timer_Expired_Returns0WhenTickIsAnyIntegerExcept0(void) ** *******************************************************************************/ -void Test_CF_Timer_TickAssertsWhenTimerTickIs0(void) +void Test_CF_Timer_TickAssertsBecause_t_tick_Is_0(void) { - /* Arrange */ + // /* Arrange */ - /* Act */ + // /* Act */ - /* Assert */ - UtAssert_Failed("CF_Assert issue"); -} /* Test_CF_Timer_Tick */ + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - t->tick"); +} /* Test_CF_Timer_TickAssertsBecause_t_tick_Is_0 */ -void Test_CF_Timer_TickDecreasesTimerTickWhenNon0(void) +void Test_CF_Timer_Tick_When_t_tick_Is_non0_Decrement_t_tick(void) { /* Arrange */ uint32 initial_tick = Any_uint32_Except(0); @@ -174,7 +172,7 @@ void Test_CF_Timer_TickDecreasesTimerTickWhenNon0(void) "tick is %d and should have decreased by 1 from %d", arg_t->tick, initial_tick); -} /* Test_CF_Timer_Tick */ +} /* Test_CF_Timer_Tick_When_t_tick_Is_non0_Decrement_t_tick */ /* end CF_Timer_Tick tests */ @@ -186,44 +184,43 @@ void Test_CF_Timer_TickDecreasesTimerTickWhenNon0(void) void add_CF_Timer_Sec2Ticks_tests(void) { - UtTest_Add(Test_CF_Timer_Sec2Ticks_ReturnsExpectedValue, + UtTest_Add(Test_CF_Timer_Sec2Ticks_ReturnExpectedValue, cf_timer_tests_Setup, cf_timer_tests_Teardown, - "Test_CF_Timer_Sec2Ticks_ReturnsExpectedValue"); + "Test_CF_Timer_Sec2Ticks_ReturnExpectedValue"); } void add_CF_Timer_InitRelSec_tests(void) { - UtTest_Add(Test_CF_Timer_InitRelSec_GetsExpectedValue, + UtTest_Add(Test_CF_Timer_InitRelSec_ReceiveExpectedValue, cf_timer_tests_Setup, cf_timer_tests_Teardown, - "Test_CF_Timer_InitRelSec_GetsExpectedValue"); + "Test_CF_Timer_InitRelSec_ReceiveExpectedValue"); } void add_CF_Timer_Expired_tests(void) { - UtTest_Add(Test_CF_Timer_Expired_Returns1WhenTickIs0, + UtTest_Add(Test_CF_Timer_Expired_When_t_tick_Is_0_Return_1, cf_timer_tests_Setup, cf_timer_tests_Teardown, - "Test_CF_Timer_Expired_Returns1WhenTickIs0"); + "Test_CF_Timer_Expired_When_t_tick_Is_0_Return_1"); - UtTest_Add(Test_CF_Timer_Expired_Returns0WhenTickIs1, + UtTest_Add(Test_CF_Timer_Expired_When_t_tick_Is_1_Return_0, cf_timer_tests_Setup, cf_timer_tests_Teardown, - "Test_CF_Timer_Expired_Returns0WhenTickIs1"); + "Test_CF_Timer_Expired_When_t_tick_Is_1_Return_0"); - UtTest_Add(Test_CF_Timer_Expired_Returns0WhenTickIsAnyIntegerExcept0, + UtTest_Add(Test_CF_Timer_Expired_When_t_tick_IsAnyIntegerExcept_0_Return_0, cf_timer_tests_Setup, cf_timer_tests_Teardown, - "Test_CF_Timer_Expired_Returns0WhenTickIsAnyIntegerExcept0"); + "Test_CF_Timer_Expired_When_t_tick_IsAnyIntegerExcept_0_Return_0"); } void add_CF_Timer_Tick_tests(void) { - UtTest_Add(Test_CF_Timer_TickAssertsWhenTimerTickIs0, + UtTest_Add(Test_CF_Timer_TickAssertsBecause_t_tick_Is_0, cf_timer_tests_Setup, cf_timer_tests_Teardown, - "Test_CF_Timer_TickAssertsWhenTimerTickIs0"); - UtTest_Add(Test_CF_Timer_TickDecreasesTimerTickWhenNon0, + "Test_CF_Timer_TickAssertsBecause_t_tick_Is_0"); + UtTest_Add(Test_CF_Timer_Tick_When_t_tick_Is_non0_Decrement_t_tick, cf_timer_tests_Setup, cf_timer_tests_Teardown, - "Test_CF_Timer_TickDecreasesTimerTickWhenNon0"); + "Test_CF_Timer_Tick_When_t_tick_Is_non0_Decrement_t_tick"); } - /* end cf_timer_tests UtTest_Add groups */ /******************************************************************************* diff --git a/unit-test/cf_utils_tests.c b/unit-test/cf_utils_tests.c index 7eae3364..96834f9e 100644 --- a/unit-test/cf_utils_tests.c +++ b/unit-test/cf_utils_tests.c @@ -1,12 +1,10 @@ - /* cf testing includes */ -#include "cf_utils.c" #include "cf_test_utils.h" +#include "cf_utils.c" /* cf_utils_tests globals */ extern type_of_context_CF_CList_Traverse_t type_of_context_CF_CList_Traverse; - /******************************************************************************* ** ** cf_utils_tests Setup and Teardown @@ -27,7 +25,7 @@ void cf_utils_tests_Teardown(void) /******************************************************************************* ** -** cf_utils_tests specific Any functions TODO:find a better way to to this +** cf_utils_tests specific Any functions NOTE:Some of these may be better as global ** *******************************************************************************/ @@ -49,7 +47,6 @@ condition_code_t Any_condition_code_t(void) void local_handler_OS_close(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context) { - osal_id_t filedes = UT_Hook_GetArgValueByName(Context, "filedes", osal_id_t); int32 status; UT_Stub_GetInt32StatusCode(Context, &status); @@ -71,7 +68,6 @@ void DummyFunctionFor_CF_TraverseAllTransactions_(transaction_t* t, void* contex UT_DEFAULT_IMPL(DummyFunctionFor_CF_TraverseAllTransactions_); } - /******************************************************************************* ** ** cf_utils.h function tests @@ -82,22 +78,21 @@ void DummyFunctionFor_CF_TraverseAllTransactions_(transaction_t* t, void* contex void Test_cf_dequeue_transaction_AssertsBecause_t_IsNull(void) { - /* Arrange */ + // /* Arrange */ // transaction_t *arg_t = NULL; - /* Act */ - //cf_dequeue_transaction(arg_t); + // /* Act */ + // cf_dequeue_transaction(arg_t); - /* Assert */ - UtAssert_Failed("CF_Assert issue - Behavior appears to want this, but it cannot do it\nCannot test assert call. In release mode with unlikely((x)),\nshort-circuit booleans fail to short-circuit"); + // /* Assert */ // UtAssert_STUB_COUNT(CF_HandleAssert, 1); - + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - t"); } /* end Test_cf_dequeue_transaction_AssertsBecause_t_IsNull */ void Test_cf_dequeue_transaction_AssertsBecause_t_chan_num_LessThan_CF_NUM_CHANNELS(void) { - /* Arrange */ + // /* Arrange */ // transaction_t arg_t; // clist_node *expected_qs = // &CF_AppData.engine.channels[arg_t.chan_num].qs[arg_t.flags.all.q_index]; @@ -106,32 +101,30 @@ void Test_cf_dequeue_transaction_AssertsBecause_t_chan_num_LessThan_CF_NUM_CHANN // arg_t.chan_num = dummy_chan_num; - /* Act */ + // /* Act */ //cf_dequeue_transaction(&arg_t); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ // UtAssert_STUB_COUNT(CF_HandleAssert, 1); - + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - t->chan_numchan_num].q_size[t->flags.all.q_index]"); } /* end Test_cf_dequeue_transaction_AssertsBecause_q_size_Eq0 */ -void Test_cf_dequeue_transaction_Calls_CF_CList_Remove_AndDecrementsThe_q_size(void) +void Test_cf_dequeue_transaction_Call_CF_CList_Remove_AndDecrement_q_size(void) { /* Arrange */ transaction_t arg_t; @@ -160,17 +153,13 @@ void Test_cf_dequeue_transaction_Calls_CF_CList_Remove_AndDecrementsThe_q_size(v /* Assert */ UtAssert_STUB_COUNT(CF_HandleAssert, 0); - UtAssert_True(context_clist_remove.head == expected_head, - "CF_CList_Remove received head %p and should be %p", - context_clist_remove.head, expected_head); - UtAssert_True(context_clist_remove.node == expected_cl_node, - "CF_CList_Remove received node %p and should be %p", - context_clist_remove.node, expected_cl_node); + UtAssert_ADDRESS_EQ(context_clist_remove.head, expected_head); + UtAssert_ADDRESS_EQ(context_clist_remove.node, expected_cl_node); UtAssert_True(updated_q_size == initial_q_size - 1, "q_size is %d and that is 1 less than initial value %d", updated_q_size, initial_q_size); -} /* end Test_cf_dequeue_transaction_Calls_CF_CList_Remove_AndDecrementsThe_q_size */ +} /* end Test_cf_dequeue_transaction_Call_CF_CList_Remove_AndDecrement_q_size */ /* end cf_dequeue_transaction tests */ @@ -178,35 +167,35 @@ void Test_cf_dequeue_transaction_Calls_CF_CList_Remove_AndDecrementsThe_q_size(v void Test_cf_move_transaction_AssertsBecause_t_IsNull(void) { - /* Arrange */ + // /* Arrange */ - /* Act */ + // /* Act */ - /* Assert */ - UtAssert_Failed("CF_Assert issue - Cannot test assert call. In release mode with unlikely((x)),\nshort-circuit booleans fail to short-circuit: CF_Assert(t&&(t->chan_numchan_numchan_num].q_size[t->flags.all.q_index]"); } /* end Test_cf_move_transaction_AssertsBecause_channel_hk_Has_q_size_Eq0 */ -void Test_cf_move_transaction_SuccessCalls_CF_CList_InsertBack_AndSets_q_index_ToPassedIn_q(void) +void Test_cf_move_transaction_Call_CF_CList_InsertBack_AndSet_q_index_ToGiven_q(void) { /* Arrange */ transaction_t dummy_t; @@ -243,28 +232,18 @@ void Test_cf_move_transaction_SuccessCalls_CF_CList_InsertBack_AndSets_q_index_T /* Act */ cf_move_transaction(arg_t, arg_q); - UT_GetStubCount(UT_KEY(CF_CList_InsertBack)); - /* Assert */ UtAssert_STUB_COUNT(CF_HandleAssert, 0); UtAssert_STUB_COUNT(CF_CList_Remove, 1); - UtAssert_True(context_clist_remove.head == expected_remove_head, - "CF_CList_Remove received head %p and should be %p", - context_clist_remove.head, expected_remove_head); - UtAssert_True(context_clist_remove.node == expected_remove_node, - "CF_CList_Remove received node %p and should be %p", - context_clist_remove.node, expected_remove_node); + UtAssert_ADDRESS_EQ(context_clist_remove.head, expected_remove_head); + UtAssert_ADDRESS_EQ(context_clist_remove.node, expected_remove_node); UtAssert_STUB_COUNT(CF_CList_InsertBack, 1); - UtAssert_True(context_clist_insert_back.head == expected_insert_back_head, - "CF_CList_InsertBack received head %p and should be %p", - context_clist_insert_back.head, expected_insert_back_head); - UtAssert_True(context_clist_insert_back.node == expected_insert_back_node, - "CF_CList_InsertBack received node %p and should be %p", - context_clist_insert_back.node, expected_insert_back_node); + UtAssert_ADDRESS_EQ(context_clist_insert_back.head, expected_insert_back_head); + UtAssert_ADDRESS_EQ(context_clist_insert_back.node, expected_insert_back_node); UtAssert_True(arg_t->flags.all.q_index == arg_q, "t->flags.all.q_index set to %u and should equal passed in q value %u", arg_t->flags.all.q_index, arg_q); -} /* end Test_cf_move_transaction_SuccessCalls_CF_CList_InsertBack_AndSets_q_index_ToPassedIn_q */ +} /* end Test_cf_move_transaction_Call_CF_CList_InsertBack_AndSet_q_index_ToGiven_q */ /* end cf_move_transaction tests */ @@ -272,7 +251,7 @@ void Test_cf_move_transaction_SuccessCalls_CF_CList_InsertBack_AndSets_q_index_T void Test_CF_CList_Remove_Ex_AssertsBecause_q_size_Eq0(void) { - /* Arrange */ + // /* Arrange */ // channel_t dummy_c; // channel_t* arg_c = &dummy_c; // cf_queue_index_t arg_index = Any_cf_queue_index_t(); @@ -286,16 +265,16 @@ void Test_CF_CList_Remove_Ex_AssertsBecause_q_size_Eq0(void) // // expected_remove_head = &arg_c->qs[arg_index]; - //CF_AppData.hk.channel_hk[arg_c-CF_AppData.engine.channels].q_size[arg_index] = 0; + // CF_AppData.hk.channel_hk[arg_c-CF_AppData.engine.channels].q_size[arg_index] = 0; - /* Act */ + // /* Act */ //CF_CList_Remove_Ex(arg_c, arg_index, arg_node); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - CF_AppData.hk.channel_hk[c-CF_AppData.engine.channels].q_size[index]"); } /* end Test_CF_CList_Remove_Ex_AssertsBecause_q_size_Eq0 */ -void Test_CF_CList_Remove_Ex_Calls_CF_CList_Remove_AndDecrements_q_size(void) +void Test_CF_CList_Remove_Ex_Call_CF_CList_Remove_AndDecrement_q_size(void) { /* Arrange */ channel_t* arg_c = @@ -326,22 +305,18 @@ void Test_CF_CList_Remove_Ex_Calls_CF_CList_Remove_AndDecrements_q_size(void) /* Assert */ UtAssert_STUB_COUNT(CF_HandleAssert, 0); UtAssert_STUB_COUNT(CF_CList_Remove, 1); - UtAssert_True(context_clist_remove.head == expected_remove_head, - "CF_CList_Remove received head %p and should be %p", - context_clist_remove.head, expected_remove_head); - UtAssert_True(context_clist_remove.node == expected_remove_node, - "CF_CList_Remove received node %p and should be %p", - context_clist_remove.node, expected_remove_node); + UtAssert_ADDRESS_EQ(context_clist_remove.head, expected_remove_head); + UtAssert_ADDRESS_EQ(context_clist_remove.node, expected_remove_node); UtAssert_True(updated_q_size == initial_q_size - 1, "q_size is %d and that is 1 less than initial value %d", updated_q_size, initial_q_size); -} /* end Test_CF_CList_Remove_Ex_Calls_CF_CList_Remove_AndDecrements_q_size */ +} /* end Test_CF_CList_Remove_Ex_Call_CF_CList_Remove_AndDecrement_q_size */ /* end CF_CList_Remove_Ex tests */ /* CF_CList_InsertAfter_Ex tests */ -void Test_CF_CList_InsertAfter_Ex_Calls_CF_CList_InsertAfter_AndIncrements_q_size(void) +void Test_CF_CList_InsertAfter_Ex_Call_CF_CList_InsertAfter_AndIncrement_q_size(void) { /* Arrange */ channel_t* arg_c = @@ -369,26 +344,20 @@ void Test_CF_CList_InsertAfter_Ex_Calls_CF_CList_InsertAfter_AndIncrements_q_siz /* Assert */ UtAssert_STUB_COUNT(CF_CList_InsertAfter, 1); - UtAssert_True(context_CF_CList_InsertAfter.head == expected_insert_after_head, - "CF_CList_InsertAfter received head %p and should be %p", - context_CF_CList_InsertAfter.head, expected_insert_after_head); - UtAssert_True(context_CF_CList_InsertAfter.start == arg_start, - "CF_CList_InsertAfter received start %p and should be %p", - context_CF_CList_InsertAfter.start, arg_start); - UtAssert_True(context_CF_CList_InsertAfter.after== arg_after, - "CF_CList_InsertAfter received after %p and should be %p", - context_CF_CList_InsertAfter.after, arg_after); + UtAssert_ADDRESS_EQ(context_CF_CList_InsertAfter.head, expected_insert_after_head); + UtAssert_ADDRESS_EQ(context_CF_CList_InsertAfter.start, arg_start); + UtAssert_ADDRESS_EQ(context_CF_CList_InsertAfter.after, arg_after); UtAssert_True(updated_q_size == (uint16)(initial_q_size + 1), "q_size is %d and that is 1 more than initial value %d", updated_q_size, initial_q_size); -} /* end Test_CF_CList_InsertAfter_Ex_Calls_CF_CList_InsertAfter_AndIncrements_q_size */ +} /* end Test_CF_CList_InsertAfter_Ex_Call_CF_CList_InsertAfter_AndIncrement_q_size */ /* end CF_CList_InsertAfter_Ex tests */ /* CF_CList_InsertBack_Ex tests */ -void Test_CF_CList_InsertBack_Ex_Calls_CF_CList_InsertBack_AndIncrements_q_size(void) +void Test_CF_CList_InsertBack_Ex_Call_CF_CList_InsertBack_AndIncrement_q_size(void) { /* Arrange */ channel_t* arg_c = @@ -412,24 +381,19 @@ void Test_CF_CList_InsertBack_Ex_Calls_CF_CList_InsertBack_AndIncrements_q_size( /* Act */ CF_CList_InsertBack_Ex(arg_c, arg_index, arg_node); - - UT_GetStubCount(UT_KEY(CF_CList_InsertBack)); + uint16 updated_q_size = CF_AppData.hk.channel_hk[arg_c-CF_AppData.engine.channels].q_size[arg_index]; /* Assert */ UtAssert_STUB_COUNT(CF_CList_InsertBack, 1); - UtAssert_True(context_clist_insert_back.head == expected_insert_back_head, - "CF_CList_InsertBack received head %p and should be %p", - context_clist_insert_back.head, expected_insert_back_head); - UtAssert_True(context_clist_insert_back.node == expected_insert_back_node, - "CF_CList_InsertBack received node %p and should be %p", - context_clist_insert_back.node, expected_insert_back_node); + UtAssert_ADDRESS_EQ(context_clist_insert_back.head, expected_insert_back_head); + UtAssert_ADDRESS_EQ(context_clist_insert_back.node, expected_insert_back_node); UtAssert_True(updated_q_size == (uint16)(initial_q_size + 1), "q_size is %d and that is 1 more than initial value %d", updated_q_size, initial_q_size); -} /* end Test_CF_CList_InsertBack_Ex_Calls_CF_CList_InsertBack_AndIncrements_q_size */ +} /* end Test_CF_CList_InsertBack_Ex_Call_CF_CList_InsertBack_AndIncrement_q_size */ /* end CF_CList_InsertBack_Ex tests */ @@ -441,9 +405,9 @@ void Test_CF_CList_InsertBack_Ex_Calls_CF_CList_InsertBack_AndIncrements_q_size( ** *******************************************************************************/ -void Test_CF_TraverseHistory_Asserts_h_dir_GreaterThan_CF_DIR_NUM(void) +void Test_CF_TraverseHistory_AssertsBecause_h_dir_GreaterThan_CF_DIR_NUM(void) { - /* Arrange */ + // /* Arrange */ // history_t dummy_h; // clist_node arg_n = &dummy_h.cl_node; // trav_arg_t dummy_context; @@ -454,28 +418,23 @@ void Test_CF_TraverseHistory_Asserts_h_dir_GreaterThan_CF_DIR_NUM(void) // dummy_h.dir = Any_direction_t(); // dummy_h.peer_eid = Any_uint8(); // dummy_h.cc = Any_condition_code_t(); - - - - /* Act */ + + // /* Act */ // CF_TraverseHistory(arg_n, arg_context); - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - h->dirsrc_eid = Any_uint8(); @@ -651,12 +588,8 @@ void Test_CF_TraverseTransactions_Returns_CLIST_EXIT_When_context_result_Eq1(voi dummy_t.history->dir = Any_direction_t(); dummy_t.history->peer_eid = Any_uint8(); dummy_t.history->cc = Any_condition_code_t(); - - snprintf(dummy_t.history->fnames.src_filename, src_fname_length, - AnyRandomStringOfLettersOfLength(src_fname_length)); - dummy_t.history->cl_node = dummy_history_cl_node; - /* Arrange unstubbable: CF_WrappedWrite in same file as CF_TraverseHistor in same + /* Arrange for CF_WrappedWrite in same file as CF_TraverseHistor in same * file as CF_TraverseTransactions */ char src_colon_str[6] = "SRC: "; /* duplicates function value */ uint8 dummy_len; @@ -671,9 +604,9 @@ void Test_CF_TraverseTransactions_Returns_CLIST_EXIT_When_context_result_Eq1(voi UtAssert_True(local_result == CLIST_EXIT, "CF_TraverseTransactions returned %d and should be %d (CLIST_EXIT)", local_result, CLIST_EXIT); -} /* end Test_CF_TraverseTransactions_Returns_CLIST_EXIT_When_context_result_Eq1 */ +} /* end Test_CF_TraverseTransactions_When_context_result_Is_1_Return_CLIST_EXIT */ -void Test_CF_TraverseTransactions_Returns_CLIST_CONT_When_context_result_Eq0(void) +void Test_CF_TraverseTransactions_When_context_result_Is_0_Return_CLIST_CONT(void) { /* Arrange */ history_t dummy_history; @@ -685,26 +618,15 @@ void Test_CF_TraverseTransactions_Returns_CLIST_CONT_When_context_result_Eq0(voi arg_context->result = 0; /* ensures arg_context->result starts at 0 */ - /* Arrange unstubbable: CF_TraverseHistor in same file as CF_TraverseTransactions */ - clist_node_t dummy_history_cl_node; - uint8 src_fname_length = Any_uint8_LessThan(CF_FILENAME_MAX_LEN); - uint8 dst_fname_length = Any_uint8_LessThan(CF_FILENAME_MAX_LEN); - + /* Arrange for CF_TraverseHistor in same file as CF_TraverseTransactions */ dummy_t.history = &dummy_history; dummy_t.history->src_eid = Any_uint8(); dummy_t.history->seq_num = Any_uint32(); dummy_t.history->dir = Any_direction_t(); dummy_t.history->peer_eid = Any_uint8(); dummy_t.history->cc = Any_condition_code_t(); - - snprintf(dummy_t.history->fnames.src_filename, src_fname_length, - AnyRandomStringOfLettersOfLength(src_fname_length)); - snprintf(dummy_t.history->fnames.dst_filename, dst_fname_length, - AnyRandomStringOfLettersOfLength(dst_fname_length)); - - dummy_t.history->cl_node = dummy_history_cl_node; - /* Arrange unstubbable: CF_WrappedWrite in same file as CF_TraverseHistor in same + /* Arrange for CF_WrappedWrite in same file as CF_TraverseHistor in same * file as CF_TraverseTransactions */ char src_colon_str[6] = "SRC: "; /* duplicates function value */ char dst_colon_str[6] = "DST: "; /* duplicates function value */ @@ -723,7 +645,7 @@ void Test_CF_TraverseTransactions_Returns_CLIST_CONT_When_context_result_Eq0(voi UtAssert_True(local_result == CLIST_CONT, "CF_TraverseTransactions returned %d and should be %d (CLIST_CONT)", local_result, CLIST_CONT); -} /* end Test_CF_TraverseTransactions_Returns_CLIST_CONT_When_context_result_Eq0 */ +} /* end Test_CF_TraverseTransactions_When_context_result_Is_0_Return_CLIST_CONT */ /* end CF_TraverseTransactions tests */ @@ -733,7 +655,7 @@ void Test_CF_TraverseTransactions_Returns_CLIST_CONT_When_context_result_Eq0(voi ** *******************************************************************************/ -void Test_CF_WriteQueueDataToFile_Calls_CF_CList_Traverse_AndReturns_arg_result(void) +void Test_CF_WriteQueueDataToFile_Call_CF_CList_Traverse_AndReturn_arg_result(void) { /* Arrange */ int32 arg_fd = Any_int32(); @@ -758,24 +680,17 @@ void Test_CF_WriteQueueDataToFile_Calls_CF_CList_Traverse_AndReturns_arg_result( /* Assert */ - /* NOTE: cannot test functions local setup of arg because it is passed as a void* */ - /* TODO: Maybe this can be overcome, but need to know what all can be sent to CF_CList_Traverse */ UtAssert_STUB_COUNT(CF_CList_Traverse, 1); - UtAssert_True(context_clist_traverse.start == expected_start, - "CF_CList_Traverse received start %p and should be %p (c->qs[q])", - context_clist_traverse.start, expected_start); - UtAssert_True(context_clist_traverse.fn == expected_fn, - "CF_WriteQueueDataToFile received fn %p and should be %p (CF_TraverseTransactions)", - context_clist_traverse.fn, expected_fn); + UtAssert_ADDRESS_EQ(context_clist_traverse.start, expected_start); + UtAssert_True(context_clist_traverse.fn == expected_fn, "context_clist_traverse.fn == expected_fn"); UtAssert_True(context_clist_traverse.context_fd == arg_fd, "CF_WriteQueueDataToFile received context fd %d and should be %d (fd)", context_clist_traverse.context_fd, arg_fd); UtAssert_True(result == context_clist_traverse.context_result, "CF_WriteQueueDataToFile returned %d and should be %d (CF_CList_Traverse set arg.result)", result, context_clist_traverse.context_result); - // context_clist_traverse.counter is not checked because it is not altered - -} /* end Test_CF_WriteQueueDataToFile_Calls_CF_CList_Traverse_AndReturns_arg_result */ + /* NOTE: context_clist_traverse.counter is not checked because it is not altered */ +} /* end Test_CF_WriteQueueDataToFile_Call_CF_CList_Traverse_AndReturn_arg_result */ /* end CF_WriteQueueDataToFile tests */ @@ -785,7 +700,7 @@ void Test_CF_WriteQueueDataToFile_Calls_CF_CList_Traverse_AndReturns_arg_result( ** *******************************************************************************/ -void Test_CF_WriteHistoryQueueDataToFile_Calls_CF_CList_Traverse_AndReturns_arg_result(void) +void Test_CF_WriteHistoryQueueDataToFile_Call_CF_CList_Traverse_AndReturn_arg_result(void) { /* Arrange */ int32 arg_fd = Any_int32(); @@ -808,26 +723,20 @@ void Test_CF_WriteHistoryQueueDataToFile_Calls_CF_CList_Traverse_AndReturns_arg_ /* Act */ result = CF_WriteHistoryQueueDataToFile(arg_fd, arg_c, arg_dir); - /* Assert */ - /* NOTE: cannot test functions local setup of arg because it is passed as a void* */ - /* TODO: Maybe this can be overcome, but need to know what all can be sent to CF_CList_Traverse */ + /* NOTE: cannot test functions local setup of arg because it is passed as a void* + ** Maybe this can be overcome, but need to know what all can be sent to CF_CList_Traverse */ UtAssert_STUB_COUNT(CF_CList_Traverse, 1); - UtAssert_True(context_clist_traverse.start == expected_start, - "CF_CList_Traverse received start %p and should be %p (c->qs[q])", - context_clist_traverse.start, expected_start); - UtAssert_True(context_clist_traverse.fn == expected_fn, - "CF_WriteQueueDataToFile received fn %p and should be %p (CF_TraverseHistory)", - context_clist_traverse.fn, expected_fn); + UtAssert_ADDRESS_EQ(context_clist_traverse.start, expected_start); + UtAssert_True(context_clist_traverse.fn == expected_fn, "context_clist_traverse.fn == expected_fn"); UtAssert_True(context_clist_traverse.context_fd == arg_fd, "CF_WriteQueueDataToFile received context fd %d and should be %d (fd)", context_clist_traverse.context_fd, arg_fd); UtAssert_True(result == context_clist_traverse.context_result, "CF_WriteQueueDataToFile returned %d and should be %d (CF_CList_Traverse set arg.result)", result, context_clist_traverse.context_result); - // context_clist_traverse.counter is not checked because it is not altered - -} /* end Test_CF_WriteHistoryQueueDataToFile_Calls_CF_CList_Traverse_AndReturns_arg_result */ + /* NOTE: context_clist_traverse.counter is not checked because it is not altered */ +} /* end Test_CF_WriteHistoryQueueDataToFile_Call_CF_CList_Traverse_AndReturn_arg_result */ /* end CF_WriteHistoryQueueDataToFile tests */ @@ -837,7 +746,7 @@ void Test_CF_WriteHistoryQueueDataToFile_Calls_CF_CList_Traverse_AndReturns_arg_ ** *******************************************************************************/ -void Test_CF_PrioSearch_Returns_CLIST_CONT_Because_t_PrioIsGreaterThanContextPrio(void) +void Test_CF_PrioSearch_When_t_PrioIsGreaterThanContextPrioReturn_CLIST_CONT(void) { /* Arrange */ transaction_t dummy_t; @@ -856,9 +765,9 @@ void Test_CF_PrioSearch_Returns_CLIST_CONT_Because_t_PrioIsGreaterThanContextPri "CF_PrioSearch returned %d and should be %d (CLIST_CONT)", result, CLIST_CONT); -} /* end Test_CF_PrioSearch_Returns_CLIST_CONT_Because_t_PrioIsGreaterThanContextPrio */ +} /* end Test_CF_PrioSearch_When_t_PrioIsGreaterThanContextPrioReturn_CLIST_CONT */ -void Test_CF_PrioSearch_Returns_CLIST_EXIT_AndSets_context_t_To_t_Because_t_PrioIsEqToContextPrio(void) +void Test_CF_PrioSearch_When_t_PrioIsEqToContextPrio_Set_context_t_To_t_AndReturn_CLIST_EXIT(void) { /* Arrange */ transaction_t dummy_t; @@ -877,13 +786,11 @@ void Test_CF_PrioSearch_Returns_CLIST_EXIT_AndSets_context_t_To_t_Because_t_Prio UtAssert_True(result == CLIST_EXIT, "CF_PrioSearch returned %d and should be %d (CLIST_EXIT)", result, CLIST_EXIT); - UtAssert_True(dummy_p.t == &dummy_t, - "CF_PrioSearch context's t set to %p and should be %p (passed in node's transaction)", - dummy_p.t, &dummy_t); + UtAssert_ADDRESS_EQ(dummy_p.t, &dummy_t); -} /* end Test_CF_PrioSearch_Returns_CLIST_EXIT_AndSets_context_t_To_t_Because_t_PrioIsEqToContextPrio */ +} /* end Test_CF_PrioSearch_When_t_PrioIsEqToContextPrio_Set_context_t_To_t_AndReturn_CLIST_EXIT */ -void Test_CF_PrioSearch_Returns_CLIST_EXIT_AndSets_context_t_To_t_Because_t_PrioIsLessThanContextPrio(void) +void Test_CF_PrioSearch_When_t_PrioIsLessThanContextPrio_Set_context_t_To_t_AndReturn_CLIST_EXIT(void) { /* Arrange */ transaction_t dummy_t; @@ -902,11 +809,9 @@ void Test_CF_PrioSearch_Returns_CLIST_EXIT_AndSets_context_t_To_t_Because_t_Prio UtAssert_True(result == CLIST_EXIT, "CF_PrioSearch returned %d and should be %d (CLIST_EXIT)", result, CLIST_EXIT); - UtAssert_True(dummy_p.t == &dummy_t, - "CF_PrioSearch context's t set to %p and should be %p (passed in node's transaction)", - dummy_p.t, &dummy_t); + UtAssert_ADDRESS_EQ(dummy_p.t, &dummy_t); -} /* end Test_CF_PrioSearch_Returns_CLIST_EXIT_AndSets_context_t_To_t_Because_t_PrioIsLessThanContextPrio */ +} /* end Test_CF_PrioSearch_When_t_PrioIsLessThanContextPrio_Set_context_t_To_t_AndReturn_CLIST_EXIT */ /* end CF_PrioSearch tests */ @@ -918,25 +823,25 @@ void Test_CF_PrioSearch_Returns_CLIST_EXIT_AndSets_context_t_To_t_Because_t_Prio void Test_CF_InsertSortPrio_AssertsBecause_t_chan_num_LessThan_CF_NUM_CHANNELS(void) { - /* Arrange */ + // /* Arrange */ - /* Act */ + // /* Act */ - /* Assert */ - UtAssert_Failed("CF_Assert issue"); + // /* Assert */ + UtAssert_MIR("JIRA: GSFCCFS-1733 CF_Assert - t->chan_numstate!=CFDP_IDLE"); } /* end Test_CF_InsertSortPrio_AssertsBecause_t_state_IsNot_CFDP_IDLE */ -void Test_CF_InsertSortPrio_Calls_CF_CList_InsertBack_Ex_ListIsEmpty_AndSets_q_index_To_q(void) +void Test_CF_InsertSortPrio_Call_CF_CList_InsertBack_Ex_ListIsEmpty_AndSet_q_index_To_q(void) { /* Arrange */ transaction_t dummy_t; @@ -964,23 +869,17 @@ void Test_CF_InsertSortPrio_Calls_CF_CList_InsertBack_Ex_ListIsEmpty_AndSets_q_i /* Act */ CF_InsertSortPrio(arg_t, arg_q); - - UT_GetStubCount(UT_KEY(CF_CList_InsertBack)); /* Assert */ UtAssert_STUB_COUNT(CF_CList_InsertBack, 1); - UtAssert_True(context_clist_insert_back.head == expected_insert_back_head, - "CF_CList_InsertBack received head %p and should be %p", - context_clist_insert_back.head, expected_insert_back_head); - UtAssert_True(context_clist_insert_back.node == expected_insert_back_node, - "CF_CList_InsertBack received node %p and should be %p", - context_clist_insert_back.node, expected_insert_back_node); + UtAssert_ADDRESS_EQ(context_clist_insert_back.head, expected_insert_back_head); + UtAssert_ADDRESS_EQ(context_clist_insert_back.node, expected_insert_back_node); UtAssert_True(arg_t->flags.all.q_index == arg_q, "arg_t->flags.all.q_index set to %d and should be %d (cf_queue_index_t q)", arg_t->flags.all.q_index, arg_q); -} /* end Test_CF_InsertSortPrio_Calls_CF_CList_InsertBack_Ex_ListIsEmpty_AndSets_q_index_To_q */ +} /* end Test_CF_InsertSortPrio_Call_CF_CList_InsertBack_Ex_ListIsEmpty_AndSet_q_index_To_q */ -void Test_CF_InsertSortPrio_Calls_CF_CList_InsertAfter_Ex_AndSets_q_index_To_q(void) +void Test_CF_InsertSortPrio_Call_CF_CList_InsertAfter_Ex_AndSet_q_index_To_q(void) { /* Arrange */ transaction_t dummy_p_t; @@ -1011,7 +910,7 @@ void Test_CF_InsertSortPrio_Calls_CF_CList_InsertAfter_Ex_AndSets_q_index_To_q(v /* setup priority_arg_t altered value */ context_cf_clist_traverse_r.context_t = &dummy_p_t; - /* Arrange unstubbable: CF_CList_InsertAfter_Ex */ + /* Arrange for CF_CList_InsertAfter_Ex */ CF_CList_InsertAfter_context_t context_CF_CList_InsertAfter; UT_SetDataBuffer(UT_KEY(CF_CList_InsertAfter), &context_CF_CList_InsertAfter, sizeof(context_CF_CList_InsertAfter), false); @@ -1025,35 +924,22 @@ void Test_CF_InsertSortPrio_Calls_CF_CList_InsertAfter_Ex_AndSets_q_index_To_q(v /* Act */ CF_InsertSortPrio(arg_t, arg_q); - - UT_GetStubCount(UT_KEY(CF_CList_Traverse_R)); - UT_GetStubCount(UT_KEY(CF_CList_InsertAfter)); /* Assert */ UtAssert_STUB_COUNT(CF_CList_Traverse_R, 1); - UtAssert_True(context_cf_clist_traverse_r.end == expected_end, - "CF_CList_Traverse_R was given end %p and should be %p (c->qs[q])", - context_cf_clist_traverse_r.end, expected_end); - UtAssert_True(context_cf_clist_traverse_r.fn == expected_fn, - "CF_CList_Traverse_R was given fn %p and should be %p (CF_PrioSearch)", - context_cf_clist_traverse_r.fn, expected_fn); + UtAssert_ADDRESS_EQ(context_cf_clist_traverse_r.end, expected_end); + UtAssert_True(context_cf_clist_traverse_r.fn == expected_fn, "context_cf_clist_traverse_r.fn == expected_fn"); UtAssert_STUB_COUNT(CF_CList_InsertAfter, 1); - UtAssert_True(context_CF_CList_InsertAfter.head == (clist_node*)expected_insert_after_head, - "CF_CList_InsertAfter received head %p and should be %p (&dummy_c->qs[arg_q])", - context_CF_CList_InsertAfter.head, expected_insert_after_head); - UtAssert_True(context_CF_CList_InsertAfter.start == (clist_node)expected_insert_after_start, - "CF_CList_InsertAfter received start %p and should be %p", - context_CF_CList_InsertAfter.start, expected_insert_after_start); - UtAssert_True(context_CF_CList_InsertAfter.after == (clist_node)expected_insert_after_after, - "CF_CList_InsertAfter received after %p and should be %p", - context_CF_CList_InsertAfter.after, expected_insert_after_after); + UtAssert_ADDRESS_EQ(context_CF_CList_InsertAfter.head, (clist_node*)expected_insert_after_head); + UtAssert_ADDRESS_EQ(context_CF_CList_InsertAfter.start, (clist_node)expected_insert_after_start); + UtAssert_ADDRESS_EQ(context_CF_CList_InsertAfter.after, (clist_node)expected_insert_after_after); UtAssert_True(arg_t->flags.all.q_index == arg_q, "t->flags.all.q_index is %u and should be %u (q)", arg_t->flags.all.q_index, arg_q); -} /* end Test_CF_InsertSortPrio_Calls_CF_CList_InsertAfter_Ex_AndSets_q_index_To_q */ +} /* end Test_CF_InsertSortPrio_Call_CF_CList_InsertAfter_Ex_AndSet_q_index_To_q */ -void Test_CF_InsertSortPrio_Calls_CF_CList_InsertBack_Ex_BecauseNull_p_t(void) +void Test_CF_InsertSortPrio_When_p_t_Is_NULL_Call_CF_CList_InsertBack_Ex(void) { /* Arrange */ transaction_t dummy_t; @@ -1088,39 +974,27 @@ void Test_CF_InsertSortPrio_Calls_CF_CList_InsertBack_Ex_BecauseNull_p_t(void) expected_insert_back_head = &dummy_c->qs[arg_q]; expected_insert_back_node = &arg_t->cl_node; - /* Arrange unstubbable: CF_CList_InsertBack_Ex */ + /* Arrange for CF_CList_InsertBack_Ex */ CF_CList_InsertBack_context_t context_clist_insert_back; UT_SetDataBuffer(UT_KEY(CF_CList_InsertBack), &context_clist_insert_back, sizeof(context_clist_insert_back), false); /* Act */ CF_InsertSortPrio(arg_t, arg_q); - - UT_GetStubCount(UT_KEY(CF_CList_Traverse_R)); - UT_GetStubCount(UT_KEY(CF_CList_InsertAfter)); - UT_GetStubCount(UT_KEY(CF_CList_InsertBack)); /* Assert */ UtAssert_STUB_COUNT(CF_CList_Traverse_R, 1); - UtAssert_True(context_cf_clist_traverse_r.end == expected_end, - "CF_CList_Traverse_R was given end %p and should be %p (c->qs[q])", - context_cf_clist_traverse_r.end, expected_end); - UtAssert_True(context_cf_clist_traverse_r.fn == expected_fn, - "CF_CList_Traverse_R was given fn %p and should be %p (CF_PrioSearch)", - context_cf_clist_traverse_r.fn, expected_fn); + UtAssert_ADDRESS_EQ(context_cf_clist_traverse_r.end, expected_end); + UtAssert_True(context_cf_clist_traverse_r.fn == expected_fn, "context_cf_clist_traverse_r.fn == expected_fn"); UtAssert_STUB_COUNT(CF_CList_InsertAfter, 0); UtAssert_STUB_COUNT(CF_CList_InsertBack, 1); - UtAssert_True(context_clist_insert_back.head == expected_insert_back_head, - "CF_CList_InsertBack received head %p and should be %p", - context_clist_insert_back.head, expected_insert_back_head); - UtAssert_True(context_clist_insert_back.node == expected_insert_back_node, - "CF_CList_InsertBack received node %p and should be %p", - context_clist_insert_back.node, expected_insert_back_node); + UtAssert_ADDRESS_EQ(context_clist_insert_back.head, expected_insert_back_head); + UtAssert_ADDRESS_EQ(context_clist_insert_back.node, expected_insert_back_node); UtAssert_True(arg_t->flags.all.q_index == arg_q, "t->flags.all.q_index is %u and should be %u (q)", arg_t->flags.all.q_index, arg_q); -} /* end Test_CF_InsertSortPrio_Calls_CF_CList_InsertBack_Ex_BecauseNull_p_t */ +} /* end Test_CF_InsertSortPrio_When_p_t_Is_NULL_Call_CF_CList_InsertBack_Ex */ /* end CF_InsertSortPrio tests */ @@ -1130,7 +1004,7 @@ void Test_CF_InsertSortPrio_Calls_CF_CList_InsertBack_Ex_BecauseNull_p_t(void) ** *******************************************************************************/ -void Test_CF_TraverseAllTransactions__GetsContainer_t_Calls_args_fn_AndAdds1ToCounter(void) +void Test_CF_TraverseAllTransactions__GetContainer_t_Call_args_fn_AndAdd_1_ToCounter(void) { /* Arrange */ transaction_t dummy_t; @@ -1160,16 +1034,10 @@ void Test_CF_TraverseAllTransactions__GetsContainer_t_Calls_args_fn_AndAdds1ToCo /* Act */ result = CF_TraverseAllTransactions_(arg_n, arg_args); - UT_GetStubCount(UT_KEY(DummyFunctionFor_CF_TraverseAllTransactions_)); - /* Assert */ UtAssert_STUB_COUNT(DummyFunctionFor_CF_TraverseAllTransactions_, 1); - UtAssert_True(func_ptr_context.t == expected_t, - "args fn (func ptr) was given t %p and should be %p (t)", - func_ptr_context.t, expected_t); - UtAssert_True(func_ptr_context.context == expected_context, - "args fn (func ptr) was given context %p and should be %p (args->context)", - func_ptr_context.context, expected_context); + UtAssert_ADDRESS_EQ(func_ptr_context.t, expected_t); + UtAssert_ADDRESS_EQ(func_ptr_context.context, expected_context); UtAssert_True(arg_args->counter == initial_args_counter + 1, "CF_TraverseAllTransactions_ set args->counter to %d which is 1 more than initial value %d", arg_args->counter, initial_args_counter); @@ -1177,7 +1045,7 @@ void Test_CF_TraverseAllTransactions__GetsContainer_t_Calls_args_fn_AndAdds1ToCo "CF_TraverseAllTransactions_ returned %d and should be %d (CLIST_CONT)", result, CLIST_CONT); -} /* end Test_CF_TraverseAllTransactions__GetsContainer_t_Calls_args_fn_AndAdds1ToCounter */ +} /* end Test_CF_TraverseAllTransactions__GetContainer_t_Call_args_fn_AndAdd_1_ToCounter */ /******************************************************************************* ** @@ -1185,7 +1053,7 @@ void Test_CF_TraverseAllTransactions__GetsContainer_t_Calls_args_fn_AndAdds1ToCo ** *******************************************************************************/ -void Test_CF_TraverseAllTransactions_CallsOtherFunction_CF_Q_RX_TimesAndReturns_args_counter(void) +void Test_CF_TraverseAllTransactions_CallOtherFunction_CF_Q_RX_TimesAndReturn_args_counter(void) { /* Arrange */ channel_t dummy_c; @@ -1221,24 +1089,13 @@ void Test_CF_TraverseAllTransactions_CallsOtherFunction_CF_Q_RX_TimesAndReturns_ /* Assert */ for(i = 0; i < expected_count; ++i) { - UtAssert_True(contexts_cf_clist_traverse[i].start == (clist_node) &expected_qs_nodes[i], - "CF_CList_Traverse received start %p and should be %p (c->qs[index])", - contexts_cf_clist_traverse[i].start, &expected_qs_nodes[i]); - UtAssert_True(contexts_cf_clist_traverse[i].fn == (clist_fn_t) CF_TraverseAllTransactions_, - "CF_CList_Traverse received fn %p and should be %p (CF_TraverseAllTransactions_)", - contexts_cf_clist_traverse[i].fn, CF_TraverseAllTransactions_); - UtAssert_True(contexts_cf_clist_traverse[i].context_fn == - DummyFunctionFor_CF_TraverseAllTransactions_, - "CF_CList_Traverse context.fn[%u] is %p and should be %p (CF_TraverseAllTransactions_fn_t fn)", - i, contexts_cf_clist_traverse[i].context_fn, - DummyFunctionFor_CF_TraverseAllTransactions_); - UtAssert_True(contexts_cf_clist_traverse[i].context_context == arg_context, - "CF_CList_Traverse context.context[%u] is %p and should be %p (void *context)", - i, contexts_cf_clist_traverse[i].context_fn, - DummyFunctionFor_CF_TraverseAllTransactions_); - //TODO: checking the context count really only verifies - //CF_CList_Traverse stub works properly -- this could be removed, - //should it? Although it is the only thing showing diff in the contexts + UtAssert_ADDRESS_EQ(contexts_cf_clist_traverse[i].start, (clist_node) &expected_qs_nodes[i]); + UtAssert_True(contexts_cf_clist_traverse[i].fn == (clist_fn_t) CF_TraverseAllTransactions_, "contexts_cf_clist_traverse[i].fn == (clist_fn_t) CF_TraverseAllTransactions_"); + UtAssert_True(contexts_cf_clist_traverse[i].context_fn == DummyFunctionFor_CF_TraverseAllTransactions_, "contexts_cf_clist_traverse[i].context_fn == DummyFunctionFor_CF_TraverseAllTransactions_"); + UtAssert_ADDRESS_EQ(contexts_cf_clist_traverse[i].context_context, arg_context); + /* NOTE: checking the context count really only verifies + ** CF_CList_Traverse stub works properly -- this could be removed, + ** should it? Although it is the only thing showing diff in the contexts */ UtAssert_True(contexts_cf_clist_traverse[i].context_counter == i + 1, "CF_CList_Traverse context_counter[%u] is %d and should be %d (+1 from previous)", i, contexts_cf_clist_traverse[i].context_counter, i + 1); @@ -1246,7 +1103,7 @@ void Test_CF_TraverseAllTransactions_CallsOtherFunction_CF_Q_RX_TimesAndReturns_ UtAssert_True(result == expected_count, "CF_TraverseAllTransactions returned %d and should be %d (CF_Q_RX - CF_Q_PEND + 1)", result, expected_count); -} /* end Test_CF_TraverseAllTransactions_CallsOtherFunction_CF_Q_RX_TimesAndReturns_args_counter */ +} /* end Test_CF_TraverseAllTransactions_CallOtherFunction_CF_Q_RX_TimesAndReturn_args_counter */ /******************************************************************************* ** @@ -1254,7 +1111,7 @@ void Test_CF_TraverseAllTransactions_CallsOtherFunction_CF_Q_RX_TimesAndReturns_ ** *******************************************************************************/ -void Test_CF_TraverseAllTransactions_All_Channels_ReturnsTotalTraversals(void) +void Test_CF_TraverseAllTransactions_All_Channels_ReturnTotalTraversals(void) { /* Arrange */ int dummy_context; @@ -1264,7 +1121,7 @@ void Test_CF_TraverseAllTransactions_All_Channels_ReturnsTotalTraversals(void) int expected_result = per_channel_count * CF_NUM_CHANNELS; CF_TraverseAllTransactions_fn_t arg_fn = NULL; - /* Arrange unstubbable: CF_TraverseAllTransactions */ + /* Arrange for CF_TraverseAllTransactions */ /* set correct context type for CF_CList_Traverse stub */ type_of_context_CF_CList_Traverse = TRAVERSE_ALL_ARGS_T; @@ -1276,7 +1133,7 @@ void Test_CF_TraverseAllTransactions_All_Channels_ReturnsTotalTraversals(void) "CF_TraverseAllTransactions_All_Channels returned %d and should be %d (total transversals)", local_result, expected_result); -} /* end Test_CF_TraverseAllTransactions_All_Channels_ReturnsTotalTraversals */ +} /* end Test_CF_TraverseAllTransactions_All_Channels_ReturnTotalTraversals */ /* end CF_TraverseAllTransactions_All_Channels tests */ @@ -1286,15 +1143,15 @@ void Test_CF_TraverseAllTransactions_All_Channels_ReturnsTotalTraversals(void) ** *******************************************************************************/ -void Test_CF_WrappedOpen_Calls_OS_OpenCreate_WithGivenArgumentsAndReturnsItsValue(void) +void Test_CF_WrappedOpen_Call_OS_OpenCreate_WithGivenArgumentsAndReturnItsReturnValue(void) { /* Arrange */ osal_id_t dummy_fd; osal_id_t* arg_fd = &dummy_fd; char dummy_fname; char* arg_fname = &dummy_fname; - int32 arg_flags; - int32 arg_access; + int32 arg_flags = Any_uint32(); + int32 arg_access = Any_uint32(); int32 forced_return_OS_OpenCreate = Any_int32(); UT_SetDefaultReturnValue(UT_KEY(OS_OpenCreate), forced_return_OS_OpenCreate); @@ -1306,7 +1163,7 @@ void Test_CF_WrappedOpen_Calls_OS_OpenCreate_WithGivenArgumentsAndReturnsItsValu UtAssert_INT32_EQ(result, forced_return_OS_OpenCreate); UtAssert_STUB_COUNT(CFE_ES_PerfLogAdd, 2); UtAssert_STUB_COUNT(OS_OpenCreate, 1); -} /* end Test_CF_WrappedOpen_Calls_OS_OpenCreate_WithGivenArgumentsAndReturnsItsValue */ +} /* end Test_CF_WrappedOpen_Call_OS_OpenCreate_WithGivenArgumentsAndReturnItsReturnValue */ /* end CF_WrappedOpen tests */ @@ -1316,7 +1173,7 @@ void Test_CF_WrappedOpen_Calls_OS_OpenCreate_WithGivenArgumentsAndReturnsItsValu ** *******************************************************************************/ -void Test_CF_WrappedClose_DoesNotReceive_OS_SUCCESS_From_OS_close_EventSent(void) +void Test_CF_WrappedClose_DoNotReceive_OS_SUCCESS_From_OS_close_EventSent(void) { /* Arrange */ int32 arg_fd = Any_uint32(); @@ -1330,9 +1187,9 @@ void Test_CF_WrappedClose_DoesNotReceive_OS_SUCCESS_From_OS_close_EventSent(void UtAssert_STUB_COUNT(CFE_ES_PerfLogAdd, 2); UtAssert_STUB_COUNT(OS_close, 1); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 1); -} /* end Test_CF_WrappedClose_DoesNotReceive_OS_SUCCESS_From_OS_close_EventSent */ +} /* end Test_CF_WrappedClose_DoNotReceive_OS_SUCCESS_From_OS_close_EventSent */ -void Test_CF_WrappedClose_Receives_OS_SUCCESS_From_OS_close_NoEventSent(void) +void Test_CF_WrappedClose_Receive_OS_SUCCESS_From_OS_close_NoEventSent(void) { /* Arrange */ int32 arg_fd = Any_uint32(); @@ -1347,7 +1204,7 @@ void Test_CF_WrappedClose_Receives_OS_SUCCESS_From_OS_close_NoEventSent(void) UtAssert_STUB_COUNT(CFE_ES_PerfLogAdd, 2); UtAssert_STUB_COUNT(OS_close, 1); UtAssert_STUB_COUNT(CFE_EVS_SendEvent, 0); -} /* end Test_CF_WrappedWrite_Calls_OS_write_WithGivenArgumentsAndReturnsItsValue */ +} /* end Test_CF_WrappedClose_Receive_OS_SUCCESS_From_OS_close_NoEventSent */ /* end CF_WrappedClose tests */ @@ -1357,7 +1214,7 @@ void Test_CF_WrappedClose_Receives_OS_SUCCESS_From_OS_close_NoEventSent(void) ** *******************************************************************************/ -void Test_CF_WrappedRead_Calls_OS_read_WithGivenArgumentsAndReturnsItsValue(void) +void Test_CF_WrappedRead_CallsOS_read_WithGivenArgumentsAndReturnItsReturnValue(void) { /* Arrange */ int32 arg_fd = Any_int32(); @@ -1375,8 +1232,7 @@ void Test_CF_WrappedRead_Calls_OS_read_WithGivenArgumentsAndReturnsItsValue(void UtAssert_True(local_result == arg_read_size, "CF_WrappedRead returned %d which is the value returned from OS_read %d", local_result, arg_read_size); - // TODO: show OS_read received fd, buf, read_size -} /* end Test_CF_WrappedWrite_Calls_OS_write_WithGivenArgumentsAndReturnsItsValue */ +} /* end Test_CF_WrappedRead_CallsOS_read_WithGivenArgumentsAndReturnItsReturnValue */ /* end CF_WrappedRead tests */ @@ -1386,7 +1242,7 @@ void Test_CF_WrappedRead_Calls_OS_read_WithGivenArgumentsAndReturnsItsValue(void ** *******************************************************************************/ -void Test_CF_WrappedWrite_Calls_OS_write_WithGivenArgumentsAndReturnsItsValue(void) +void Test_CF_WrappedWrite_Call_OS_write_WithGivenArgumentsAndReturnItsReturnValue(void) { /* Arrange */ int32 arg_fd = Any_int32(); @@ -1405,8 +1261,7 @@ void Test_CF_WrappedWrite_Calls_OS_write_WithGivenArgumentsAndReturnsItsValue(vo UtAssert_True(local_result == expected_result, "CF_WrappedWrite returned %d which is the value returned from OS_write %d", local_result, expected_result); - // TODO: show OS_write received fd, buf, write_size -} /* end Test_CF_WrappedWrite_Calls_OS_write_WithGivenArgumentsAndReturnsItsValue */ +} /* end Test_CF_WrappedWrite_Call_OS_write_WithGivenArgumentsAndReturnItsReturnValue */ /* end CF_WrappedWrite tests */ @@ -1416,7 +1271,7 @@ void Test_CF_WrappedWrite_Calls_OS_write_WithGivenArgumentsAndReturnsItsValue(vo ** *******************************************************************************/ -void Test_CF_WrappedLseek_Calls_OS_lseek_WithGivenArgumentsAndReturnsItsValue(void) +void Test_CF_WrappedLseek_Call_OS_lseek_WithGivenArgumentsAndReturnItsReturnValue(void) { /* Arrange */ int32 arg_fd = Any_int32(); @@ -1434,8 +1289,7 @@ void Test_CF_WrappedLseek_Calls_OS_lseek_WithGivenArgumentsAndReturnsItsValue(vo UtAssert_True(local_result == expected_result, "CF_WrappedLseek returned %d which is the value returned from OS_lseek %d", local_result, expected_result); - // TODO: show OS_lseek received fd, offset, mode -} /* end Test_CF_WrappedLseek_Calls_OS_lseek_WithGivenArgumentsAndReturnsItsValue */ +} /* end Test_CF_WrappedLseek_Call_OS_lseek_WithGivenArgumentsAndReturnItsReturnValue */ /* end CF_WrappedLseek tests */ @@ -1444,6 +1298,7 @@ void Test_CF_WrappedLseek_Calls_OS_lseek_WithGivenArgumentsAndReturnsItsValue(vo ** cf_utils_tests UtTest_Add groups ** *******************************************************************************/ + void add_cf_utils_h_tests(void) { /* cf_dequeue_transaction tests */ @@ -1456,9 +1311,9 @@ void add_cf_utils_h_tests(void) UtTest_Add(Test_cf_dequeue_transaction_AssertsBecause_q_size_Eq0, cf_utils_tests_Setup, cf_utils_tests_Teardown, "Test_cf_dequeue_transaction_AssertsBecause_q_size_Eq0"); - UtTest_Add(Test_cf_dequeue_transaction_Calls_CF_CList_Remove_AndDecrementsThe_q_size, + UtTest_Add(Test_cf_dequeue_transaction_Call_CF_CList_Remove_AndDecrement_q_size, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_cf_dequeue_transaction_Calls_CF_CList_Remove_AndDecrementsThe_q_size"); + "Test_cf_dequeue_transaction_Call_CF_CList_Remove_AndDecrement_q_size"); /* end cf_dequeue_transaction tests */ /* cf_move_transaction tests */ @@ -1471,84 +1326,84 @@ void add_cf_utils_h_tests(void) UtTest_Add(Test_cf_move_transaction_AssertsBecause_channel_hk_Has_q_size_Eq0, cf_utils_tests_Setup, cf_utils_tests_Teardown, "Test_cf_move_transaction_AssertsBecause_channel_hk_Has_q_size_Eq0"); - UtTest_Add(Test_cf_move_transaction_SuccessCalls_CF_CList_InsertBack_AndSets_q_index_ToPassedIn_q, + UtTest_Add(Test_cf_move_transaction_Call_CF_CList_InsertBack_AndSet_q_index_ToGiven_q, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_cf_move_transaction_SuccessCalls_CF_CList_InsertBack_AndSets_q_index_ToPassedIn_q"); + "Test_cf_move_transaction_Call_CF_CList_InsertBack_AndSet_q_index_ToGiven_q"); /* end cf_move_transaction tests */ /* CF_CList_Remove_Ex tests */ UtTest_Add(Test_CF_CList_Remove_Ex_AssertsBecause_q_size_Eq0, cf_utils_tests_Setup, cf_utils_tests_Teardown, "Test_CF_CList_Remove_Ex_AssertsBecause_q_size_Eq0"); - UtTest_Add(Test_CF_CList_Remove_Ex_Calls_CF_CList_Remove_AndDecrements_q_size, + UtTest_Add(Test_CF_CList_Remove_Ex_Call_CF_CList_Remove_AndDecrement_q_size, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_CList_Remove_Ex_Calls_CF_CList_Remove_AndDecrements_q_size"); + "Test_CF_CList_Remove_Ex_Call_CF_CList_Remove_AndDecrement_q_size"); /* end CF_CList_Remove_Ex tests */ /* CF_CList_InsertAfter_Ex tests */ - UtTest_Add(Test_CF_CList_InsertAfter_Ex_Calls_CF_CList_InsertAfter_AndIncrements_q_size, + UtTest_Add(Test_CF_CList_InsertAfter_Ex_Call_CF_CList_InsertAfter_AndIncrement_q_size, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_CList_InsertAfter_Ex_Calls_CF_CList_InsertAfter_AndIncrements_q_size"); + "Test_CF_CList_InsertAfter_Ex_Call_CF_CList_InsertAfter_AndIncrement_q_size"); /* end CF_CList_InsertAfter_Ex tests */ /* CF_CList_InsertBack_Ex tests */ - UtTest_Add(Test_CF_CList_InsertBack_Ex_Calls_CF_CList_InsertBack_AndIncrements_q_size, + UtTest_Add(Test_CF_CList_InsertBack_Ex_Call_CF_CList_InsertBack_AndIncrement_q_size, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_CList_InsertBack_Ex_Calls_CF_CList_InsertBack_AndIncrements_q_size"); + "Test_CF_CList_InsertBack_Ex_Call_CF_CList_InsertBack_AndIncrement_q_size"); /* end CF_CList_InsertBack_Ex tests */ } void add_CF_TraverseHistory_tests(void) { - UtTest_Add(Test_CF_TraverseHistory_Asserts_h_dir_GreaterThan_CF_DIR_NUM, + UtTest_Add(Test_CF_TraverseHistory_AssertsBecause_h_dir_GreaterThan_CF_DIR_NUM, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_TraverseHistory_Asserts_h_dir_GreaterThan_CF_DIR_NUM"); - UtTest_Add(Test_CF_TraverseHistory_Returns_CLIST_EXIT_WhenCF_WrappedWriteFailsFirstCall, + "Test_CF_TraverseHistory_AssertsBecause_h_dir_GreaterThan_CF_DIR_NUM"); + UtTest_Add(Test_CF_TraverseHistory_When_CF_WrappedWrite_FailsFirstCallReturn_CLIST_EXIT, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_TraverseHistory_Returns_CLIST_EXIT_WhenCF_WrappedWriteFailsFirstCall"); - UtTest_Add(Test_CF_TraverseHistory_Returns_CLIST_EXIT_WhenCF_WrappedWriteFailsSecondCall, + "Test_CF_TraverseHistory_When_CF_WrappedWrite_FailsFirstCallReturn_CLIST_EXIT"); + UtTest_Add(Test_CF_TraverseHistory_When_CF_WrappedWrite_FailsSecondCallReturn_CLIST_EXIT, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_TraverseHistory_Returns_CLIST_EXIT_WhenCF_WrappedWriteFailsSecondCall"); - UtTest_Add(Test_CF_TraverseHistory_Returns_CLIST_CONT_WhenBothWrappedWritesSuccessful, + "Test_CF_TraverseHistory_When_CF_WrappedWrite_FailsSecondCallReturn_CLIST_EXIT"); + UtTest_Add(Test_CF_TraverseHistory_WhenBothWrappedWritesSuccessfulReturn_CLIST_CONT, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_TraverseHistory_Returns_CLIST_CONT_WhenBothWrappedWritesSuccessful"); + "Test_CF_TraverseHistory_WhenBothWrappedWritesSuccessfulReturn_CLIST_CONT"); } void add_CF_TraverseTransactions_tests(void) { - UtTest_Add(Test_CF_TraverseTransactions_Returns_CLIST_EXIT_When_context_result_Eq1, + UtTest_Add(Test_CF_TraverseTransactions_When_context_result_Is_1_Return_CLIST_EXIT, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_TraverseTransactions_Returns_CLIST_EXIT_When_context_result_Eq1"); - UtTest_Add(Test_CF_TraverseTransactions_Returns_CLIST_CONT_When_context_result_Eq0, + "Test_CF_TraverseTransactions_When_context_result_Is_1_Return_CLIST_EXIT"); + UtTest_Add(Test_CF_TraverseTransactions_When_context_result_Is_0_Return_CLIST_CONT, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_TraverseTransactions_Returns_CLIST_CONT_When_context_result_Eq0"); + "Test_CF_TraverseTransactions_When_context_result_Is_0_Return_CLIST_CONT"); } void add_CF_WriteQueueDataToFile_tests(void) { - UtTest_Add(Test_CF_WriteQueueDataToFile_Calls_CF_CList_Traverse_AndReturns_arg_result, + UtTest_Add(Test_CF_WriteQueueDataToFile_Call_CF_CList_Traverse_AndReturn_arg_result, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_WriteQueueDataToFile_Calls_CF_CList_Traverse_AndReturns_arg_result"); + "Test_CF_WriteQueueDataToFile_Call_CF_CList_Traverse_AndReturn_arg_result"); } void add_CF_WriteHistoryQueueDataToFile_tests(void) { - UtTest_Add(Test_CF_WriteHistoryQueueDataToFile_Calls_CF_CList_Traverse_AndReturns_arg_result, + UtTest_Add(Test_CF_WriteHistoryQueueDataToFile_Call_CF_CList_Traverse_AndReturn_arg_result, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_WriteHistoryQueueDataToFile_Calls_CF_CList_Traverse_AndReturns_arg_result"); + "Test_CF_WriteHistoryQueueDataToFile_Call_CF_CList_Traverse_AndReturn_arg_result"); } void add_CF_PrioSearch_tests(void) { - UtTest_Add(Test_CF_PrioSearch_Returns_CLIST_CONT_Because_t_PrioIsGreaterThanContextPrio, + UtTest_Add(Test_CF_PrioSearch_When_t_PrioIsGreaterThanContextPrioReturn_CLIST_CONT, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_PrioSearch_Returns_CLIST_CONT_Because_t_PrioIsGreaterThanContextPrio"); - UtTest_Add(Test_CF_PrioSearch_Returns_CLIST_EXIT_AndSets_context_t_To_t_Because_t_PrioIsEqToContextPrio, + "Test_CF_PrioSearch_When_t_PrioIsGreaterThanContextPrioReturn_CLIST_CONT"); + UtTest_Add(Test_CF_PrioSearch_When_t_PrioIsEqToContextPrio_Set_context_t_To_t_AndReturn_CLIST_EXIT, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_PrioSearch_Returns_CLIST_EXIT_AndSets_context_t_To_t_Because_t_PrioIsEqToContextPrio"); - UtTest_Add(Test_CF_PrioSearch_Returns_CLIST_EXIT_AndSets_context_t_To_t_Because_t_PrioIsLessThanContextPrio, + "Test_CF_PrioSearch_When_t_PrioIsEqToContextPrio_Set_context_t_To_t_AndReturn_CLIST_EXIT"); + UtTest_Add(Test_CF_PrioSearch_When_t_PrioIsLessThanContextPrio_Set_context_t_To_t_AndReturn_CLIST_EXIT, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_PrioSearch_Returns_CLIST_EXIT_AndSets_context_t_To_t_Because_t_PrioIsLessThanContextPrio"); + "Test_CF_PrioSearch_When_t_PrioIsLessThanContextPrio_Set_context_t_To_t_AndReturn_CLIST_EXIT"); } void add_CF_InsertSortPrio_tests(void) @@ -1559,74 +1414,74 @@ void add_CF_InsertSortPrio_tests(void) UtTest_Add(Test_CF_InsertSortPrio_AssertsBecause_t_state_IsNot_CFDP_IDLE, cf_utils_tests_Setup, cf_utils_tests_Teardown, "Test_CF_InsertSortPrio_AssertsBecause_t_state_IsNot_CFDP_IDLE"); - UtTest_Add(Test_CF_InsertSortPrio_Calls_CF_CList_InsertBack_Ex_ListIsEmpty_AndSets_q_index_To_q, + UtTest_Add(Test_CF_InsertSortPrio_Call_CF_CList_InsertBack_Ex_ListIsEmpty_AndSet_q_index_To_q, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_InsertSortPrio_Calls_CF_CList_InsertBack_Ex_ListIsEmpty_AndSets_q_index_To_q"); - UtTest_Add(Test_CF_InsertSortPrio_Calls_CF_CList_InsertAfter_Ex_AndSets_q_index_To_q, + "Test_CF_InsertSortPrio_Call_CF_CList_InsertBack_Ex_ListIsEmpty_AndSet_q_index_To_q"); + UtTest_Add(Test_CF_InsertSortPrio_Call_CF_CList_InsertAfter_Ex_AndSet_q_index_To_q, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_InsertSortPrio_Calls_CF_CList_InsertAfter_Ex_AndSets_q_index_To_q"); - UtTest_Add(Test_CF_InsertSortPrio_Calls_CF_CList_InsertBack_Ex_BecauseNull_p_t, + "Test_CF_InsertSortPrio_Call_CF_CList_InsertAfter_Ex_AndSet_q_index_To_q"); + UtTest_Add(Test_CF_InsertSortPrio_When_p_t_Is_NULL_Call_CF_CList_InsertBack_Ex, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_InsertSortPrio_Calls_CF_CList_InsertBack_Ex_BecauseNull_p_t"); + "Test_CF_InsertSortPrio_When_p_t_Is_NULL_Call_CF_CList_InsertBack_Ex"); } void add_CF_TraverseAllTransactions__tests(void) { - UtTest_Add(Test_CF_TraverseAllTransactions__GetsContainer_t_Calls_args_fn_AndAdds1ToCounter, + UtTest_Add(Test_CF_TraverseAllTransactions__GetContainer_t_Call_args_fn_AndAdd_1_ToCounter, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_TraverseAllTransactions__GetsContainer_t_Calls_args_fn_AndAdds1ToCounter"); + "Test_CF_TraverseAllTransactions__GetContainer_t_Call_args_fn_AndAdd_1_ToCounter"); } void add_CF_TraverseAllTransactions_tests(void) { - UtTest_Add(Test_CF_TraverseAllTransactions_CallsOtherFunction_CF_Q_RX_TimesAndReturns_args_counter, + UtTest_Add(Test_CF_TraverseAllTransactions_CallOtherFunction_CF_Q_RX_TimesAndReturn_args_counter, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_TraverseAllTransactions_CallsOtherFunction_CF_Q_RX_TimesAndReturns_args_counter"); + "Test_CF_TraverseAllTransactions_CallOtherFunction_CF_Q_RX_TimesAndReturn_args_counter"); } void add_CF_TraverseAllTransactions_All_Channels_tests(void) { - UtTest_Add(Test_CF_TraverseAllTransactions_All_Channels_ReturnsTotalTraversals, + UtTest_Add(Test_CF_TraverseAllTransactions_All_Channels_ReturnTotalTraversals, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_TraverseAllTransactions_All_Channels_ReturnsTotalTraversals"); + "Test_CF_TraverseAllTransactions_All_Channels_ReturnTotalTraversals"); } void add_CF_WrappedOpen_tests(void) { - UtTest_Add(Test_CF_WrappedOpen_Calls_OS_OpenCreate_WithGivenArgumentsAndReturnsItsValue, + UtTest_Add(Test_CF_WrappedOpen_Call_OS_OpenCreate_WithGivenArgumentsAndReturnItsReturnValue, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_WrappedOpen_Calls_OS_OpenCreate_WithGivenArgumentsAndReturnsItsValue"); + "Test_CF_WrappedOpen_Call_OS_OpenCreate_WithGivenArgumentsAndReturnItsReturnValue"); } void add_CF_WrappedClose_tests(void) { - UtTest_Add(Test_CF_WrappedClose_DoesNotReceive_OS_SUCCESS_From_OS_close_EventSent, + UtTest_Add(Test_CF_WrappedClose_DoNotReceive_OS_SUCCESS_From_OS_close_EventSent, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_WrappedClose_DoesNotReceive_OS_SUCCESS_From_OS_close_EventSent"); - UtTest_Add(Test_CF_WrappedClose_Receives_OS_SUCCESS_From_OS_close_NoEventSent, + "Test_CF_WrappedClose_DoNotReceive_OS_SUCCESS_From_OS_close_EventSent"); + UtTest_Add(Test_CF_WrappedClose_Receive_OS_SUCCESS_From_OS_close_NoEventSent, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_WrappedClose_Receives_OS_SUCCESS_From_OS_close_NoEventSent"); + "Test_CF_WrappedClose_Receive_OS_SUCCESS_From_OS_close_NoEventSent"); } void add_CF_WrappedRead_tests(void) { - UtTest_Add(Test_CF_WrappedRead_Calls_OS_read_WithGivenArgumentsAndReturnsItsValue, + UtTest_Add(Test_CF_WrappedRead_CallsOS_read_WithGivenArgumentsAndReturnItsReturnValue, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_WrappedRead_Calls_OS_read_WithGivenArgumentsAndReturnsItsValue"); + "Test_CF_WrappedRead_CallsOS_read_WithGivenArgumentsAndReturnItsReturnValue"); } void add_CF_WrappedWrite_tests(void) { - UtTest_Add(Test_CF_WrappedWrite_Calls_OS_write_WithGivenArgumentsAndReturnsItsValue, + UtTest_Add(Test_CF_WrappedWrite_Call_OS_write_WithGivenArgumentsAndReturnItsReturnValue, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_WrappedWrite_Calls_OS_write_WithGivenArgumentsAndReturnsItsValue"); + "Test_CF_WrappedWrite_Call_OS_write_WithGivenArgumentsAndReturnItsReturnValue"); } void add_CF_WrappedLseek_tests(void) { - UtTest_Add(Test_CF_WrappedLseek_Calls_OS_lseek_WithGivenArgumentsAndReturnsItsValue, + UtTest_Add(Test_CF_WrappedLseek_Call_OS_lseek_WithGivenArgumentsAndReturnItsReturnValue, cf_utils_tests_Setup, cf_utils_tests_Teardown, - "Test_CF_WrappedLseek_Calls_OS_lseek_WithGivenArgumentsAndReturnsItsValue"); + "Test_CF_WrappedLseek_Call_OS_lseek_WithGivenArgumentsAndReturnItsReturnValue"); } /******************************************************************************* diff --git a/unit-test/stubs/cf_app_stubs.c b/unit-test/stubs/cf_app_stubs.c index a98c7be2..35243ee1 100644 --- a/unit-test/stubs/cf_app_stubs.c +++ b/unit-test/stubs/cf_app_stubs.c @@ -26,6 +26,7 @@ /* UT includes */ #include "uttest.h" #include "utstubs.h" +#include "uttools.h" CF_AppData_t CF_AppData; @@ -40,10 +41,12 @@ CF_AppData_t CF_AppData; ** None ** *************************************************************************/ -static void CF_HkCmd(void) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_HkCmd(void) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Checks to see if a table update is pending, and perform it. @@ -55,10 +58,12 @@ static void CF_HkCmd(void) ** None ** *************************************************************************/ -static void CF_CheckTables(void) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CheckTables(void) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Validation function for config table. @@ -75,10 +80,12 @@ static void CF_CheckTables(void) ** \endreturns ** *************************************************************************/ -static int32 CF_ValidateConfigTable(void *tbl_ptr) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int32 CF_ValidateConfigTable(void *tbl_ptr) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Load the table on application start @@ -92,10 +99,12 @@ static int32 CF_ValidateConfigTable(void *tbl_ptr) ** \endreturns ** *************************************************************************/ -static int32 CF_TableInit(void) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int32 CF_TableInit(void) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief CF app init function @@ -113,10 +122,12 @@ static int32 CF_TableInit(void) ** \endreturns ** *************************************************************************/ -static int32 CF_Init(void) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int32 CF_Init(void) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief CF wakeup function @@ -128,10 +139,12 @@ static int32 CF_Init(void) ** None ** *************************************************************************/ -static void CF_WakeUp(void) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_WakeUp(void) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief CF message processing function @@ -144,10 +157,12 @@ static void CF_WakeUp(void) ** msg must not be NULL. ** *************************************************************************/ -static void CF_ProcessMsg(CFE_SB_Buffer_t msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_ProcessMsg(CFE_SB_Buffer_t msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief CF app entry point @@ -160,8 +175,10 @@ static void CF_ProcessMsg(CFE_SB_Buffer_t msg) ** This must only be called once. ** *************************************************************************/ -void CF_AppMain(void) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// void CF_AppMain(void) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } diff --git a/unit-test/stubs/cf_assert_stubs.c b/unit-test/stubs/cf_assert_stubs.c index 166cdb48..f5d60b8d 100644 --- a/unit-test/stubs/cf_assert_stubs.c +++ b/unit-test/stubs/cf_assert_stubs.c @@ -20,7 +20,6 @@ #include "uttest.h" #include "utstubs.h" - void CF_HandleAssert(const char *file, int line) { /* diff --git a/unit-test/stubs/cf_cfdp_helpers_stubs.c b/unit-test/stubs/cf_cfdp_helpers_stubs.c index 93f5f539..10abcdf5 100644 --- a/unit-test/stubs/cf_cfdp_helpers_stubs.c +++ b/unit-test/stubs/cf_cfdp_helpers_stubs.c @@ -60,7 +60,7 @@ int CF_GetMemcpySize(const uint8_t *num, int size) { UT_GenStub_Execute(CF_GetMemcpySize, Basic, NULL); UT_Stub_CopyToLocal(UT_KEY(CF_GetMemcpySize), &forced_return, sizeof(forced_return)); - UT_Stub_SetReturnValue(CF_GetMemcpySize, forced_return); + UT_Stub_SetReturnValue(UT_KEY(CF_GetMemcpySize), forced_return); return UT_GenStub_GetReturnValue(CF_GetMemcpySize, int); } diff --git a/unit-test/stubs/cf_cfdp_r_stubs.c b/unit-test/stubs/cf_cfdp_r_stubs.c index 76f19eed..7c34beee 100644 --- a/unit-test/stubs/cf_cfdp_r_stubs.c +++ b/unit-test/stubs/cf_cfdp_r_stubs.c @@ -29,6 +29,7 @@ /* UT includes */ #include "uttest.h" #include "utstubs.h" +#include "uttools.h" #include "utgenstub.h" typedef struct { @@ -44,10 +45,12 @@ typedef struct { ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_R2_SetCc(transaction_t *t, condition_code_t cc) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R2_SetCc(transaction_t *t, condition_code_t cc) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief CFDP R1 transaction reset function. @@ -61,10 +64,12 @@ static void CF_CFDP_R2_SetCc(transaction_t *t, condition_code_t cc) ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_R1_Reset(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R1_Reset(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief CFDP R2 transaction reset function. @@ -76,10 +81,12 @@ static void CF_CFDP_R1_Reset(transaction_t *t) ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_R2_Reset(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R2_Reset(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Checks that the transaction file's CRC matches expected. @@ -92,10 +99,12 @@ static void CF_CFDP_R2_Reset(transaction_t *t) ** \endreturns ** *************************************************************************/ -static int CF_CFDP_R_CheckCrc(transaction_t *t, uint32 expected_crc) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_R_CheckCrc(transaction_t *t, uint32 expected_crc) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Checks R2 transaction state for transaction completion status. @@ -113,10 +122,12 @@ static int CF_CFDP_R_CheckCrc(transaction_t *t, uint32 expected_crc) ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_R2_Complete(transaction_t *t, int ok_to_send_nak) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R2_Complete(transaction_t *t, int ok_to_send_nak) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Process a filedata PDU on a transaction. @@ -129,10 +140,12 @@ static void CF_CFDP_R2_Complete(transaction_t *t, int ok_to_send_nak) ** \endreturns ** *************************************************************************/ -static int CF_CFDP_R_ProcessFd(transaction_t *t, uint32 *bytes_received) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_R_ProcessFd(transaction_t *t, uint32 *bytes_received) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Processing receive EOF common functionality for R1/R2. @@ -150,10 +163,12 @@ static int CF_CFDP_R_ProcessFd(transaction_t *t, uint32 *bytes_received) ** \endreturns ** *************************************************************************/ -static int CF_CFDP_R_SubstateRecvEof(transaction_t *t, const pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_R_SubstateRecvEof(transaction_t *t, const pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Process receive EOF for R1. @@ -169,10 +184,12 @@ static int CF_CFDP_R_SubstateRecvEof(transaction_t *t, const pdu_header_t *pdu) ** \endreturns ** *************************************************************************/ -static void CF_CFDP_R1_SubstateRecvEof(transaction_t *t, const pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R1_SubstateRecvEof(transaction_t *t, const pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Process receive EOF for R2. @@ -189,10 +206,12 @@ static void CF_CFDP_R1_SubstateRecvEof(transaction_t *t, const pdu_header_t *pdu ** \endreturns ** *************************************************************************/ -static void CF_CFDP_R2_SubstateRecvEof(transaction_t *t, const pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R2_SubstateRecvEof(transaction_t *t, const pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Process received file data for R1. @@ -204,10 +223,12 @@ static void CF_CFDP_R2_SubstateRecvEof(transaction_t *t, const pdu_header_t *pdu ** t must not be NULL. pdu must not be NULL. ** *************************************************************************/ -static void CF_CFDP_R1_SubstateRecvFileData(transaction_t *t, const pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R1_SubstateRecvFileData(transaction_t *t, const pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Process received file data for R2. @@ -223,10 +244,12 @@ static void CF_CFDP_R1_SubstateRecvFileData(transaction_t *t, const pdu_header_t ** t must not be NULL. pdu must not be NULL. ** *************************************************************************/ -static void CF_CFDP_R2_SubstateRecvFileData(transaction_t *t, const pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R2_SubstateRecvFileData(transaction_t *t, const pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Loads a single NAK segment request. @@ -242,10 +265,12 @@ static void CF_CFDP_R2_SubstateRecvFileData(transaction_t *t, const pdu_header_t ** \endreturns ** *************************************************************************/ -static void CF_CFDP_R2_GapCompute(const chunks_t *chunks, const chunk_t *c, void *opaque) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R2_GapCompute(const chunks_t *chunks, const chunk_t *c, void *opaque) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Send a NAK pdu for R2. @@ -265,10 +290,12 @@ static void CF_CFDP_R2_GapCompute(const chunks_t *chunks, const chunk_t *c, void ** \endreturns ** *************************************************************************/ -static int CF_CFDP_R_SubstateSendNak(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_R_SubstateSendNak(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Initialize a transaction structure for R. @@ -279,13 +306,9 @@ static int CF_CFDP_R_SubstateSendNak(transaction_t *t) *************************************************************************/ void CF_CFDP_R_Init(transaction_t *t) { - UT_GenStub_SetupReturnBuffer(CF_CFDP_R_Init, int); - UT_GenStub_AddParam(CF_CFDP_R_Init, transaction_t *, t); UT_GenStub_Execute(CF_CFDP_R_Init, Basic, NULL); - - return UT_GenStub_GetReturnValue(CF_CFDP_R_Init, int); } /************************************************************************/ @@ -310,10 +333,12 @@ void CF_CFDP_R_Init(transaction_t *t) ** \endreturns ** *************************************************************************/ -static int CF_CFDP_R2_CalcCrcChunk(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_R2_CalcCrcChunk(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Send a FIN pdu. @@ -326,10 +351,12 @@ static int CF_CFDP_R2_CalcCrcChunk(transaction_t *t) ** \endreturns ** *************************************************************************/ -static int CFDP_R2_SubstateSendFin(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CFDP_R2_SubstateSendFin(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Process receive FIN-ACK pdu. @@ -342,10 +369,12 @@ static int CFDP_R2_SubstateSendFin(transaction_t *t) ** t must not be NULL. pdu must not be NULL. ** *************************************************************************/ -static void CF_CFDP_R2_Recv_fin_ack(transaction_t *t, const pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R2_Recv_fin_ack(transaction_t *t, const pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Process receive metadata pdu for R2. @@ -361,10 +390,12 @@ static void CF_CFDP_R2_Recv_fin_ack(transaction_t *t, const pdu_header_t *pdu) ** t must not be NULL. pdu must not be NULL. ** *************************************************************************/ -static void CF_CFDP_R2_RecvMd(transaction_t *t, const pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R2_RecvMd(transaction_t *t, const pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Dispatch function for all received packets. @@ -378,10 +409,12 @@ static void CF_CFDP_R2_RecvMd(transaction_t *t, const pdu_header_t *pdu) ** t must not be NULL. fns must not be NULL. ** *************************************************************************/ -static void CF_CFDP_R_DispatchRecv(transaction_t *t, void (*const fns[SEND_NUM_STATES][PDU_INVALID_MAX])(transaction_t*, const pdu_header_t*), void (*const fd_fn)(transaction_t*, const pdu_header_t*)) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R_DispatchRecv(transaction_t *t, void (*const fns[SEND_NUM_STATES][PDU_INVALID_MAX])(transaction_t*, const pdu_header_t*), void (*const fd_fn)(transaction_t*, const pdu_header_t*)) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief R1 receive pdu processing. @@ -432,10 +465,12 @@ void CF_CFDP_R_Cancel(transaction_t *t) ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_R_SendInactivityEvent(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_R_SendInactivityEvent(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Perform tick (time-based) processing for R transactions. @@ -453,6 +488,7 @@ static void CF_CFDP_R_SendInactivityEvent(transaction_t *t) *************************************************************************/ void CF_CFDP_R_Tick(transaction_t *t, int *cont) { - unimplemented(__FUNCTION__, __FILE__, __LINE__); + UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", __FILE__, __LINE__); + exit(-86); } diff --git a/unit-test/stubs/cf_cfdp_s_stubs.c b/unit-test/stubs/cf_cfdp_s_stubs.c index ac97c89c..b34239a3 100644 --- a/unit-test/stubs/cf_cfdp_s_stubs.c +++ b/unit-test/stubs/cf_cfdp_s_stubs.c @@ -29,6 +29,7 @@ /* UT includes */ #include "uttest.h" #include "utstubs.h" +#include "uttools.h" #include "utgenstub.h" /************************************************************************/ @@ -43,10 +44,12 @@ ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_S_Reset(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S_Reset(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Send an eof pdu. @@ -61,10 +64,12 @@ static void CF_CFDP_S_Reset(transaction_t *t) ** \endreturns ** *************************************************************************/ -static cfdp_send_ret_t CF_CFDP_S_SendEof(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static cfdp_send_ret_t CF_CFDP_S_SendEof(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Sends an eof for S1. @@ -73,10 +78,12 @@ static cfdp_send_ret_t CF_CFDP_S_SendEof(transaction_t *t) ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_S1_SubstateSendEof(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S1_SubstateSendEof(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Triggers tick processing to send an EOF and wait for EOF-ACK for S2 @@ -85,10 +92,12 @@ static void CF_CFDP_S1_SubstateSendEof(transaction_t *t) ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_S2_SubstateSendEof(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S2_SubstateSendEof(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Helper function to populate the pdu with file data and send it. @@ -108,10 +117,12 @@ static void CF_CFDP_S2_SubstateSendEof(transaction_t *t) ** *************************************************************************/ /* if bytes_to_read is 0, then read max possible */ -static int32CF_CFDP_S_SendFileData(transaction_t *t, uint32 foffs, uint32 bytes_to_read, uint8 calc_crc) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int32 CF_CFDP_S_SendFileData(transaction_t *t, uint32 foffs, uint32 bytes_to_read, uint8 calc_crc) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Standard state function to send the next file data PDU for active transaction. @@ -129,10 +140,12 @@ static int32CF_CFDP_S_SendFileData(transaction_t *t, uint32 foffs, uint32 bytes_ /* regular filedata send * based on t->foffs for current offset * checks for EOF and changes state if necessary */ -static void CF_CFDP_S_SubstateSendFileData(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S_SubstateSendFileData(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Respond to a nak by sending filedata pdus as response. @@ -149,10 +162,12 @@ static void CF_CFDP_S_SubstateSendFileData(transaction_t *t) ** \endreturns ** *************************************************************************/ -static int CF_CFDP_S_CheckAndRespondNak(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_S_CheckAndRespondNak(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Send filedata handling for S2. @@ -165,10 +180,12 @@ static int CF_CFDP_S_CheckAndRespondNak(transaction_t *t) ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_S2_SubstateSendFileData(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S2_SubstateSendFileData(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Send metadata PDU. @@ -181,10 +198,12 @@ static void CF_CFDP_S2_SubstateSendFileData(transaction_t *t) ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_S_SubstateSendMetadata(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S_SubstateSendMetadata(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Send FIN-ACK packet for S2. @@ -193,10 +212,12 @@ static void CF_CFDP_S_SubstateSendMetadata(transaction_t *t) ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_S_SubstateSendFinAck(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S_SubstateSendFinAck(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief A fin was received before file complete, so abandon the transaction. @@ -205,10 +226,12 @@ static void CF_CFDP_S_SubstateSendFinAck(transaction_t *t) ** t must not be NULL. pdu must not be NULL. ** *************************************************************************/ -static void CF_CFDP_S2_EarlyFin(transaction_t *t, const pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S2_EarlyFin(transaction_t *t, const pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief S2 received FIN, so set flag to send FIN-ACK. @@ -217,10 +240,12 @@ static void CF_CFDP_S2_EarlyFin(transaction_t *t, const pdu_header_t *pdu) ** t must not be NULL. pdu must not be NULL. ** *************************************************************************/ -static void CF_CFDP_S2_Fin(transaction_t *t, const pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S2_Fin(transaction_t *t, const pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief S2 NAK pdu received handling. @@ -234,10 +259,12 @@ static void CF_CFDP_S2_Fin(transaction_t *t, const pdu_header_t *pdu) ** t must not be NULL. pdu must not be NULL. ** *************************************************************************/ -static void CF_CFDP_S2_Nak(transaction_t *t, const pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S2_Nak(transaction_t *t, const pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief S2 NAK handling but with arming the NAK timer. @@ -246,10 +273,12 @@ static void CF_CFDP_S2_Nak(transaction_t *t, const pdu_header_t *pdu) ** t must not be NULL. pdu must not be NULL. ** *************************************************************************/ -static void CF_CFDP_S2_Nak_Arm(transaction_t *t, const pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S2_Nak_Arm(transaction_t *t, const pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief S2 received ack pdu in wait for EOF-ACK state. @@ -262,10 +291,12 @@ static void CF_CFDP_S2_Nak_Arm(transaction_t *t, const pdu_header_t *pdu) ** t must not be NULL. pdu must not be NULL. ** *************************************************************************/ -static void CF_CFDP_S2_WaitForEofAck(transaction_t *t, const pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S2_WaitForEofAck(transaction_t *t, const pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Dispatch function for all received packets. @@ -279,10 +310,12 @@ static void CF_CFDP_S2_WaitForEofAck(transaction_t *t, const pdu_header_t *pdu) ** t must not be NULL. fns must not be NULL. ** *************************************************************************/ -static void CF_CFDP_S_DispatchRecv(transaction_t *t, void (*const fns[SEND_NUM_STATES][PDU_INVALID_MAX])(transaction_t*, const pdu_header_t*)) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_S_DispatchRecv(transaction_t *t, void (*const fns[SEND_NUM_STATES][PDU_INVALID_MAX])(transaction_t*, const pdu_header_t*)) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief S1 receive pdu processing. @@ -293,7 +326,8 @@ static void CF_CFDP_S_DispatchRecv(transaction_t *t, void (*const fns[SEND_NUM_S *************************************************************************/ void CF_CFDP_S1_Recv(transaction_t *t) { - unimplemented(__FUNCTION__, __FILE__, __LINE__); + UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", __FILE__, __LINE__); + exit(-86); } /************************************************************************/ @@ -305,7 +339,8 @@ void CF_CFDP_S1_Recv(transaction_t *t) *************************************************************************/ void CF_CFDP_S2_Recv(transaction_t *t) { - unimplemented(__FUNCTION__, __FILE__, __LINE__); + UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", __FILE__, __LINE__); + exit(-86); } /************************************************************************/ @@ -366,7 +401,8 @@ void CF_CFDP_S_Cancel(transaction_t *t) *************************************************************************/ void CF_CFDP_S_Tick(transaction_t *t, int *cont /* unused */) { - unimplemented(__FUNCTION__, __FILE__, __LINE__); + UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", __FILE__, __LINE__); + exit(-86); } /************************************************************************/ @@ -383,5 +419,6 @@ void CF_CFDP_S_Tick(transaction_t *t, int *cont /* unused */) *************************************************************************/ void CF_CFDP_S_Tick_Nak(transaction_t *t, int *cont) { - unimplemented(__FUNCTION__, __FILE__, __LINE__); + UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", __FILE__, __LINE__); + exit(-86); } diff --git a/unit-test/stubs/cf_cfdp_stubs.c b/unit-test/stubs/cf_cfdp_stubs.c index f1656a6e..e2bba534 100644 --- a/unit-test/stubs/cf_cfdp_stubs.c +++ b/unit-test/stubs/cf_cfdp_stubs.c @@ -40,10 +40,10 @@ #define NUM_CLISTS 4 const int CF_max_chunks[CF_DIR_NUM][CF_NUM_CHANNELS] = {CF_CHANNEL_NUM_RX_CHUNKS_PER_TRANSACTION, CF_CHANNEL_NUM_TX_CHUNKS_PER_TRANSACTION}; -static void CF_CFDP_RecvIdle(transaction_t*); -static void CF_CFDP_RecvDrop(transaction_t*); +// static void CF_CFDP_RecvIdle(transaction_t*); +// static void CF_CFDP_RecvDrop(transaction_t*); -static void CF_CFDP_TxFile__(transaction_t *t, cfdp_class_t cfdp_class, uint8 keep, uint8 chan, uint8 priority); +// static void CF_CFDP_TxFile__(transaction_t *t, cfdp_class_t cfdp_class, uint8 keep, uint8 chan, uint8 priority); typedef struct trans_seq_arg_t { @@ -90,10 +90,12 @@ void CF_CFDP_ArmAckTimer(transaction_t *t) ** \endreturns ** *************************************************************************/ -static cfdp_class_t CF_CFDP_GetClass(transaction_t *ti) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static cfdp_class_t CF_CFDP_GetClass(transaction_t *ti) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Determine if a cfdp transaction is a sender or not @@ -106,10 +108,12 @@ static cfdp_class_t CF_CFDP_GetClass(transaction_t *ti) ** \endreturns ** *************************************************************************/ -static int CF_CFDP_IsSender(transaction_t *ti) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_IsSender(transaction_t *ti) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief arm inactivity timer @@ -122,10 +126,12 @@ static int CF_CFDP_IsSender(transaction_t *ti) ** The given transaction is active and initialized. ** *************************************************************************/ -static void CF_CFDP_ArmInactTimer(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_ArmInactTimer(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Dispatch received packet to its transaction. @@ -134,10 +140,12 @@ static void CF_CFDP_ArmInactTimer(transaction_t *t) ** t must not be null. It must be an initialized transaction. ** *************************************************************************/ -static void CF_CFDP_DispatchRecv(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_DispatchRecv(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Dispatches control to the active tx transaction. @@ -146,10 +154,12 @@ static void CF_CFDP_DispatchRecv(transaction_t *t) ** t must not be NULL. t must be a valid tx transaction. ** *************************************************************************/ -static void CF_CFDP_DispatchTx(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_DispatchTx(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Get an unused chunks structure off the chunks queue. @@ -162,10 +172,12 @@ static void CF_CFDP_DispatchTx(transaction_t *t) ** \endreturns ** *************************************************************************/ -static chunks_wrapper_t *CF_CFDP_FindUnusedChunks(channel_t *c, direction_t dir) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static chunks_wrapper_t *CF_CFDP_FindUnusedChunks(channel_t *c, direction_t dir) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Find an unused transaction on a channel. @@ -179,10 +191,12 @@ static chunks_wrapper_t *CF_CFDP_FindUnusedChunks(channel_t *c, direction_t dir) ** *************************************************************************/ /* finds an unused transaction and returns with it on no Q */ -static transaction_t *CF_CFDP_FindUnusedTransaction(channel_t *c) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static transaction_t *CF_CFDP_FindUnusedTransaction(channel_t *c) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Returns a history structure back to its unused state. @@ -210,10 +224,12 @@ void CF_CFDP_ResetHistory(channel_t *c, history_t *h) ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_FreeTransaction(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_FreeTransaction(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief List traversal function to check if the desired sequence number matches. @@ -227,10 +243,12 @@ static void CF_CFDP_FreeTransaction(transaction_t *t) ** \endreturns ** *************************************************************************/ -static int CF_CFDP_FindTransactionBySequenceNumber_(clist_node n, trans_seq_arg_t *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_FindTransactionBySequenceNumber_(clist_node n, trans_seq_arg_t *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Finds an active transaction by sequence number. @@ -308,10 +326,12 @@ pdu_header_t *CF_CFDP_MsgOutGet(const transaction_t *t, int silent) ** The PDU in the output buffer is ready to transmit. ** *************************************************************************/ -static void CF_CFDP_Send(uint8 chan_num, uint32 len) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_Send(uint8 chan_num, uint32 len) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Build the PDU header in the output buffer to prepare to send a packet. @@ -347,7 +367,7 @@ void Handler_CF_CFDP_ConstructPduHeader_Default(void *UserObj, UT_EntryKey_t Fun UT_Stub_CopyToLocal(UT_KEY(CF_CFDP_ConstructPduHeader), &forced_return, sizeof(forced_return)); - UT_Stub_SetReturnValue(CF_CFDP_ConstructPduHeader, forced_return); + UT_Stub_SetReturnValue(UT_KEY(CF_CFDP_ConstructPduHeader), forced_return); } pdu_header_t *CF_CFDP_ConstructPduHeader(const transaction_t *t, uint8 directive_code, cf_entity_id_t src_eid, cf_entity_id_t dst_eid, uint8 towards_sender, cf_transaction_seq_t tsn, int silent) @@ -401,7 +421,8 @@ cfdp_send_ret_t CF_CFDP_SendMd(transaction_t *t) *************************************************************************/ pdu_header_t *CF_CFDP_EarlySendFd(transaction_t *t) { - unimplemented(__FUNCTION__, __FILE__, __LINE__); + UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", __FILE__, __LINE__); + exit(-86); } /************************************************************************/ @@ -444,10 +465,12 @@ cfdp_send_ret_t CF_CFDP_SendFd(transaction_t *t, uint32 offset, int len) ** \endreturns ** *************************************************************************/ -static int CF_CFDP_FinishEofAck(pdu_header_t *pdu) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_FinishEofAck(pdu_header_t *pdu) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Build a eof PDU for transmit. @@ -577,7 +600,8 @@ cfdp_send_ret_t CF_CFDP_SendNak(transaction_t *t, int num_segment_requests) *************************************************************************/ pdu_header_t *CF_CFDP_EarlySendNak(transaction_t *t) { - unimplemented(__FUNCTION__, __FILE__, __LINE__); + UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", __FILE__, __LINE__); + exit(-86); } /************************************************************************/ @@ -596,10 +620,12 @@ pdu_header_t *CF_CFDP_EarlySendNak(transaction_t *t) ** \endreturns ** *************************************************************************/ -static int CF_CFDP_RecvPh(int chan_num) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_RecvPh(int chan_num) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Unpack a metadata PDU from a received message. @@ -733,10 +759,10 @@ int CF_CFDP_RecvNak(int *num_segment_requests) ** t must not be NULL. There must be a received message. ** *************************************************************************/ -static void CF_CFDP_RecvDrop(transaction_t *t) -{ - ++CF_AppData.hk.channel_hk[t->chan_num].counters.recv.dropped; -} +// static void CF_CFDP_RecvDrop(transaction_t *t) +// { +// ++CF_AppData.hk.channel_hk[t->chan_num].counters.recv.dropped; +// } /************************************************************************/ /** \brief Receive state function to process new rx transaction. @@ -752,10 +778,12 @@ static void CF_CFDP_RecvDrop(transaction_t *t) ** t must not be NULL. There must be a received message. ** *************************************************************************/ -static void CF_CFDP_RecvIdle(transaction_t *t) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_RecvIdle(transaction_t *t) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Initialization function for the cfdp engine @@ -774,7 +802,7 @@ static void CF_CFDP_RecvIdle(transaction_t *t) *************************************************************************/ int32 CF_CFDP_InitEngine(void) { - UT_DEFAULT_IMPL(CF_CFDP_InitEngine); + return UT_DEFAULT_IMPL(CF_CFDP_InitEngine); } /************************************************************************/ @@ -784,10 +812,12 @@ int32 CF_CFDP_InitEngine(void) ** c must not be NULL. ** *************************************************************************/ -static void CF_CFDP_ReceiveMessage(channel_t *c) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_ReceiveMessage(channel_t *c) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief List traversal function that cycles the first active tx. @@ -806,10 +836,12 @@ static void CF_CFDP_ReceiveMessage(channel_t *c) ** \endreturns ** *************************************************************************/ -static int CF_CFDP_CycleTx_(clist_node node, void *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_CycleTx_(clist_node node, void *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Cycle the current active tx or make a new one active. @@ -829,10 +861,12 @@ static int CF_CFDP_CycleTx_(clist_node node, void *context) ** \endreturns ** *************************************************************************/ -static void CF_CFDP_CycleTx(channel_t *c) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_CycleTx(channel_t *c) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief List traversal function that calls a r or s tick function. @@ -846,10 +880,12 @@ static void CF_CFDP_CycleTx(channel_t *c) ** \endreturns ** *************************************************************************/ -static int CF_CFDP_DoTick(clist_node node, void *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_DoTick(clist_node node, void *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Call R and then S tick functions for all active transactions. @@ -867,10 +903,12 @@ static int CF_CFDP_DoTick(clist_node node, void *context) ** \endreturns ** *************************************************************************/ -static void CF_CFDP_TickTransactions(channel_t *c) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_TickTransactions(channel_t *c) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Helper function to set tx file state in a transaction. @@ -879,10 +917,12 @@ static void CF_CFDP_TickTransactions(channel_t *c) ** t must not be NULL. ** *************************************************************************/ -static void CF_CFDP_TxFile__(transaction_t *t, cfdp_class_t cfdp_class, uint8 keep, uint8 chan, uint8 priority) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_TxFile__(transaction_t *t, cfdp_class_t cfdp_class, uint8 keep, uint8 chan, uint8 priority) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Helper function to set tx fiel state in a transaction. @@ -900,10 +940,12 @@ static void CF_CFDP_TxFile__(transaction_t *t, cfdp_class_t cfdp_class, uint8 ke ** \endreturns ** *************************************************************************/ -static void CF_CFDP_TxFile_(transaction_t *t, cfdp_class_t cfdp_class, uint8 keep, uint8 chan, uint8 priority, cf_entity_id_t dest_id) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_TxFile_(transaction_t *t, cfdp_class_t cfdp_class, uint8 keep, uint8 chan, uint8 priority, cf_entity_id_t dest_id) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Begin transmit of a file. @@ -957,10 +999,12 @@ int32 CF_CFDP_TxFile(const char src_filename[CF_FILENAME_MAX_LEN], const char ds ** \endreturns ** *************************************************************************/ -static int32 CF_CFDP_PlaybackDir_(playback_t *p, const char src_filename[CF_FILENAME_MAX_LEN], const char dst_filename[CF_FILENAME_MAX_LEN], cfdp_class_t cfdp_class, uint8 keep, uint8 chan, uint8 priority, cf_entity_id_t dest_id) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int32 CF_CFDP_PlaybackDir_(playback_t *p, const char src_filename[CF_FILENAME_MAX_LEN], const char dst_filename[CF_FILENAME_MAX_LEN], cfdp_class_t cfdp_class, uint8 keep, uint8 chan, uint8 priority, cf_entity_id_t dest_id) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Begin transmit of a directory. @@ -1015,10 +1059,12 @@ int32 CF_CFDP_PlaybackDir(const char src_filename[CF_FILENAME_MAX_LEN], const ch ** \endreturns ** *************************************************************************/ -static void CF_CFDP_ProcessPlaybackDirectory(channel_t *c, playback_t *p) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_ProcessPlaybackDirectory(channel_t *c, playback_t *p) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Update the playback or polling counter for channel HK @@ -1028,10 +1074,12 @@ static void CF_CFDP_ProcessPlaybackDirectory(channel_t *c, playback_t *p) ** must not be NULL. ** *************************************************************************/ -static void CF_CFDP_UpdatePollPbCounted(int chan_index, playback_t *pb, int up, uint8 *counter) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_UpdatePollPbCounted(int chan_index, playback_t *pb, int up, uint8 *counter) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Call CF_CFDP_ProcessPlaybackDirectory on all commanded playbacks. @@ -1044,10 +1092,12 @@ static void CF_CFDP_UpdatePollPbCounted(int chan_index, playback_t *pb, int up, ** c must not be NULL. ** *************************************************************************/ -static void CF_CFDP_ProcessPlaybackDirectories(channel_t *c) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_ProcessPlaybackDirectories(channel_t *c) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Kick the dir playback if timer elapsed. @@ -1060,10 +1110,12 @@ static void CF_CFDP_ProcessPlaybackDirectories(channel_t *c) ** c must not be NULL. ** *************************************************************************/ -static void CF_CFDP_ProcessPollingDirectories(channel_t *c) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CFDP_ProcessPollingDirectories(channel_t *c) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Cycle the engine. Called once per wakeup. @@ -1108,7 +1160,8 @@ void CF_CFDP_ResetTransaction(transaction_t *t, int keep_history) *************************************************************************/ int CF_CFDP_CopyDataToLv(lv_t *dest_lv, const uint8 *data, uint32 len) { - unimplemented(__FUNCTION__, __FILE__, __LINE__); + UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", __FILE__, __LINE__); + exit(-86); } /************************************************************************/ @@ -1125,7 +1178,8 @@ int CF_CFDP_CopyDataToLv(lv_t *dest_lv, const uint8 *data, uint32 len) *************************************************************************/ int CF_CFDP_CopyDataFromLv(uint8 buf[CF_FILENAME_MAX_LEN], const lv_t *src_lv) { - unimplemented(__FUNCTION__, __FILE__, __LINE__); + UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", __FILE__, __LINE__); + exit(-86); } /************************************************************************/ @@ -1152,10 +1206,12 @@ void CF_CFDP_CancelTransaction(transaction_t *t) ** \retcode Always 0 indicate list traversal should not exit early. \endcode ** \endreturns *************************************************************************/ -static int CF_CFDP_CloseFiles(clist_node n, void *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CFDP_CloseFiles(clist_node n, void *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Disables the cfdp engine and resets all state in it. diff --git a/unit-test/stubs/cf_chunk_stubs.c b/unit-test/stubs/cf_chunk_stubs.c index 374c8a2d..e64a8148 100644 --- a/unit-test/stubs/cf_chunk_stubs.c +++ b/unit-test/stubs/cf_chunk_stubs.c @@ -34,6 +34,7 @@ /* UT includes */ #include "uttest.h" #include "utstubs.h" +#include "uttools.h" #include "utgenstub.h" #define MAX(a,b) (((a) > (b)) ? (a) : (b)) @@ -45,10 +46,12 @@ ** chunks must not be NULL. ** *************************************************************************/ -static void CF_Chunks_EraseRange(chunks_t *chunks, index_t start, index_t end) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_Chunks_EraseRange(chunks_t *chunks, index_t start, index_t end) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Erase a single chunk. @@ -57,10 +60,12 @@ static void CF_Chunks_EraseRange(chunks_t *chunks, index_t start, index_t end) ** chunks must not be NULL. ** *************************************************************************/ -static void CF_Chunks_EraseChunk(chunks_t *chunks, index_t erase_index) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_Chunks_EraseChunk(chunks_t *chunks, index_t erase_index) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Insert a chunk before index_before. @@ -69,10 +74,12 @@ static void CF_Chunks_EraseChunk(chunks_t *chunks, index_t erase_index) ** chunks must not be NULL. chunk must not be NULL. ** *************************************************************************/ -static void CF_Chunks_InsertChunk(chunks_t *chunks, index_t index_before, const chunk_t *chunk) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_Chunks_InsertChunk(chunks_t *chunks, index_t index_before, const chunk_t *chunk) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Finds where a chunk should be inserted in the chunks. @@ -88,10 +95,12 @@ static void CF_Chunks_InsertChunk(chunks_t *chunks, index_t index_before, const ** \endreturns ** *************************************************************************/ -static index_t CF_Chunks_FindInsertPosition(chunks_t *chunks, const chunk_t *chunk) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static index_t CF_Chunks_FindInsertPosition(chunks_t *chunks, const chunk_t *chunk) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Possibly combines the given chunk with the previous chunk. @@ -104,10 +113,12 @@ static index_t CF_Chunks_FindInsertPosition(chunks_t *chunks, const chunk_t *chu ** \endreturns ** *************************************************************************/ -static int CF_Chunks_CombinePrevious(chunks_t *chunks, index_t i, const chunk_t *chunk) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_Chunks_CombinePrevious(chunks_t *chunks, index_t i, const chunk_t *chunk) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Possibly combines the given chunk with the next chunk. @@ -120,10 +131,12 @@ static int CF_Chunks_CombinePrevious(chunks_t *chunks, index_t i, const chunk_t ** \endreturns ** *************************************************************************/ -static int CF_Chunks_CombineNext(chunks_t *chunks, index_t i, const chunk_t *chunk) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_Chunks_CombineNext(chunks_t *chunks, index_t i, const chunk_t *chunk) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Finds the smallest size out of all chunks. @@ -136,10 +149,12 @@ static int CF_Chunks_CombineNext(chunks_t *chunks, index_t i, const chunk_t *chu ** \endreturns ** *************************************************************************/ -static index_t CF_Chunks_FindSmallestSize(const chunks_t *chunks) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static index_t CF_Chunks_FindSmallestSize(const chunks_t *chunks) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Insert a chunk. @@ -152,10 +167,12 @@ static index_t CF_Chunks_FindSmallestSize(const chunks_t *chunks) ** chunks must not be NULL. chunk must not be NULL. ** *************************************************************************/ -static void CF_Chunks_Insert(chunks_t *chunks, index_t i, const chunk_t *chunk) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_Chunks_Insert(chunks_t *chunks, index_t i, const chunk_t *chunk) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Public function to add a chunk. @@ -243,7 +260,8 @@ void CF_Chunks_Init(chunks_t *chunks, index_t CF_max_chunks, chunk_t *chunks_mem *************************************************************************/ void CF_ChunksReset(chunks_t *chunks) { - unimplemented(__FUNCTION__, __FILE__, __LINE__); + UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", __FILE__, __LINE__); + exit(-86); } /************************************************************************/ diff --git a/unit-test/stubs/cf_clist_stubs.c b/unit-test/stubs/cf_clist_stubs.c index 2981f677..340df49b 100644 --- a/unit-test/stubs/cf_clist_stubs.c +++ b/unit-test/stubs/cf_clist_stubs.c @@ -28,6 +28,8 @@ #include "cf_test_utils.h" #include "cf_cfdp.h" +extern type_of_context_CF_CList_Traverse_t type_of_context_CF_CList_Traverse; + /************************************************************************/ /** \brief Initialize a clist node. ** @@ -51,7 +53,8 @@ void CF_CList_InitNode(clist_node node) *************************************************************************/ void CF_CList_InsertFront(clist_node *head, clist_node node) { - unimplemented(__FUNCTION__, __FILE__, __LINE__); + UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", __FILE__, __LINE__); + exit(-86); } /************************************************************************/ @@ -131,8 +134,6 @@ void CF_CList_InsertAfter(clist_node *head, clist_node start, clist_node after) ** start must not be NULL. fn must be a valid function. ** *************************************************************************/ -extern type_of_context_CF_CList_Traverse_t type_of_context_CF_CList_Traverse = - NOT_YET_SET; void CF_CList_Traverse(clist_node start, clist_fn_t fn, void *context) { @@ -151,10 +152,10 @@ void CF_CList_Traverse(clist_node start, clist_fn_t fn, void *context) case TRAV_ARG_T: UT_Stub_CopyFromLocal(UT_KEY(CF_CList_Traverse), context, sizeof(int32)); - result_location = context + sizeof(int32); + result_location = (uint8*)context + sizeof(int32); UT_Stub_CopyToLocal(UT_KEY(CF_CList_Traverse), result_location, sizeof(int32)); - UT_Stub_CopyFromLocal(UT_KEY(CF_CList_Traverse), context + + UT_Stub_CopyFromLocal(UT_KEY(CF_CList_Traverse), (uint8*)context + (sizeof(int32) *2), sizeof(fn)); break; @@ -165,12 +166,12 @@ void CF_CList_Traverse(clist_node start, clist_fn_t fn, void *context) fn_size = sizeof(clist_fn_t); UT_Stub_CopyFromLocal(UT_KEY(CF_CList_Traverse), context, fn_size); - UT_Stub_CopyFromLocal(UT_KEY(CF_CList_Traverse), context + + UT_Stub_CopyFromLocal(UT_KEY(CF_CList_Traverse), (uint8*)context + fn_size, sizeof(void*)); //TODO: does the counter really need this behavior? all it is //counting is number of times stub is called which is already //counted. - result_location = context + fn_size + sizeof(void*); + result_location = (uint8*)context + fn_size + sizeof(void*); ++(*(int32*)result_location); /* increase count */ int32 count = *((int32*)result_location); /* count val to copy */ UT_Stub_CopyFromLocal(UT_KEY(CF_CList_Traverse), &count, @@ -186,8 +187,8 @@ void CF_CList_Traverse(clist_node start, clist_fn_t fn, void *context) { void* transaction_sequence_number = context; void* src_eid = - transaction_sequence_number + 4; /* uint32 - 4 bytes */ - void* t = src_eid + 4; /* uint8 - 4 bytes, no packing in struct */ + (uint8*)transaction_sequence_number + 4; /* uint32 - 4 bytes */ + void* t = (uint8*)src_eid + 4; /* uint8 - 4 bytes, no packing in struct */ UT_Stub_CopyFromLocal(UT_KEY(CF_CList_Traverse), transaction_sequence_number, sizeof(cf_transaction_seq_t)); @@ -199,8 +200,7 @@ void CF_CList_Traverse(clist_node start, clist_fn_t fn, void *context) break; default: - //TODO:printf CF_CList_Traverse should be made into a UT message - printf("CF_CList_Traverse Stub type_of_context_CF_CList_Traverse = NOT_YET_SET or a value not in case statement.\n" + UtAssertEx(false, UTASSERT_CASETYPE_TSF, __FILE__, __LINE__, "CF_CList_Traverse Stub type_of_context_CF_CList_Traverse = NOT_YET_SET or a value not in case statement.\n" "This means the context will not be used/saved correctly.\n" "It should be set to a value equal to the expected context type.\n"); } /* end switch */ diff --git a/unit-test/stubs/cf_cmd_stubs.c b/unit-test/stubs/cf_cmd_stubs.c index ea6c12b6..4cc7bc51 100644 --- a/unit-test/stubs/cf_cmd_stubs.c +++ b/unit-test/stubs/cf_cmd_stubs.c @@ -56,10 +56,12 @@ typedef struct { ** None ** *************************************************************************/ -static void CF_CmdAcc(void) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdAcc(void) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Increment the command rejected counter. @@ -68,10 +70,12 @@ static void CF_CmdAcc(void) ** None ** *************************************************************************/ -static void CF_CmdRej(void) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdRej(void) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Conditionally increment the command accept or reject counters. @@ -80,10 +84,12 @@ static void CF_CmdRej(void) ** None ** *************************************************************************/ -static void CF_CmdCond(int cond) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdCond(int cond) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief The no-operation command. @@ -98,10 +104,12 @@ static void CF_CmdCond(int cond) ** None ** *************************************************************************/ -static void CF_CmdNoop(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdNoop(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief The reset counters command. @@ -116,10 +124,12 @@ static void CF_CmdNoop(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdReset(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdReset(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Ground command to start a file transfer. @@ -132,10 +142,12 @@ static void CF_CmdReset(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdTxFile(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdTxFile(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Ground command to start directory playback. @@ -148,10 +160,12 @@ static void CF_CmdTxFile(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdPlaybackDir(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdPlaybackDir(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Common logic for all channel-based commands. @@ -170,10 +184,12 @@ static void CF_CmdPlaybackDir(CFE_SB_Buffer_t* msg) ** \endreturns ** *************************************************************************/ -static int CF_DoChanAction(cf_cmd_unionargs_t *cmd, const char *errstr, chan_action_fn_t fn, void *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_DoChanAction(cf_cmd_unionargs_t *cmd, const char *errstr, chan_action_fn_t fn, void *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Channel action to set the frozen bit for a channel. @@ -186,10 +202,12 @@ static int CF_DoChanAction(cf_cmd_unionargs_t *cmd, const char *errstr, chan_act ** \endreturns ** *************************************************************************/ -static int CF_DoFreezeThaw(uint8 chan_num, const bool_arg_t *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_DoFreezeThaw(uint8 chan_num, const bool_arg_t *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Freeze a channel. @@ -198,10 +216,12 @@ static int CF_DoFreezeThaw(uint8 chan_num, const bool_arg_t *context) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdFreeze(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdFreeze(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Thaw a channel. @@ -210,10 +230,12 @@ static void CF_CmdFreeze(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdThaw(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdThaw(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Search for a transaction across all channels. @@ -226,10 +248,12 @@ static void CF_CmdThaw(CFE_SB_Buffer_t* msg) ** \endreturns ** *************************************************************************/ -static transaction_t *CF_CFDP_FindTransactionBySequenceNumberAllChannels(cf_transaction_seq_t ts, cf_entity_id_t eid) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static transaction_t *CF_CFDP_FindTransactionBySequenceNumberAllChannels(cf_transaction_seq_t ts, cf_entity_id_t eid) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /* CF_TsnChanAction() returns the number of transactions acted upon */ /************************************************************************/ @@ -249,10 +273,12 @@ static transaction_t *CF_CFDP_FindTransactionBySequenceNumberAllChannels(cf_tran ** \endreturns ** *************************************************************************/ -static int CF_TsnChanAction(cf_cmd_transaction_t *cmd, const char *cmdstr, CF_TsnChanAction_fn_t fn, void *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_TsnChanAction(cf_cmd_transaction_t *cmd, const char *cmdstr, CF_TsnChanAction_fn_t fn, void *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Set the suspended bit in a transaction. @@ -261,10 +287,12 @@ static int CF_TsnChanAction(cf_cmd_transaction_t *cmd, const char *cmdstr, CF_Ts ** t must not be NULL. context must not be NULL. ** *************************************************************************/ -static void CF_DoSuspRes_(transaction_t *t, susp_res_arg_t *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_DoSuspRes_(transaction_t *t, susp_res_arg_t *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Handle transaction suspend and resume commands. @@ -277,10 +305,12 @@ static void CF_DoSuspRes_(transaction_t *t, susp_res_arg_t *context) ** cmd must not be NULL. ** *************************************************************************/ -static void CF_DoSuspRes(cf_cmd_transaction_t *cmd, uint8 action) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_DoSuspRes(cf_cmd_transaction_t *cmd, uint8 action) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Handle transaction suspend command. @@ -289,10 +319,12 @@ static void CF_DoSuspRes(cf_cmd_transaction_t *cmd, uint8 action) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdSuspend(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdSuspend(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Handle transaction resume command. @@ -301,10 +333,12 @@ static void CF_CmdSuspend(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdResume(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdResume(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief tsn chan action to cancel a transaction. @@ -313,10 +347,12 @@ static void CF_CmdResume(CFE_SB_Buffer_t* msg) ** t must not be NULL. ** *************************************************************************/ -static void CF_CmdCancel_(transaction_t *t, void *ignored) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdCancel_(transaction_t *t, void *ignored) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Handle a cancel ground command. @@ -325,10 +361,12 @@ static void CF_CmdCancel_(transaction_t *t, void *ignored) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdCancel(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdCancel(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief tsn chan action to abandon a transaction. @@ -337,10 +375,12 @@ static void CF_CmdCancel(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdAbandon_(transaction_t *t, void *ignored) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdAbandon_(transaction_t *t, void *ignored) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Handle an abandon ground command. @@ -349,10 +389,12 @@ static void CF_CmdAbandon_(transaction_t *t, void *ignored) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdAbandon(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdAbandon(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Sets the dequeue enable/disable flag for a channel. @@ -361,10 +403,12 @@ static void CF_CmdAbandon(CFE_SB_Buffer_t* msg) ** context must not be NULL. ** *************************************************************************/ -static void CF_DoEnableDisableDequeue(uint8 chan_num, const bool_arg_t *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_DoEnableDisableDequeue(uint8 chan_num, const bool_arg_t *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Handle an enable dequeue ground command. @@ -373,10 +417,12 @@ static void CF_DoEnableDisableDequeue(uint8 chan_num, const bool_arg_t *context) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdEnableDequeue(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdEnableDequeue(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Handle a disable dequeue ground command. @@ -385,10 +431,12 @@ static void CF_CmdEnableDequeue(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdDisableDequeue(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdDisableDequeue(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Sets the enable/disable flag for the specified polling directory. @@ -397,10 +445,12 @@ static void CF_CmdDisableDequeue(CFE_SB_Buffer_t* msg) ** context must not be NULL. ** *************************************************************************/ -static int CF_DoEnableDisablePolldir(uint8 chan_num, const bool_msg_arg_t *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_DoEnableDisablePolldir(uint8 chan_num, const bool_msg_arg_t *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Enable a polling dir ground command. @@ -409,10 +459,12 @@ static int CF_DoEnableDisablePolldir(uint8 chan_num, const bool_msg_arg_t *conte ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdEnablePolldir(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdEnablePolldir(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Disable a polling dir ground command. @@ -421,10 +473,12 @@ static void CF_CmdEnablePolldir(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdDisablePolldir(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdDisablePolldir(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Purge the history queue for the given channel. @@ -433,10 +487,12 @@ static void CF_CmdDisablePolldir(CFE_SB_Buffer_t* msg) ** n must not be NULL. c must not be NULL. ** *************************************************************************/ -static int CF_PurgeHistory(clist_node n, channel_t *c) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_PurgeHistory(clist_node n, channel_t *c) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Purge the pending transaction queue. @@ -445,10 +501,12 @@ static int CF_PurgeHistory(clist_node n, channel_t *c) ** n must not be NULL. ** *************************************************************************/ -static int CF_PurgeTransaction(clist_node n, void *ignored) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_PurgeTransaction(clist_node n, void *ignored) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Channel action command to perform purge queue operations. @@ -465,10 +523,12 @@ static int CF_PurgeTransaction(clist_node n, void *ignored) ** \endreturns ** *************************************************************************/ -static int CF_DoPurgeQueue(uint8 chan_num, cf_cmd_unionargs_t *cmd) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_DoPurgeQueue(uint8 chan_num, cf_cmd_unionargs_t *cmd) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Ground command to purge either the history or pending queues. @@ -477,10 +537,12 @@ static int CF_DoPurgeQueue(uint8 chan_num, cf_cmd_unionargs_t *cmd) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdPurgeQueue(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdPurgeQueue(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Ground command to write a file with queue information. @@ -489,10 +551,12 @@ static void CF_CmdPurgeQueue(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdWriteQueue(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdWriteQueue(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Ground command to send configuration parameters. @@ -501,10 +565,12 @@ static void CF_CmdWriteQueue(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdSendCfgParams(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdSendCfgParams(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Checks if the value is less than or equal to the max pdu size. @@ -517,10 +583,12 @@ static void CF_CmdSendCfgParams(CFE_SB_Buffer_t* msg) ** \endreturns ** *************************************************************************/ -static int CF_CmdValidateChunkSize(uint32 val, uint8 chan_num /* ignored */) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_CmdValidateChunkSize(uint32 val, uint8 chan_num /* ignored */) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Perform a configuration get/set operation. @@ -534,10 +602,12 @@ static int CF_CmdValidateChunkSize(uint32 val, uint8 chan_num /* ignored */) *************************************************************************/ /* combine getset into a single function with a branch to avoid wasted memory footprint with duplicate * logic for finding the parameter */ -static void CF_CmdGetSetParam(uint8 is_set, uint8 param_id, uint32 value, uint8 chan_num) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdGetSetParam(uint8 is_set, uint8 param_id, uint32 value, uint8 chan_num) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Ground command to set a configuration parameter. @@ -546,10 +616,12 @@ static void CF_CmdGetSetParam(uint8 is_set, uint8 param_id, uint32 value, uint8 ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdSetParam(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdSetParam(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Ground command to set a configuration parameter. @@ -558,10 +630,12 @@ static void CF_CmdSetParam(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdGetParam(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdGetParam(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Ground command enable engine. @@ -570,10 +644,12 @@ static void CF_CmdGetParam(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdEnableEngine(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdEnableEngine(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Ground command disable engine. @@ -582,10 +658,12 @@ static void CF_CmdEnableEngine(CFE_SB_Buffer_t* msg) ** msg must not be NULL. ** *************************************************************************/ -static void CF_CmdDisableEngine(CFE_SB_Buffer_t* msg) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static void CF_CmdDisableEngine(CFE_SB_Buffer_t* msg) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Process any ground command contained in the given message. diff --git a/unit-test/stubs/cf_timer_stubs.c b/unit-test/stubs/cf_timer_stubs.c index 04acd16b..c81708b0 100644 --- a/unit-test/stubs/cf_timer_stubs.c +++ b/unit-test/stubs/cf_timer_stubs.c @@ -39,10 +39,12 @@ ** \endreturns ** *************************************************************************/ -static uint32 CF_Timer_Sec2Ticks(cf_timer_sec_t sec) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static uint32 CF_Timer_Sec2Ticks(cf_timer_sec_t sec) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Initialize a timer with a relative number of seconds. diff --git a/unit-test/stubs/cf_utils_stubs.c b/unit-test/stubs/cf_utils_stubs.c index 61332550..67cbe3c2 100644 --- a/unit-test/stubs/cf_utils_stubs.c +++ b/unit-test/stubs/cf_utils_stubs.c @@ -65,10 +65,12 @@ typedef struct { ** \endreturns ** *************************************************************************/ -static int CF_TraverseHistory(clist_node n, trav_arg_t *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_TraverseHistory(clist_node n, trav_arg_t *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Walk over all transactions and print information from their history. @@ -82,10 +84,12 @@ static int CF_TraverseHistory(clist_node n, trav_arg_t *context) ** \endreturns ** *************************************************************************/ -static int CF_TraverseTransactions(clist_node n, trav_arg_t *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_TraverseTransactions(clist_node n, trav_arg_t *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Write a transaction-based queue's transaction history to a file. @@ -142,10 +146,12 @@ int32 CF_WriteHistoryQueueDataToFile(int32 fd, channel_t *c, direction_t dir) ** \endreturns ** *************************************************************************/ -static int CF_PrioSearch(clist_node node, void *context) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_PrioSearch(clist_node node, void *context) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Insert a transaction into a priority sorted transaction queue. @@ -183,10 +189,12 @@ void CF_InsertSortPrio(transaction_t *t, cf_queue_index_t q) ** \endreturns ** *************************************************************************/ -static int CF_TraverseAllTransactions_(clist_node n, traverse_all_args_t *args) -{ - unimplemented(__FUNCTION__, __FILE__, __LINE__); -} +// static int CF_TraverseAllTransactions_(clist_node n, traverse_all_args_t *args) +// { +// UtPrintf("NOT YET IMPLEMENTED stub in \n%s:line #%d\n", +// __FILE__, __LINE__); +// exit(-86); +// } /************************************************************************/ /** \brief Traverses all transactions on all active queues and performs an operation on them. diff --git a/unit-test/utilities/cf_test_utils.c b/unit-test/utilities/cf_test_utils.c index 7e3c7464..8aba5625 100644 --- a/unit-test/utilities/cf_test_utils.c +++ b/unit-test/utilities/cf_test_utils.c @@ -52,6 +52,8 @@ void cf_tests_Setup(void) set_default_ptr(&context_CFE_MSG_SetMsgTime.MsgPtr); context_CFE_MSG_SetMsgTime.Time.Seconds = UT_INT_32_DEFAULT; context_CFE_MSG_SetMsgTime.Time.Subseconds = UT_INT_32_DEFAULT; + + type_of_context_CF_CList_Traverse = NOT_YET_SET; } void cf_tests_Teardown(void) @@ -365,12 +367,6 @@ uint16 Any_uint16_ExceptThese(uint16 exceptions[], uint8 num_exceptions) { uint8 i = 0; uint16 random_val = Any_uint16(); - printf("exceptions = %p\n", exceptions); - for (i=0;i /* UT includes */ #include "ut_utils_cfe_hooks.h" +/* NOTE: This was designed and used before the advent of the ut-assert hander +** ability. It's use is only for the legacy code that needed it before the +** changes to ut-assert. Handlers should be used instead of this function */ + /*****************************************************************************/ /** * \brief Turns a standard ut-assert stub into a unit test reporter. @@ -73,15 +78,15 @@ */ int32 stub_reporter_hook(void *UserObj, int32 StubRetcode, uint32 CallCount, const UT_StubContext_t *Context) { - uint8 i = 0; /* i is index */ - uint8 size_used = 0; /* determines size of argument to be saved */ - void* val_location = NULL; /* pointer to arg value to be saved */ - void* obj_ptr; /* tracker indicates where to push data into UserObj */ + uint8 i = 0; /* i is index */ + uint8 size_used = 0; /* determines size of argument to be saved */ + const void* val_location = NULL; /* pointer to arg value to be saved */ + uint8* obj_ptr; /* tracker indicates where to push data into UserObj */ /* Determine where in the UserObj we should be located dependent upon CallCount */ if (CallCount == 0) { - obj_ptr = UserObj; + obj_ptr = (uint8*)UserObj; } else { @@ -101,7 +106,7 @@ int32 stub_reporter_hook(void *UserObj, int32 StubRetcode, uint32 CallCount, con } /* obj_ptr moves a full context_size for every call (initial value is 0) -- user object for calls > 1 must be an array of contexts */ - obj_ptr = UserObj + (context_size * CallCount); + obj_ptr = (uint8*)UserObj + (context_size * CallCount); } for(i = 0; i < Context->ArgCount; ++i) @@ -123,29 +128,6 @@ int32 stub_reporter_hook(void *UserObj, int32 StubRetcode, uint32 CallCount, con obj_ptr += size_used; } - /* All arguments saved to context, check for va */ - - /* va is UNDER CONSTRUCTION due to multi-call changes */ - /* va exists when there is a variable argument function like CFE_EVS_SendEvent */ - // if (va != NULL) - // { - // /* user object expecting any va MUST have a uint8 directly after */ - // uint8 num_args = *(uint8*)obj_ptr; - // /* TODO: 8 bytes is arbitrary and is currenlty what my system supports, this should be platform independent somehow */ - // uint16 bytes_of_data = num_args * 8; - - // /* step past the argument uint8 in the user object */ - // ++obj_ptr; - // /* copy as much data as the number of args in the reg_save_area starting at the gp_offset */ - // memcpy(obj_ptr, va[0].reg_save_area + va[0].gp_offset, bytes_of_data); - - // /* return 0 is success? */ - // return 0; // } return StubRetcode; } - -// int32 stub_reporter_hook(void *UserObj, int32 StubRetcode, uint32 CallCount, const UT_StubContext_t *Context) -// { -// return stub_reporter_va_hook(UserObj, StubRetcode, CallCount, Context, NULL); -// } \ No newline at end of file diff --git a/unit-test/utilities/ut_utils_cfe_hooks.h b/unit-test/utilities/ut_utils_cfe_hooks.h index 67097bc7..5c2d1be0 100644 --- a/unit-test/utilities/ut_utils_cfe_hooks.h +++ b/unit-test/utilities/ut_utils_cfe_hooks.h @@ -7,6 +7,5 @@ /* UT includes */ #include "utstubs.h" - int32 stub_reporter_hook(void *UserObj, int32 StubRetcode, uint32 CallCount, const UT_StubContext_t *Context); #endif \ No newline at end of file